@vertigis/workflow 5.32.2 → 5.33.0

package/Activator.d.ts

@@ -0,0 +1,21 @@
+import Bluebird from "bluebird";
+/** Implemented by workflow containers to customize the creation of various currencies. */
+export interface IFacilityFactory {
+    /** Activates an instance. */
+    (type: string): PromiseLike<{}> | {};
+}
+/** Implemented by facilities to uniquely identify that facility. */
+export interface IFacility {
+    type: string;
+}
+/** Exposes functionality for activating well-known facilities. */
+export declare class Activator {
+    /** Provides a means to provide a factory implementations. */
+    factories: IFacilityFactory[];
+    /**
+     * Activates an instance of a type.
+     * @param type The type to activate an instnace of.
+     * @param name The cardinal name of the instance.
+     */
+    activate<T extends IFacility>(basis: T): Bluebird<T>;
+}

package/Activator.js

@@ -0,0 +1 @@
+import Bluebird from"bluebird";class Activator{constructor(){this.factories=[]}activate(r){for(const e of this.factories){var t=e(r.type);if(void 0!==t)return Bluebird.resolve(t)}return Bluebird.resolve(r)}}export{Activator};

package/IActivityHandler.d.ts

@@ -0,0 +1,92 @@
+import Bluebird from "bluebird";
+import { LogLevel } from "./diagnostics/logging";
+import { Task } from "./Task";
+/** Shorthand for a deferrable result. */
+export declare type Deferrable<T> = PromiseLike<T> | T;
+/** Implemented by activity handlers. */
+export interface IActivityHandler {
+    /** Executes the logic for an activity. */
+    execute(inputs: {}, context: IActivityContext, ...args: any[]): Deferrable<{}>;
+}
+/** Describes ambient-level state. */
+export interface IAmbientState {
+    /** Indicates the ActivityContexts with group name monikers that are in scope. */
+    activityContexts: {};
+    /** Indicates the completion object. */
+    completion: Bluebird<{}>;
+    /** Indicates the environment for expressions evaluation. */
+    environment: {};
+    /** Indicates the resources for expression evaluation. */
+    resources: {};
+    /** Indicates the error given to the workflow consumer. */
+    error: Error;
+    /** Indicates the inputs given to the workflow consumer. */
+    inputs: {};
+    /** Indicates the current workflow locale. */
+    locale: string;
+    /** Indicates the current workflow log level. */
+    logLevel: LogLevel;
+    /** Indicates the outputs that the workflow should return. */
+    outputs: {};
+    /** Indicates the trivia for storing ambient-level state. */
+    trivia: {};
+    /** Immediately completes the workflow. */
+    complete(outputs?: {}): void;
+    /** Immediately completes the workflow with an error. */
+    reject(error?: Error): void;
+}
+/**
+ * Describes something that can be aborted via an `AbortController`.
+ */
+export interface Abortable {
+    /**
+     * An `AbortSignal` to be passed to Esri's web-based APIs.
+     * When aborted, the operation will be cancelled.
+     */
+    signal?: AbortSignal;
+}
+/** Describes an activity currently being executed. */
+export interface IActivityContext {
+    /** Indicates the locally-unique identifier that changes per-run per-activity. */
+    luid: any;
+    /** Indicates the ambient state. */
+    ambient: IAmbientState;
+    /** Indicates the action being executed. */
+    action: string;
+    /** Indicates the branch being executed. */
+    branch: boolean | number | string;
+    /** Indicates the cancellation token. */
+    cancellationToken: Task<void> & Abortable;
+    /** Indicates the number of passes on the current step. */
+    passes: number;
+    /** Indicates the state that was persisted. */
+    state: any;
+    /** Indicates the error that was caught. */
+    caught: Error;
+    /** Attempts to call on a transition chain. */
+    call(branch?: boolean | number | string): void;
+    /** Attempts to fork to a transition chain. */
+    fork(branch?: boolean | number | string): void;
+    /** Attempts to jump to a transition chain. */
+    jump(branch?: boolean | number | string): void;
+    /** Instructs the engine to allow the activity to handle errors. */
+    registerForErrors(): void;
+    /** Indicates if any transitions are available for the given branch. */
+    hasBranch(branch?: boolean | number | string): boolean;
+    /** Persists state across invocations. */
+    persist(state: any): void;
+    /** Attempts to restart the workflow at the context. */
+    goto(): void;
+}
+/**
+ * Indicates an activity has no inputs. Should only be used in
+ * an activity's execute method signature.
+ */
+export interface EmptyInputs {
+}
+/**
+ * Indicates an activity has no outputs. Should only be used in
+ * an activity's execute method signature.
+ */
+export interface EmptyOutputs {
+}

