@vertigis/viewer-spec/messaging/registry/sketching.d.ts

VertiGIS Viewer Specification

import type Graphic from "@arcgis/core/Graphic";
import type Point from "@arcgis/core/geometry/Point";
import type LineSymbol3D from "@arcgis/core/symbols/LineSymbol3D";
import type PictureFillSymbol from "@arcgis/core/symbols/PictureFillSymbol";
import type PictureMarkerSymbol from "@arcgis/core/symbols/PictureMarkerSymbol";
import type PointSymbol3D from "@arcgis/core/symbols/PointSymbol3D";
import type PolygonSymbol3D from "@arcgis/core/symbols/PolygonSymbol3D";
import type SimpleFillSymbol from "@arcgis/core/symbols/SimpleFillSymbol";
import type SimpleLineSymbol from "@arcgis/core/symbols/SimpleLineSymbol";
import type SimpleMarkerSymbol from "@arcgis/core/symbols/SimpleMarkerSymbol";
import type TextSymbol from "@arcgis/core/symbols/TextSymbol";
import type { GeometryUnion, SymbolUnion } from "@arcgis/core/unionTypes.js";
import type { Feature } from "@vertigis/arcgis-extensions/data/Feature.js";
import type { LineSymbol3DJson, PictureFillSymbolJson, PictureMarkerSymbolJson, PointSymbol3DJson, PolygonSymbol3DJson, SimpleFillSymbolJson, SimpleLineSymbolJson, SimpleMarkerSymbolJson, SymbolJson } from "@vertigis/arcgis-extensions/json/SymbolJson.js";
import type { MapExtension } from "@vertigis/arcgis-extensions/mapping/MapExtension";
import type { SnappingProperties } from "../../app-config/web/SnappingProperties.js";
import type { TopologyProperties } from "../../app-config/web/TopologyProperties.js";
import type { Command } from "../Command.js";
import { CommandRegistry } from "../CommandRegistry.js";
import type { Event } from "../Event.js";
import { EventRegistry } from "../EventRegistry.js";
import type { Operation } from "../Operation.js";
import { OperationRegistry } from "../OperationRegistry.js";
import type { FeaturesLike, GeometryLike, GraphicsLike, HasMaps, Maps, MapsLike } from "../common.js";
import type { EditSymbolResult } from "./drawing.js";
import type { GeodeticCurveType, LengthUnits, LengthUnitsMobile, ReferenceLine } from "./geometry.js";
/**
 * A representation of a 2D vector or point.
 */
export interface Vector2D {
    /**
     * The x component.
     */
    x: number;
    /**
     * The y component.
     */
    y: number;
}
/**
 * A set of symbols that can be used to sketch geometries.
 */
export interface SymbolSet {
    /**
     * The symbol used to draw points.
     */
    pointSymbol?: SimpleMarkerSymbol | SimpleMarkerSymbolJson | PictureMarkerSymbol | PictureMarkerSymbolJson;
    /**
     * The symbol used to draw 3D points.
     */
    pointSymbol3D?: PointSymbol3D | PointSymbol3DJson;
    /**
     * The symbol used to draw lines.
     */
    lineSymbol?: SimpleLineSymbol | SimpleLineSymbolJson;
    /**
     * The symbol used to draw 3D lines.
     */
    lineSymbol3D?: LineSymbol3D | LineSymbol3DJson;
    /**
     * The symbol used to draw polygons.
     */
    polygonSymbol?: SimpleFillSymbol | SimpleFillSymbolJson | PictureFillSymbol | PictureFillSymbolJson;
    /**
     * The symbol used to draw 3D polygons.
     */
    polygonSymbol3D?: PolygonSymbol3D | PolygonSymbol3DJson;
}
/**
 * The type of tool used for sketching.
 */
export declare enum SketchTool {
    POINT = "point",
    MULTIPOINT = "multipoint",
    /**
     * Not supported in VertiGIS Studio Mobile.
     */
    LINE = "line",
    POLYLINE = "polyline",
    POLYGON = "polygon",
    EXTENT = "extent",
    /**
     * Not supported in VertiGIS Studio Mobile.
     */
    SQUARE = "square",
    /**
     * Not supported in VertiGIS Studio Mobile.
     */
    CIRCLE = "circle"
}
/**
 * Indicates whether a new point should be added before or after the active
 * point in a sketch.
 */
export type AddNodeOrder = "add-after-active" | "add-before-active";
/**
 * Deprecated - use "sketching.move-point" with {@link MovePointArgs}.
 *
 * @deprecated
 */
export interface MoveNodeArgs extends HasMaps {
    /**
     * The point to move, which must already exist within the active sketch. If
     * not provided, the active point will be used.
     */
    node?: Point;
    /**
     * The new position for the point.
     */
    position: GeometryUnion;
}
/**
 * The arguments for the "sketching.move-point" command.
 */
export interface MovePointArgs extends HasMaps {
    /**
     * The point to move, which must already exist within the active sketch. If
     * this property is undefined and no geometry and pointIndex are specified,
     * the active point(s) will be moved.
     */
    point?: Point;
    /**
     * The geometry where the point exists, if multiple are present in an active
     * editing session. This property is required if pointIndex and/or partIndex
     * are defined.
     */
    geometry?: GeometryUnion;
    /**
     * The index of the point. If this property is defined, the 'geometry'
     * property must also be defined.
     */
    pointIndex?: number;
    /**
     * The part of the geometry where the point exists. Required for polyline
     * and polygon geometry types when the geometry and pointIndex properties
     * are defined.
     */
    partIndex?: number;
    /**
     * The new point that will replace the target point within an active sketch
     * or edit geometry. If this property is defined, the distance property will
     * be ignored.
     */
    newPoint?: Point;
    /**
     * An amount to move the point(s) on the X and Y axes. If the newPoint
     * property is defined, this property will be ignored.
     */
    distance?: Vector2D;
    /**
     * The units of the above distance. Optional, will default to the units used
     * by the measurement service associated with the map.
     */
    units?: LengthUnits;
}
/**
 * Deprecated - use "sketching.set-active-points" with
 * {@link SetActivePointsArgs}.
 *
 * @deprecated
 */
export interface SwitchActiveNodeArgs extends HasMaps {
    /**
     * The new point that will become the active point of an active sketch.
     */
    node: Point;
}
/**
 * The arguments for the "sketching.set-active-points" command.
 */
export interface SetActivePointsArgs extends HasMaps {
    /**
     * The new point(s) that will become active in the sketch or editing
     * session. Sketching only supports one active point; if multiple are
     * specified, then only the first will be set as active.
     */
    points?: Point | Point[];
    /**
     * The geometry where the new active point exists, if multiple are present
     * in an active editing session. This property is required if pointIndex
     * and/or partIndex are defined.
     */
    geometry?: GeometryUnion;
    /**
     * The index of the new active point. If this property is defined, the
     * geometry property must be defined.
     */
    pointIndex?: number;
    /**
     * The part of the geometry where the new active point exists. Required for
     * polyline and polygon geometry types when the geometry and pointIndex
     * properties are defined.
     */
    partIndex?: number;
}
/**
 * Arguments for the "sketching.capture-geometry" operation.
 */
export interface CaptureGeometryArgs {
    /**
     * The maps to activate drawing on. By default it will be all maps.
     */
    maps?: MapsLike;
    /**
     * The geometry/shape to use for sketching. * Multiple sketch tools are only
     * supported by VertiGIS Studio Web. When multiple sketch tools are
     * provided, the sketch will begin with the first one in the list. If
     * "point" is the first of multiple options in the list, click actions will
     * create points while click-and-drag actions will automatically begin the
     * freehand variation of the next included geometry type. The types "point",
     * "line" and "square" are supported only in Web.
     */
    geometryType: SketchTool | SketchTool[];
    /**
     * An optional symbol to use. SymbolSets are not supported by VertiGIS
     * Studio Mobile.
     */
    symbol?: SymbolJson | SymbolSet;
    /**
     * The maximum number of segments permitted for a polyline or polygon
     * sketch. Default is no limit. Mobile only.
     */
    maxSegments?: number;
    /**
     * The settings to be applied to the sketch. Mobile only.
     */
    editorSettings?: GeometryEditorSettings;
    /**
     * Disables freehand sketching during the draw session. Web only.
     */
    disableFreehand?: boolean;
    /**
     * Web only. Additional settings that are specific to sketching plugins,
     * keyed by plugin ID. The only currently supported plugin is "snapping". A
     * boolean value can also be assigned to completely disable, or enable with
     * default settings.
     */
    pluginSettings?: Record<string, boolean | Record<string, unknown>>;
}
/**
 * Result of the "sketching.capture-geometry" operation.
 */