package/ProgramInspectorFacility.d.ts

@@ -0,0 +1,23 @@
+import Bluebird from "bluebird";
+import { ProgramInspector } from "./definition/ProgramInspector";
+export interface ResolveArgs {
+    id?: string;
+    program?: string | {};
+    url?: string;
+}
+export declare class ProgramInspectorFacility {
+    private _cache;
+    constructor();
+    /**
+     * Resolves the program inspector for a specified workflow `Program`. This function will cache the workflow program by default
+     * and will return the cached version in subsequent lookups, unless instructed otherwise.
+     * @param args The input `ResolveArgs` argument. Depending on the host, this may be a url or an object containing an id, url or workflow `Program` object.
+     * @param useCache An optional boolean which determines whether caching is allowed for retrieved workflow programs. Defaults to true.
+     * @param workflowDownloader An optional function which may be used to override the default download function for retrieving a workflow `Program`
+     *                           This is useful on hosts like GVH where special processing may be required before downloading resources.
+     */
+    resolveInspector(args: ResolveArgs | string, useCache?: boolean, workflowDownloader?: (url: string) => Bluebird<any>): Bluebird<ProgramInspector>;
+    private downloadAndResolveInspector;
+    private loadWorkflow;
+    private createInspector;
+}

package/ProgramInspectorFacility.js

@@ -0,0 +1 @@
+import esriRequest from"@arcgis/core/request";import Bluebird from"bluebird";import{Dictionary}from"./Collections.js";import{ProgramInspector}from"./definition/ProgramInspector.js";class ProgramInspectorFacility{constructor(){this._cache=new Dictionary}resolveInspector(o,n=!0,i){return Bluebird.attempt(()=>{if(!o)return this.downloadAndResolveInspector(void 0,i);var r="string"==typeof o?o:o.program||o.url;if(n){const t="string"==typeof o?o:o.id||o.url;if(void 0!==t&&null!==t){var e=this._cache.find(t);return void 0!==e?e:(this._cache.assign(t,this.downloadAndResolveInspector(r,i).catch(r=>(this._cache.remove(t),Bluebird.reject(r)))),this._cache.find(t))}}return this.downloadAndResolveInspector(r,i)})}downloadAndResolveInspector(r,e){if(r instanceof ProgramInspector)return Bluebird.resolve(r);if("object"==typeof r)return this.createInspector(r);const t=e||this.loadWorkflow;return t(r).then(this.createInspector).catch(r=>Bluebird.reject(r))}loadWorkflow(r){var e=r.match(/^(.*?)\/home\/item\.html\?id=(.*?)(\#.*)?$/);return null!=e&&(r=`${e[1]}/sharing/rest/content/items/${e[2]}/data?f=json`),Bluebird.resolve(esriRequest(r)).then(r=>Bluebird.resolve(r.data))}createInspector(e){return Bluebird.attempt(function(){if(e instanceof ProgramInspector)return e;const r=new ProgramInspector;return r.import(e),r})}}export{ProgramInspectorFacility};

package/Validation.d.ts

@@ -0,0 +1,26 @@
+import { Lookup } from "./Collections";
+/** An object used to facilitate activity input validation. */
+export declare namespace validation {
+    const never: any;
+    /** Fails an assertion. */
+    function fail(inputName: string, assertion: string): void;
+    /** Coerces an array out of a value. */
+    function array<T>(inputName: string, value: T[] | T, defaultValue?: T[]): T[];
+    /** Checks if the given value is a defined value. */
+    function exists<T>(inputName: string, value: T, defaultValue?: T): T;
+    function id(inputName: string, value: any, defaultValue?: string | number): string | number;
+    /** Checks if the given value is a defined value. */
+    function number(inputName: string, value: any, defaultValue?: number): number;
+    /** Checks if the given value is a defined within a map. */
+    /** This can be useful for coercing enumerations. */
+    function choice<T>(inputName: string, map: Lookup<T>, value: T): T;
+    /** Checks if the given value is a defined within a map. */
+    function boolean(inputName: string, value: any, defaultValue?: boolean): boolean;
+    /** Checks if the given value is a defined within a map. */
+    function string(inputName: string, value: any, defaultValue?: string): string;
+    /** Checks if an input object contains a url or an esri layer with a url. */
+    function urlOrLayer(inputs: {
+        url?: string;
+        layer?: __esri.Layer;
+    }): string;
+}

package/activities/arcgis/AddAttachment.d.ts

@@ -0,0 +1,22 @@
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+export interface AddAttachmentInputs {
+    /** The URL of the ArcGIS feature layer or table. Either url or layer is required. */
+    url?: string;
+    /** The ArcGIS feature layer or table. Either url or layer is required. */
+    layer?: __esri.Layer;
+    objectId: number;
+    attachment: File;
+    /** The geodatabase version on which the operation will be performed. This argument only applies to layers or tables that support versioned data. Requires ArcGIS Server v.10.1+. */
+    gdbVersion?: string;
+    /** The time span in milliseconds to wait for the request's results. */
+    timeout?: number;
+}
+export interface AddAttachmentOutputs {
+    result: any;
+}
+/** Add an attachment to the feature specified by the object id. */
+export declare class AddAttachment implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: AddAttachmentInputs, context: IActivityContext): Deferrable<AddAttachmentOutputs>;
+}

package/activities/arcgis/AddFeatureLayer.d.ts

@@ -0,0 +1,23 @@
+import { IActivityHandler, IActivityContext } from "../../IActivityHandler";
+import { MapProvider } from "./MapProvider";
+/** Defines the inputs for the Add Feature Layer activity */
+export interface AddFeatureLayerInputs {
+    /** The features to be included in the new layer. */
+    features: __esri.Graphic | __esri.FeatureSet | __esri.Graphic[];
+    /** The display name of the new layer. */
+    displayName: string;
+    /** The fields to be included in the new layer. */
+    fields: __esri.Field[];
+}
+/** Defines the outputs for the Add Feature Layer Activity */
+export interface AddFeatureLayerOutputs {
+    /** The new feature layer that was created. */
+    layer: __esri.FeatureLayer;
+}
+export declare class AddFeatureLayer implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: AddFeatureLayerInputs, _context: IActivityContext, type: typeof MapProvider): Promise<AddFeatureLayerOutputs>;
+    /** Override within a host implementation for custom behaviour. */
+    protected addLayerToMap(map: MapProvider, layer: __esri.FeatureLayer): void;
+}