export interface CaptureGeometryResult {
    /**
     * The geometry that was captured.
     */
    geometry: GeometryUnion;
    /**
     * The map that the user sketched the geometry on. Unavailable in VertiGIS
     * Studio Mobile.
     */
    maps: MapsLike;
    /**
     * The symbol that was used. Unavailable in VertiGIS Studio Web.
     */
    symbol?: SymbolUnion;
}
/**
 * A generic context for operations that act on geometries.
 */
export interface GeometryOperationBase {
    /**
     * The maps to activate editing on. By default it will be all maps.
     */
    maps?: MapsLike;
    /**
     * The geometries to edit.
     */
    geometry?: GeometryLike;
    /**
     * The graphics containing geometries to edit. The graphics will pass
     * through and be assigned the altered geometries. Not supported in Mobile.
     */
    graphics?: GraphicsLike;
    /**
     * The features containing geometries to edit. The features will pass
     * through and be assigned the altered geometries. Not supported in Mobile.
     */
    features?: FeaturesLike;
    /**
     * Flag all inputs as measured geometries. Geometry operations will show
     * measurements for in progress operations. Not supported in Mobile.
     */
    isMeasurement?: boolean;
    /**
     * An optional symbol to use while editing.
     */
    symbol?: SimpleLineSymbol | PictureFillSymbol | PictureMarkerSymbol | SimpleFillSymbol | SimpleMarkerSymbol | TextSymbol | Symbol;
}
/**
 * Arguments for the "sketching.edit-geometry" operation.
 */
export interface EditGeometryArgs extends GeometryOperationBase {
    /**
     * The options for this edit operation. Not supported in Mobile. Web only.
     *
     * @webOnly
     */
    options?: EditGeometryOptions;
    /**
     * Web only. Additional settings that are specific to sketching plugins,
     * keyed by plugin ID. The only currently supported plugin is "snapping". A
     * boolean value can also be assigned to completely disable, or enable with
     * default settings.
     */
    pluginSettings?: Record<string, boolean | Record<string, unknown>>;
}
/**
 * Options for the "sketching.edit-geometry operation.
 *
 * @webOnly
 */
export interface EditGeometryOptions {
    /**
     * Whether to allow deletion of the edited geometry. Defaults to false.
     */
    enableDelete?: boolean;
    /**
     * Whether to allow rotation of the edited geometry. Defaults to true.
     */
    enableRotation?: boolean;
    /**
     * Whether to allow scaling of the edited geometry. Defaults to true.
     */
    enableScaling?: boolean;
    /**
     * Whether to allow the user to toggle to the non-default scale mode.
     * Defaults to true.
     */
    enableScaleModeToggle?: boolean;
    /**
     * Whether to allow moving of the edited geometry. Defaults to true. Not
     * applicable when editing in 3D.
     */
    enableMoving?: boolean;
    /**
     * Whether to allow the user to add, move, and remove vertices from a
     * geometry. Defaults to true.
     */
    enableVertexEditing?: boolean;
    /**
     * Setting "free" allows independent scaling on the x and y axis,
     * "preserve-aspect-ratio" constrains scaling to the original aspect ratio.
     * Defaults to "preserve-aspect-ratio".
     */
    scaleMode?: "free" | "preserve-aspect-ratio";
    /**
     * Whether the resulting geometry is validated before it's returned from the
     * operation. If the geometry is invalid upon completion, an error is
     * thrown. Defaults to true.
     */
    validateGeometry?: boolean;
    /**
     * Where to anchor the geometry when performing a free scale operation.
     * Defaults to "center".
     */
    anchor?: "center" | "opposite";
}
/**
 * Result of the "sketching.edit-geometry" operation.
 */