package/activities/arcgis/AddFeatures.d.ts

@@ -0,0 +1,27 @@
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+import { ApplyEditResult, ApplyEditResults } from "./libs/arcGisRestApi";
+/** Defines inputs for the AddFeatures activity. */
+export interface AddFeaturesInputs {
+    /** The URL of the ArcGIS feature layer or table to edit. Either url or layer input is required. */
+    url?: string;
+    /** The ArcGIS feature layer or table to edit. Either url or layer input is required.  */
+    layer?: __esri.Layer;
+    /** The features to add to the layer or table. When adding to a layer, the features' geometries must have the same spatial reference as the layer. */
+    features: __esri.Graphic | __esri.Graphic[];
+    /** The geodatabase version on which the operation will be performed. This argument only applies to layers or tables that support versioned data. Requires ArcGIS Server v.10.1+. */
+    gdbVersion?: string;
+    /** The time span in milliseconds to wait for the request's results. */
+    timeout?: number;
+}
+export interface AddFeaturesOutputs {
+    /** Indicates the results that were returned. */
+    results: ApplyEditResult[];
+    success: boolean;
+}
+export declare class AddFeatures implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: AddFeaturesInputs, context: IActivityContext): Deferrable<AddFeaturesOutputs>;
+    /** Called after the apply edit operation completes. */
+    protected onApplyEditsComplete(results: ApplyEditResults): void;
+}

package/activities/arcgis/CastGeometry.d.ts

@@ -0,0 +1,23 @@
+import { IActivityHandler } from "../../IActivityHandler";
+/** Defines inputs for the Cast Geometry activity. */
+export interface CastGeometryInputs {
+    geometry: __esri.Geometry;
+}
+/** Defines outputs for the Cast Geometry activity. */
+export interface CastGeometryOutputs {
+    /** The geometry as a point. */
+    point?: __esri.Point;
+    /** The geometry as a polygon. */
+    polygon?: __esri.Polygon;
+    /** The geometry as a polyline. */
+    polyline?: __esri.Polyline;
+    /** The geometry as a extent. */
+    extent?: __esri.Extent;
+    /** The geometry as a multipoint. */
+    multipoint?: __esri.Multipoint;
+}
+export declare class CastGeometry implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: CastGeometryInputs): CastGeometryOutputs;
+}

package/activities/arcgis/ClosestFacilityTask.d.ts