export interface EditGeometryResult extends GeometryOperationBase {
    /**
     * Any coincident Features that were included in the geometry editing
     * session, if topological editing was enabled. Web only.
     */
    coincidentFeatures?: Feature[];
    /**
     * Any coincident Graphics that were included in the geometry editing
     * session, if topological editing was enabled. Web only.
     */
    coincidentGraphics?: CoincidentEditingGraphicResult[];
}
/**
 * The result of a Graphic being coincidentally edited as a part of a editing
 * session with topological editing enabled. Web Only.
 */
export interface CoincidentEditingGraphicResult {
    /**
     * The coincident graphic that was included in an editing session with
     * topological editing enabled.
     */
    graphic: Graphic;
    /**
     * A copy of the original geometry of the Graphic, before it was edited.
     */
    originalGeometry: GeometryUnion;
}
/**
 * Arguments for the "sketching.move-geometry" operation.
 */
export interface MoveGeometryArgs extends GeometryOperationBase {
    /**
     * An amount to move the geometry on the X and Y axes.
     */
    distance: Vector2D;
    /**
     * The units of the above distance. Optional, will default to the units used
     * by the measurement service associated with the map.
     */
    units?: LengthUnits;
}
/**
 * Arguments for the "sketching.scale-geometry" operation.
 */
export interface ScaleGeometryArgs extends GeometryOperationBase {
    /**
     * The amount to scale the geometry, specified either uniformly or
     * independently on the x and y axis. Point geometries will not be modified
     * by this operation.
     */
    scale: Vector2D | number;
}
/**
 * Arguments for the "sketching.rotate-geometry" operation.
 */
export interface RotateGeometryArgs extends GeometryOperationBase {
    /**
     * The number of degrees to rotate the geometry.
     */
    degrees: number;
    /**
     * The origin around which to rotate the geometry. Defaults to the centroid.
     */
    origin?: Point;
}
/**
 * Arguments for the "sketching.stop" operation.
 */
export interface StopGeometryEditArgs {
    /**
     * The maps on which to stop editing geometry.
     */
    maps: MapsLike;
    /**
     * Whether to validate the geometry before returning it. Defaults to true if
     * not set.
     */
    validateGeometry?: boolean;
}
/**
 * Arguments for the "sketching.add-point" command.
 */
export interface AddPointArgs extends HasMaps {
    /**
     * The new point to be added.
     */
    newPoint: Point;
    /**
     * The geometry to add the point to, if multiple are present in an active
     * editing session. Not supported by Mobile.
     */
    geometry?: GeometryUnion;
}
/**
 * Arguments for the "sketching.insert-point" command.
 */
export interface InsertPointArgs extends HasMaps {
    /**
     * The index of the part to which the point will be added. If null, the last
     * part will be used.
     */
    partIndex?: number;
    /**
     * The index at which the point will be added. If null, the point will be
     * added as the last point.
     */
    pointIndex?: number;
    /**
     * The new point to be added.
     */
    newPoint: Point;
    /**
     * The geometry to add the point to, if multiple are present in an active
     * editing session. Not supported by Mobile.
     */
    geometry?: GeometryUnion;
}
/**
 * Deprecated - Mobile users should rather use "geometry.add-point"; Web users
 * should use "sketching.add-point" with {@link AddPointArgs} or
 * "sketching.insert-point" with {@link InsertPointArgs} instead.
 *
 * @deprecated
 */
export interface AddNodeToGeometryArgs extends HasMaps {
    /**
     * The initial geometry to add the point to. Can be null.
     */
    geometry: GeometryUnion;
    /**
     * The type of geometry to create if the initial geometry is null. In
     * VertiGIS Studio Mobile, this value must be 'polygon' or 'polyline'. In
     * VertiGIS Studio Web, this value may also be null if the point being added
     * is intended to be added to the active sketch.
     */
    geometryType: string;
    /**
     * A point geometry to add to the initial geometry. In VertiGIS Studio Web,
     * this value may be null if the intention is to add a point at the position
     * of the active point of an active sketch.
     */
    node: GeometryUnion;
    /**
     * Indicates whether the new point should be added before or after the
     * active point in the sketch. Not supported by VertiGIS Studio Mobile.
     */
    nodeOrder?: AddNodeOrder;
}
/**
 * Arguments for the "sketching.delete" command.
 */
export interface DeleteGeometryArgs extends HasMaps {
    /**
     * The point to remove from the geometry. If this property is defined, the
     * 'pointIndex' and 'partIndex' properties are ignored. If no point nor
     * pointIndex/partIndex are specified, any active points will be deleted. If
     * there are no active points, the entire geometry will be deleted.
     */
    point?: Point;
    /**
     * The geometry to remove a point from. If this property is not specified,
     * any active vertices will be deleted.
     */
    geometry?: GeometryUnion;
    /**
     * The index of the point that should be removed from the geometry. If this
     * property is defined, the geometry property must also be defined.
     */
    pointIndex?: number;
    /**
     * The index of the part of the geometry that the point should be removed
     * from. Required for polyline and polygon geometry types when the geometry
     * and pointIndex properties are defined.
     */
    partIndex?: number;
}
/**
 * Arguments for the "sketching.set-geometry-mode" command.
 */
export interface SetGeometryModeArgs extends HasMaps {
    /**
     * The geometry mode to switch to. VertiGIS Studio Mobile only supports
     * "line" and "area".
     */
    editorGeometryMode: EditorGeometryMode | SketchTool;
}
/**
 * Arguments for the "sketching.set-interaction-mode" command.
 */
export interface SetInteractionModeArgs extends HasMaps {
    /**
     * The interaction mode to switch to.
     */
    editorInteractionMode: EditorInteractionMode;
}
/**
 * Arguments for the "sketching.start-streaming" command.
 */
export interface StartStreamingArgs extends HasMaps {
    /**
     * An optional value indicating, in seconds, how often points should be
     * recorded.
     */
    interval?: number;
}
/**
 * The editor geometry mode.
 */
export type EditorGeometryMode = "line" | "area";
/**
 * The editor interaction mode.
 */
export type EditorInteractionMode = "centerCrosshairMode" | "pointerMode";
/**
 * Settings for a sketch.
 */
export interface GeometryEditorSettings {
    /**
     * Whether snapping should be enabled.
     */
    snappingEnabled?: boolean;
    /**
     * Whether bearing labels should be shown on the map.
     */
    showBearings?: boolean;
    /**
     * The editor geometry mode.
     */
    editorGeometryMode?: EditorGeometryMode;
    /**
     * The editor interaction mode.
     */
    editorInteractionMode?: EditorInteractionMode;
    /**
     * Whether the sketch is using freehand or segment sketching.
     */
    freehand?: boolean;
    /**
     * Whether the sketch should stop when double clicking.
     */
    finishOnDoubleClick?: boolean;
    /**
     * Whether the sketch should commit its geometry if another sketch is
     * activated.
     */
    finishIfInterrupted?: boolean;
}
/**
 * Result returned from the 'sketching.get-active-points' operation.
 */
export interface GetActivePointsResult extends GetActiveSketchResult {
}
/**
 * Result returned from the 'sketching.get-active-sketch' operation.
 */
export interface GetActiveSketchResult {
    /**
     * The active graphic(s).
     */
    graphics: Graphic[] | undefined;
    /**
     * The map associated with the graphics.
     */
    maps: MapExtension;
}
/**
 * Specifies if a desired point comes before or after a given reference point.
 */
export type PointOffset = "before" | "after";
/**
 * Arguments for the 'sketching.get-adjacent-point' operation.
 */