@@ -0,0 +1,90 @@
+import { IActivityHandler, IActivityContext } from "../../IActivityHandler";
+import { MapProvider } from "./MapProvider";
+/** Defines inputs for the basic Closest Facility Task activity. This task is related to the Route and Service Area tasks. */
+export interface ClosestFacilityTaskInputs {
+    /** The URL to the ArcGIS network analysis service. */
+    url: string;
+    /** The set of facilities loaded as network locations during analysis. These can be specified as either a DataLayer or a FeatureSet. Either the URL or the features should be specified, but not both. */
+    facilities: __esri.DataLayer | __esri.FeatureSet | __esri.NetworkFeatureSet | __esri.NetworkUrl;
+    /** The set of incidents loaded as network locations during analysis. Can be an instance of a DataLayer or FeatureSet. Either a URL or features should be supplied, but not both. */
+    incidents: __esri.DataLayer | __esri.FeatureSet | __esri.NetworkFeatureSet | __esri.NetworkUrl;
+    /** The list of network attribute names to be accumulated with the analysis; i.e., which attributes should be returned as part of the response. The defaulted is as defined in the specific routing network layer. See: http://resources.arcgis.com/en/help/main/10.2/index.html#//00470000000m000000 */
+    accumulateAttributes?: string[];
+    /** An array of parameter values. If present, an attribute name, parameter name, and value must be specified. */
+    attributeParameterValues?: __esri.AttributeParameterValue[];
+    /** The cutoff value used to determine when to stop traversing. */
+    defaultCutoff?: number;
+    /** The number of facilities to find. */
+    defaultTargetFacilityCount?: number;
+    /** The language used when generating driving directions. This parameter applies only when returnDirections parameter is set to true. If an unsupported language code is specified, the service returns the directions using the default language, English. */
+    directionsLanguage?: string;
+    /** The length unit to use when computing directions. The default is as defined in the specific routing network layer. Known values: centimeters | decimal-degrees | decimeters | feet | inches | kilometers | meters | miles | millimeters | nautical-miles | points | yards. */
+    directionsLengthUnits?: string;
+    /** Defines the amount of direction information returned. Default value: standard. Known values: complete | complete-no-events | instructions-only | standard | summary-only. */
+    directionsOutputType?: string;
+    /** The style to be used when returning directions. The default will be as defined in the network layer. View the REST layer description for your network service to see a list of supported styles. */
+    directionsStyleName?: "desktop" | "navigation" | "campus" | string;
+    /** The name of network attribute to use for the drive time when computing directions. The default is as defined in the specific routing network layer. */
+    directionsTimeAttribute?: string;
+    /** If true, avoids network elements restricted by barriers or restrictions specified in restrictionAttributes. Default value: true. */
+    doNotLocateOnRestrictedElements?: boolean;
+    /** The network attribute name to be used as the impedance attribute in the analysis. The default is as defined in the routing network layer. You can specify any attribute names listed in the Service Directory under Network Dataset -> Network Attributes as "Usage Type: esriNAUTCost". You can also specify a value of "none" to indicate that no network attributes should be used for impedance. For example, set impedanceAttribute to "Time" for the quickest route, or to "Length" for the shortest drive, assuming the service has those two esriNAUTCost attributes. */
+    impedanceAttribute?: string;
+    impedenceAttribute?: string;
+    /** The precision of the output geometry after generalization. If 0, no generalization of output geometry is performed. If present and positive, it represents the MaximumAllowableOffset parameter and generalization is performed according to IPolycurve.Generalize. */
+    outputGeometryPrecision?: number;
+    /** The units of the output geometry precision. Known Values: centimeters | decimal-degrees | decimeters | feet | inches | kilometers | meters | miles | millimeters | nautical-miles | points | yards. */
+    outputGeometryPrecisionUnits?: string;
+    /** The type of output lines to be generated in the result. Default Value: true-shape. Known Values: none | straight | true-shape | true-shape-with-measure. */
+    outputLines?: string;
+    /** The spatial reference (or well-known ID of same) for the geometries returned with the analysis results. If not specified, the geometries are returned in the spatial reference of the map. */
+    outSpatialReference?: number | string | __esri.SpatialReference;
+    /** The set of point barriers loaded as network locations during analysis. Can be an instance of a DataLayer or FeatureSet. Either a URL or features should be supplied, but not both. */
+    pointBarriers?: __esri.DataLayer | __esri.FeatureSet;
+    /** The set of polygon barriers loaded as network locations during analysis. At ArcGIS Server 10.1, an optional url property was added. Use this property to specify a REST query request to a Feature, Map or GP Service that returns a JSON feature set. The url property can be specified using DataFile. Note that either the features or url property should be specified. */
+    polygonBarriers?: __esri.DataLayer | __esri.FeatureSet;
+    /** The set of polyline barriers loaded as network locations during analysis. At ArcGIS Server 10.1, an optional url property was added. Use this property to specify a REST query request to a Feature, Map or GP Service that returns a JSON feature set. The url property can be specified using DataFile. Note that either the features or url property should be specified. */
+    polylineBarriers?: __esri.DataLayer | __esri.FeatureSet;
+    /** The list of network attribute names to be used as restrictions with the analysis. The default is as defined in the specific routing network layer used in your ClosestFacilityTask. Possible values are listed in the Service Directory under Network Dataset -> Network Attributes. You can also specify a value of none to indicate that no network attributes should be used as restrictions. If you specify an empty array, it will default to the default of the service. */
+    restrictionAttributes?: string[];
+    /** Specifies how U-Turns should be handled. The default is as defined in the specific routing network layer. Known Values: allow-backtrack | at-dead-ends-only | no-backtrack | at-dead-ends-and-intersections. */
+    restrictUTurns?: string;
+    /** If true, barriers are returned in the directions property of each RouteResult. Default Value: false. */
+    returnDirections?: boolean;
+    /** If true, facilities will be returned with the analysis results. Default Value: false */
+    returnFacilities?: boolean;
+    /** If true, incidents will be returned with the analysis results. Default value: false. */
+    returnIncidents?: boolean;
+    /** If true, point barriers will be returned in the barriers property of the ClosestFacilitySolveResult. Default value: false. */
+    returnPointBarriers?: boolean;
+    /** If true, polygon barriers are returned in the barriers property of the ClosestFacilitySolveResult. Default value: false. */
+    returnPolygonBarriers?: boolean;
+    /** If true, polyline barriers are returned in the barriers property of the ClosestFacilitySolveResult. Default value: false. */
+    returnPolylineBarriers?: boolean;
+    /** If true, routes are generated and returned in the route property of each ClosestFacilitySolveResult. Default Value: true */
+    returnRoutes?: boolean;
+    /** The arrival or departure date and time. For example, if the travelDirection is set to TO_FACILITY and timeOfDayUsage is set to "end" and timeOfDay is set to 8:00 a.m., the returned route(s) will be setup to arrive at the facility at 8:00 a.m. local time. Requires ArcGIS Server service version 10.1 or greater. */
+    timeOfDay?: Date;
+    /** Defines the way the timeOfDay value is used. The default value is defined in the network layer. Requires ArcGIS Server service version 10.1 or greater. Known values: start | end. */
+    timeOfDayUsage?: string;
+    /** Options for traveling to or from the facility. Default values are defined by the network layer. See NATravelDirection for a list of valid values. */
+    travelDirection?: string;
+    /** If true, the hierarchy attribute for the network should be used in analysis. The default is as defined in the specific routing network layer. */
+    useHierarchy?: boolean;
+}
+/** defines outputs for the Closest Facility Task activity. */
+export interface ClosestFacilityTaskOutputs {
+    directions: __esri.DirectionsFeatureSet | __esri.DirectionsFeatureSet[];
+    facilities: __esri.FeatureSet;
+    incidents: __esri.FeatureSet;
+    messages: __esri.NAMessage[];
+    pointBarriers: __esri.FeatureSet;
+    polygonBarriers: __esri.FeatureSet;
+    polylineBarriers: __esri.FeatureSet;
+    routes: __esri.FeatureSet;
+}
+export declare class ClosestFacilityTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: ClosestFacilityTaskInputs, context: IActivityContext, mapProvider: typeof MapProvider): Promise<ClosestFacilityTaskOutputs>;
+}