export interface GetAdjacentPointArgs extends HasMaps {
    /**
     * A point geometry that represents a vertex within an active editing
     * graphic.
     */
    referencePoint: Point;
    /**
     * Specifies if the desired point comes before or after the referencePoint.
     * Defaults to 'after'.
     */
    relativeOffset?: PointOffset;
}
/**
 * Arguments for the "sketching.set-constraints" command.
 */
export interface SetConstraintsArgs extends HasMaps {
    /**
     * The constraint for the length of the line between the selected vertex and
     * the new point.
     */
    length?: number;
    /**
     * The constraint for the angle of the line between the selected vertex and
     * the new point, relative to the reference line. Remains unchanged until
     * set to a different value, or cleared.
     */
    angle?: number;
    /**
     * A reference line that the angle will be relative to. Defaults to 'north'.
     * Remains unchanged until set again.
     */
    referenceLine?: ReferenceLine;
    /**
     * Indicates whether constraints will be automatically cleared after a
     * vertex is added or updated. If not set (value is null), then the value
     * will remain unchanged with this operation. If the value has never been
     * set, the default is false. Remains unchanged until set to a different
     * value.
     */
    autoClear?: boolean;
    /**
     * The units to be used for length. If not specified, the units of the map's
     * spatial reference will be used.
     */
    units?: LengthUnitsMobile;
    /**
     * Indicates whether the distance calculations will be geodetic or planar.
     * Default is true.
     */
    geodetic?: boolean;
    /**
     * The geodetic curve type used when calculating the new point. Only applies
     * when geodetic is set to true. Defaults to geodesic.
     */
    geodeticCurveType?: GeodeticCurveType;
}
/**
 * Arguments for the "sketching.clear-constraints" command.
 */
export interface ClearConstraintsArgs extends HasMaps {
    /**
     * Indicates whether the length constraint should be cleared. Defaults to
     * true if not specified.
     */
    clearLengthConstraint?: boolean;
    /**
     * Indicates whether the angle constraint should be cleared. Defaults to
     * true if not specified.
     */
    clearAngleConstraint?: boolean;
}
/**
 * Arguments for the "sketching.set-snapping-configuration" command.
 */
export interface SetSnappingConfigurationArgs extends HasMaps {
    /**
     * The snapping properties to set.
     */
    config: SnappingProperties;
    /**
     * Whether the config should be replace, or merged. Defaults to "merge".
     */
    mode?: "replace" | "merge";
}
/**
 * Arguments for the "sketching.set-topology-configuration" command.
 */