package/activities/arcgis/CreateGraphic.d.ts

@@ -0,0 +1,17 @@
+import { IActivityHandler, IActivityContext } from "../../IActivityHandler";
+/** Defines inputs for the Create Graphic activity. */
+export interface CreateGraphicInputs {
+    attributes?: Object;
+    geometry?: __esri.Geometry;
+    symbol?: __esri.Symbol;
+}
+/** Defines outputs for the Create Graphic activity. */
+export interface CreateGraphicOutputs {
+    /** The Feature result. */
+    feature: __esri.Graphic;
+}
+export declare class CreateGraphic implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: CreateGraphicInputs, context: IActivityContext): CreateGraphicOutputs;
+}

package/activities/arcgis/CreatePoint.d.ts

@@ -0,0 +1,17 @@
+import { IActivityHandler, IActivityContext } from "../../IActivityHandler";
+/** Defines inputs for the Create Point activity. */
+export interface CreatePointInputs {
+    x: number;
+    y: number;
+    spatialReference?: string | number | __esri.SpatialReference;
+}
+/** Defines outputs for the Create Point activity. */
+export interface CreatePointOutputs {
+    /** The Point. */
+    point: __esri.Point;
+}
+export declare class CreatePoint implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: CreatePointInputs, context: IActivityContext): CreatePointOutputs;
+}

package/activities/arcgis/CutEngineTask.d.ts

@@ -0,0 +1,18 @@
+import { IActivityHandler, Deferrable } from "../../IActivityHandler";
+/** Defines inputs for the Cut activity. This activity relies on the geometry engine. */
+export interface CutEngineTaskInputs {
+    /** The geometry (a Polyline or Polygon) to be cut. */
+    geometry: __esri.Geometry;
+    /** The polyline which cuts the geometry. */
+    cutter: __esri.Polyline;
+}
+/** Defines outputs for the Cut activity. */
+export interface CutEngineTaskOutputs {
+    /** An array with zero, one, two, or three entries. For Polylines, all left cuts are grouped together in the first Geometry. Right cuts and coincident cuts are grouped in the second Geometry and each undefined cut, along with any uncut parts, are output as separate Polylines. For Polygons, all left cuts are grouped in the first Polygon, all right cuts are grouped in the second Polygon, and each undefined cut, along with any left-over parts after cutting, are output as a separate Polygon. If no cuts are returned then the array will be empty. An undefined cut will only be produced if a left cut or right cut was produced and there was a part left over after cutting, or a cut is bounded to the left and right of the cutter. */
+    geometry: __esri.Geometry[];
+}
+export declare class CutEngineTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: CutEngineTaskInputs): Deferrable<CutEngineTaskOutputs>;
+}

package/activities/arcgis/DeleteAttachments.d.ts

@@ -0,0 +1,22 @@
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+export interface DeleteAttachmentsInputs {
+    /** The URL of the ArcGIS feature layer or table. Either url or layer is required. */
+    url?: string;
+    /** The ArcGIS feature layer or table. Either url or layer is required. */
+    layer?: __esri.Layer;
+    objectId: number;
+    attachmentIds: number | number[];
+    /** The geodatabase version on which the operation will be performed. This argument only applies to layers or tables that support versioned data. Requires ArcGIS Server v.10.1+. */
+    gdbVersion?: string;
+    /** The time span in milliseconds to wait for the request's results. */
+    timeout?: number;
+}
+export interface DeleteAttachmentsOutputs {
+    results: object[];
+}
+/** Delete attachments associated with the specified object id. */
+export declare class DeleteAttachments implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: DeleteAttachmentsInputs, context: IActivityContext): Deferrable<DeleteAttachmentsOutputs>;
+}

package/activities/arcgis/DeleteFeatures.d.ts

@@ -0,0 +1,30 @@
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+import { ApplyEditResult, ApplyEditResults } from "./libs/arcGisRestApi";
+/** Defines inputs for the DeleteFeatures activity. */
+export interface DeleteFeaturesInputs {
+    /** The URL of the ArcGIS feature layer or table to edit. Either url or layer is required. */
+    url?: string;
+    /** The ArcGIS feature layer or table to edit. Either url or layer is required. */
+    layer?: __esri.Layer;
+    features?: number | number[] | __esri.Graphic | __esri.Graphic[] | string | string[];
+    /** Indicates if the features to be deleted should be identified by Global IDs instead of Object IDs. The default value is false. */
+    useGlobalIds?: boolean;
+    /** Indicates the field which contains the OBJECTID or GlobalID for all features. */
+    objectIdField?: string;
+    /** The geodatabase version on which the operation will be performed. This argument only applies to layers or tables that support versioned data. Requires ArcGIS Server v.10.1+. */
+    gdbVersion?: string;
+    /** The time span in milliseconds to wait for the request's results. */
+    timeout?: number;
+}
+export interface DeleteFeaturesOutputs {
+    /** Indicates the results given after deletion. */
+    results: ApplyEditResult[];
+    success: boolean;
+}
+export declare class DeleteFeatures implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: DeleteFeaturesInputs, context: IActivityContext): Deferrable<DeleteFeaturesOutputs>;
+    /** Called after the apply edit operation completes. */
+    protected onApplyEditsComplete(results: ApplyEditResults): void;
+}

package/activities/arcgis/ExtendedSpatialReferenceInfoEngineTask.d.ts