export interface SetTopologyConfigurationArgs extends HasMaps {
    /**
     * The topology properties to set.
     */
    config: TopologyProperties;
    /**
     * Whether the config should be replace, or merged. Defaults to "merge".
     */
    mode?: "replace" | "merge";
}
export declare class SketchingOperations extends OperationRegistry {
    protected readonly _prefix = "sketching";
    /**
     * Allows the user to create geometry by sketching on a map. Returns the
     * geometry that was drawn, along with the map that it was drawn on.
     */
    get captureGeometry(): Operation<CaptureGeometryArgs, CaptureGeometryResult>;
    /**
     * Allows the user to edit the symbology used by the graphics actively being
     * edited. Web only.
     *
     * @webOnly
     */
    get editActiveSymbol(): Operation<void, EditSymbolResult | undefined>;
    /**
     * Allows the user to edit an existing geometry by drawing on a map. Returns
     * the geometry that was edited, or the supplied feature with the altered
     * geometry applied, along with the map that it was drawn on.
     */
    get editGeometry(): Operation<EditGeometryArgs, EditGeometryResult>;
    /**
     * Allows the user to move an existing geometry by a specified amount.
     * Returns the altered geometry or the supplied feature with altered
     * geometry applied. Will also pass through any map or symbol associated
     * with the command chain, but only the map is required for this operation.
     * Web only.
     *
     * @webOnly
     */
    get moveGeometry(): Operation<MoveGeometryArgs, GeometryOperationBase>;
    /**
     * Allows the user to scale and mirror an existing geometry on either axis.
     * Returns the altered geometry or the supplied feature with altered
     * geometry applied. Will also pass through any map or symbol associated
     * with the command chain, but they are not required for this operation. Web
     * only.
     *
     * @webOnly
     */
    get scaleGeometry(): Operation<ScaleGeometryArgs, GeometryOperationBase>;
    /**
     * Allows the user to rotate an existing geometry. Returns the altered
     * geometry or the supplied feature with altered geometry applied. Will also
     * pass through any map or symbol associated with the command chain, but
     * they are not required for this operation. Web only.
     *
     * @webOnly
     */
    get rotateGeometry(): Operation<RotateGeometryArgs, GeometryOperationBase>;
    /**
     * Stops geometry capturing or editing on a given map. Returns the current
     * geometry. If validateGeometry parameter is true and geometry is invalid,
     * the operation will return null.
     */
    get stop(): Operation<StopGeometryEditArgs | void, CaptureGeometryResult>;
    /**
     * Deprecated - Mobile users should rather use "geometry.add-point"; Web
     * users should use "sketching.add-point" or "sketching.insert-point"
     * instead.
     *
     * @deprecated
     */
    get addNodeToGeometry(): Operation<AddNodeToGeometryArgs, GeometryUnion>;
    /**
     * Returns the active sketch graphic from a map. Web only.
     *
     * @webOnly
     */
    get getActiveSketch(): Operation<void, GetActiveSketchResult>;
    /**
     * Deprecated - use 'sketching.get-active-points' instead. Web only.
     *
     * @deprecated
     * @webOnly
     */
    get getActiveNode(): Operation<Maps, GetActivePointsResult>;
    /**
     * Returns the active point graphics of the active sketch or edit session on
     * a map. Web only.
     *
     * @webOnly
     */
    get getActivePoints(): Operation<Maps, GetActivePointsResult>;
    /**
     * Return the adjacent point graphic(s), relative to a given vertex that's a
     * part of an active editing or sketching session. This operation is only
     * supported for Polyline and Polygon geometries. Web only.
     *
     * @webOnly
     */
    get getAdjacentPoint(): Operation<GetAdjacentPointArgs, GetActiveSketchResult>;
    /**
     * Checks whether streaming is active. Mobile only.
     *
     * @mobileOnly
     */
    get isStreaming(): Operation<HasMaps, boolean>;
}
export declare class SketchingCommands extends CommandRegistry {
    protected readonly _prefix = "sketching";
    /**
     * Set the snapping default to 'on' for all subsequent operations. Web only.
     *
     * @webOnly
     */
    get activateSnapping(): Command<void>;
    /**
     * Set the topology default to 'on' for all subsequent operations. Web only.
     *
     * @webOnly
     */
    get activateTopology(): Command<void>;
    /**
     * Cancels the current geometry edit or capture operation. Web only.
     *
     * @webOnly
     */
    get cancel(): Command<void>;
    /**
     * Set the snapping default to 'off' for all subsequent operations. Web
     * only.
     *
     * @webOnly
     */
    get deactivateSnapping(): Command<void>;
    /**
     * Set the topology default to 'off' for all subsequent operations. Web
     * only.
     *
     * @webOnly
     */
    get deactivateTopology(): Command<void>;
    /**
     * Undoes the last edit while editing a geometry.
     */
    get undo(): Command<HasMaps>;
    /**
     * Redoes the last undone edit while editing a geometry.
     */
    get redo(): Command<HasMaps>;
    /**
     * Sets the geometry mode of the geometry editor.
     */
    get setGeometryMode(): Command<SetGeometryModeArgs>;
    /**
     * Sets the global snapping configuration.
     */
    get setSnappingConfiguration(): Command<SetSnappingConfigurationArgs>;
    /**
     * Sets the global snapping configuration. Web only.
     *
     * @webOnly
     */
    get setTopologyConfiguration(): Command<SetTopologyConfigurationArgs>;
    /**
     * Adds a point at the center of the map while editing a geometry. Works in
     * centerCrosshair mode only. Mobile only.
     *
     * @mobileOnly
     */
    get addPointAtCenter(): Command<HasMaps>;
    /**
     * Adds a point at the user's current location while editing a geometry.
     * Mobile only.
     *
     * @mobileOnly
     */
    get addPointAtCurrentLocation(): Command<HasMaps>;
    /**
     * Sets a point at the user's current location while editing a geometry. In
     * this context, "set" means to either add a point at the current location,
     * or update the currently selected point to be the user's current location,
     * depending on what edit mode the user is in. Mobile only.
     *
     * @mobileOnly
     */
    get setPointAtCurrentLocation(): Command<HasMaps>;
    /**
     * If a point is supplied while a sketching or editing operation is active,
     * the vertex at that point will be deleted from the current geometry. If no
     * point is supplied, any active points in the session will be deleted. If
     * there are no active points in the session, the entire geometry will be
     * deleted.
     */
    get delete(): Command<void | DeleteGeometryArgs>;
    /**
     * Deprecated - use 'sketching.move-point' instead. Web only.
     *
     * @deprecated
     * @webOnly
     */
    get moveNode(): Command<MoveNodeArgs>;
    /**
     * Moves a point within an active sketch to a new location. Web only.
     *
     * @webOnly
     */
    get movePoint(): Command<MovePointArgs>;
    /**
     * Deprecated - use 'sketching.set-active-points' instead. Web only.
     *
     * @deprecated
     * @webOnly
     */
    get switchActiveNode(): Command<SwitchActiveNodeArgs>;
    /**
     * Switches the active point of an active sketch. Web only.
     *
     * @webOnly
     */
    get setActivePoints(): Command<SetActivePointsArgs>;
    /**
     * Sets the interaction mode of the geometry editor. Mobile only.
     *
     * @mobileOnly
     */
    get setInteractionMode(): Command<SetInteractionModeArgs>;
    /**
     * Enables free scaling while editing geometries. Web only.
     *
     * @webOnly
     */
    get enableFreeScaleMode(): Command<void>;
    /**
     * Disables free scaling while editing geometries. Web only.
     *
     * @webOnly
     */
    get disableFreeScaleMode(): Command<void>;
    /**
     * Enables more precise inputs while editing geometries. Web only.
     *
     * @webOnly
     */
    get enablePrecisionMode(): Command<void>;
    /**
     * Disables more precise inputs while editing geometries. Web only.
     *
     * @webOnly
     */
    get disablePrecisionMode(): Command<void>;
    /**
     * Sets constraints on the active sketch. Mobile only.
     *
     * @mobileOnly
     */
    get setConstraints(): Command<SetConstraintsArgs>;
    /**
     * Clears constraints that have been previously set. Mobile only.
     *
     * @mobileOnly
     */
    get clearConstraints(): Command<ClearConstraintsArgs>;
    /**
     * Inserts a point into a polygon, polyline, or multipoint at the specified
     * index. If the partIndex is null, then the last part is used. If the
     * pointIndex is null, then the new point is inserted at the end.
     */
    get insertPoint(): Command<InsertPointArgs>;
    /**
     * Adds a point to polygon, polyline, or multipoint using the selected index
     * as the point to insert after.
     */
    get addPoint(): Command<AddPointArgs>;
    /**
     * Starts streaming: recording your location at regular intervals and adding
     * the collected points to the currently active geometry editor. Mobile
     * only.
     *
     * @mobileOnly
     */
    get startStreaming(): Command<StartStreamingArgs>;
    /**
     * Stops streaming. Mobile only.
     *
     * @mobileOnly
     */
    get stopStreaming(): Command<HasMaps>;
}
export declare class SketchingEvents extends EventRegistry {
    protected readonly _prefix = "sketching";
    /**
     * Raised when streaming has begun. Mobile only.
     *
     * @mobileOnly
     */
    get streamingStarted(): Event<HasMaps>;
    /**
     * Raised when streaming has stopped. Mobile only.
     *
     * @mobileOnly
     */
    get streamingStopped(): Event<HasMaps>;
}