@@ -0,0 +1,17 @@
+import { IActivityHandler, IActivityContext } from "../../IActivityHandler";
+import { MapProvider } from "./MapProvider";
+/** Defines inputs for the ExtendedSpatialReferenceInfo activity. This activity relies on the geometry engine. */
+export interface ExtendedSpatialReferenceInfoEngineTaskInputs {
+    /** The input spatial reference. Valid inputs are projected spatial references (e.g., Web Mercator). Geographic spatial references (e.g., WGS84) are not valid. */
+    spatialReference: __esri.SpatialReference | string | number;
+}
+/** Defines outputs for the ExtendedSpatialReferenceInfo activity. */
+export interface ExtendedSpatialReferenceInfoEngineTaskOutputs {
+    spatialReference: __esri.geometryEngineAsyncSpatialReferenceInfo;
+}
+/** Gets extended spatial reference information. */
+export declare class ExtendedSpatialReferenceInfoEngineTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: ExtendedSpatialReferenceInfoEngineTaskInputs, context: IActivityContext, type: typeof MapProvider): Promise<ExtendedSpatialReferenceInfoEngineTaskOutputs>;
+}

package/activities/arcgis/ExtendedSpatialReferenceInfoEngineTask.js

@@ -0,0 +1 @@
+import{__decorate}from"tslib";import{extendedSpatialReferenceInfo}from"@arcgis/core/geometry/geometryEngineAsync";import{activate}from"../../Hooks.js";import{validation}from"../../Validation.js";import{MapProvider}from"./MapProvider.js";let ExtendedSpatialReferenceInfoEngineTask=class{async execute(e,n,a){e=validation.exists("spatialReference",e.spatialReference);return{spatialReference:await extendedSpatialReferenceInfo(a.getOutSR(e))}}};ExtendedSpatialReferenceInfoEngineTask.action="gcx:wf:arcgis::ExtendedSpatialReferenceInfoEngineTask",ExtendedSpatialReferenceInfoEngineTask.suite="gcx:wf:builtin",ExtendedSpatialReferenceInfoEngineTask=__decorate([activate(MapProvider)],ExtendedSpatialReferenceInfoEngineTask);export{ExtendedSpatialReferenceInfoEngineTask};

package/activities/arcgis/FeatureTableMap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Gets the tables associated with the specified Esri mp.
+ * @param map An Esri map.
+ */
+export declare function getTables(esriMap: __esri.Map): __esri.FeatureLayer[] | undefined;
+/**
+ * Associates a table with the specified Esri map.
+ * This is purely a weak reference between the two. The table is not assigned directly to the Esri map in any way.
+ * @param map An Esri map.
+ * @param table A feature table.
+ */
+export declare function addTable(esriMap: __esri.Map, table: __esri.FeatureLayer): void;

package/activities/arcgis/FlipEngineTask.d.ts

@@ -0,0 +1,21 @@
+import { IActivityHandler, Deferrable } from "../../IActivityHandler";
+/** Defines inputs for the Flip activity. This activity relies on the geometry engine. */
+export interface FlipEngineTaskInputs {
+    /** The geometry to flip. */
+    geometry: __esri.Geometry;
+    /** The orientation. Defaults to "horizontal". */
+    orientation: "horizontal" | "vertical" | string;
+    /** Optional point to flip geometry around. Defaults to the centroid of the geometry. */
+    origin?: __esri.Point;
+}
+/** Defines the outputs for the Flip activity. */
+export interface FlipEngineTaskOutputs {
+    /** The flipped geometry. */
+    geometry: __esri.Geometry;
+}
+export declare class FlipEngineTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    executeUsing(orientation: string, geometry: __esri.Geometry, origin: __esri.Point): Promise<__esri.Geometry>;
+    execute(inputs: FlipEngineTaskInputs): Deferrable<FlipEngineTaskOutputs>;
+}

package/activities/arcgis/Geocode.d.ts

@@ -0,0 +1,38 @@
+import { Lookup } from "../../Collections";
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+import { MapProvider } from "./MapProvider";
+/** Defines inputs for the Geocode activity. */
+export interface GeocodeInputs {
+    /** The URL of the geocoding service. */
+    url: string;
+    /** The various address fields accepted by the corresponding geocode service. These fields are listed in the addressFields property of the JSON representation of the associated geocode service. Example: Suppose that addressFields of a geocode service resource includes fields with the following names: Street, City, State, and Zone. If you want to perform the Geocode operation by providing values for the Street and Zone fields, you'd set the query parameters as Street: 380 New York St, Zone: 92373. */
+    address?: string | Lookup<any>;
+    /** The maximum number of locations to be returned by a search, up to the maximum number allowed by the geocode service. If not specified, the maximum number of candidates for which the service is configured will be returned. Note: This parameter was added at 10.3, and is only supported by geocode services published with ArcGIS 10.3 for Server and later versions. */
+    maxLocations?: number;
+    /** The list of fields to be included in the returned result set. This list is a comma-delimited list of field names. If you specify the shape field in the list of return fields, it is ignored. For non-intersection addresses, you can specify the candidate fields from the geocode service resource. For intersection addresses, you can specify the intersection candidate fields from the geocode service resource. Example: [StreetName,StreetType]. Note: outFields = [*] returns all fields. */
+    outFields?: string | string[];
+    /** The well-known ID (WKID) of the spatial reference or a Spatial Reference object for the returned address candidates. For a list of valid WKID values, see http://resources.arcgis.com/EN/HELP/REST/APIREF/PCS.HTML and http://resources.arcgis.com/EN/HELP/REST/APIREF/GCS.HTML. */
+    outSpatialReference?: number | string | __esri.SpatialReference;
+    /** The spatial extent (bounding box) to be used in geocoding. The response will return only the candidates that are within this spatial extent. Unless the spatialReference is included in the searchExtent, the coordinates are assumed to be in the spatial reference of the locator. Note: This optional parameter is supported only for services that use locators created using ArcGIS 10.0 or later. If comma-separated values are used, they must be in the following format: <XMin>,<YMin>,<XMax>,<YMax>. The searchExtent coordinates should always use a period as the decimal separator even in countries where a comma is traditionally used. */
+    searchExtent?: number[] | __esri.Extent;
+    /** Defines an origin point location that is used with the distance parameter to sort geocoding candidates based on their proximity to said location. The distance parameter specifies the radial distance from the location in meters. If a distance is not specified, it defaults to 2000 meters. The location parameter can be represented by a Point object or as a comma-separated list. The spatial reference can be specified if a Point is used; otherwise the spatial reference is assumed to be the same as that of the geocoding service. If comma-separated values are used, they must be in the following format: <XCoordinate>,<YCoordinate>. Note: This parameter was added at 10.3 and is only supported by geocode services published with ArcGIS 10.3 for Server and later versions. */
+    location?: number[] | __esri.Point;
+    /** Specifies the radius of an area around a point location that is used to boost the rank of geocoding candidates so that candidates closest to the location are returned first. The distance value is in meters. If the distance parameter is specified, the location parameter must be specified as well. */
+    distance?: number;
+    /** The time span in milliseconds to wait for the request's results. */
+    timeout?: number;
+}
+/** Defines outputs for the Geocode activity. */
+export interface GeocodeOutputs {
+    /** Indicates the first candidate address. */
+    candidate?: __esri.AddressCandidate;
+    /** Indicates all the candidates. */
+    candidates?: __esri.AddressCandidate[];
+    /** Indicates the result spatial reference. */
+    spatialReference?: __esri.SpatialReference;
+}
+export declare class Geocode implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: GeocodeInputs, context: IActivityContext, type: typeof MapProvider): Deferrable<GeocodeOutputs>;
+}

package/activities/arcgis/Geoprocessing.d.ts

@@ -0,0 +1,26 @@
+import { Lookup } from "../../Collections";
+import { IActivityHandler, IActivityContext } from "../../IActivityHandler";
+import { MapProvider } from "./MapProvider";
+/** Defines inputs to the Synchronous Geoprocessor task. This task is suitable for geoprocessing services with a synchronous execution type. */
+export interface GeoprocessingInputs {
+    /** The URL of the ArcGIS Server Geoprocessing service task. */
+    url: string;
+    /** The input arguments accepted by the task. */
+    arguments: Lookup<any>;
+    /** The spatial reference of the output geometries. If this is not specified, the output geometries are in the spatial reference of the input geometries. If processSpatialReference is specified and outputSpatialReference is not specified, the output geometries' spatial reference is processSpatialReference. */
+    outSpatialReference?: number | string | __esri.SpatialReference;
+    /** The spatial reference that the model uses to perform geometry operations. If processSpatialReference is specified while outputSpatialReference is not, the output geometries' spatial reference is processSpatialReference.  */
+    processSpatialReference?: number | string | __esri.SpatialReference;
+}
+/** Defines outputs to the Geoprocessor activity. */
+export interface GeoprocessingOutputs {
+    /** The messages from the geoprocessing job. */
+    messages: __esri.GPMessage[];
+    /** The results of the geoprocessing job. */
+    results: Lookup<any>;
+}
+export declare class Geoprocessing implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: GeoprocessingInputs, context: IActivityContext, mapProvider: typeof MapProvider): Promise<GeoprocessingOutputs>;
+}