@vertigis/workflow 5.31.0

package/esm/activities/arcgis/AddAttachment.js

@@ -0,0 +1 @@
+import esriRequest from"@arcgis/core/request";import{GenericActivityError}from"../../Errors.js";import{validation}from"../../Validation.js";import{addToPath,inline,isAbortable,schedulePromiseCancellation}from"./tools.js";class AddAttachment{execute(t,e){var n=validation.urlOrLayer(t).trim(),i=validation.number("objectId",t.objectId,validation.never),a=validation.exists("attachmentIds",t.attachment,validation.never),o=validation.string("gdbVersion",t.gdbVersion),t=validation.number("timeout",t.timeout,void 0),i=addToPath(n,`${i}/addAttachment`);const r=new FormData;r.append("attachment",a),o&&r.append("gdbVersion",o),r.append("f","json");const d={method:"post",body:r,responseType:"json",timeout:t,cacheBust:!1};return isAbortable(e.cancellationToken)&&(d.signal=e.cancellationToken.signal),i=esriRequest(i,d).then(t=>t.data),schedulePromiseCancellation(e,i),inline(i,function(t){t=t.addAttachmentResult;if(!t)throw new GenericActivityError('Error running the "Add Attachment" activity. The response did not include the required "addAttachmentResult" property.');return{result:t}})}}AddAttachment.action="gcx:wf:arcgis::AddAttachment",AddAttachment.suite="gcx:wf:builtin";export{AddAttachment};

package/esm/activities/arcgis/AddFeatureLayer.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="arcgis-js-api" />
+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/esm/activities/arcgis/AddFeatureLayer.js

@@ -0,0 +1 @@
+import{__decorate}from"tslib";import Collection from"@arcgis/core/core/Collection";import FeatureLayer from"@arcgis/core/layers/FeatureLayer";import{activate}from"../../Hooks.js";import{validation}from"../../Validation.js";import{MapProvider}from"./MapProvider.js";import{featuresToArray}from"./tools.js";let AddFeatureLayer=class{async execute(e,a,r){var t=featuresToArray(validation.exists("features",e.features)),i=validation.string("displayName",e.displayName,validation.never);const o=validation.array("fields",e.fields,validation.never),d=r.create();await d.load();let s=void 0;r=o.filter(e=>"oid"===e.type)[0];if(r&&r.name){const l=new Collection;l.addMany(t),s=new FeatureLayer({fields:o,objectIdField:r.name,title:i,source:l}),this.addLayerToMap(d,s)}return{layer:s}}addLayerToMap(e,a){e.view.map.add(a)}};AddFeatureLayer.action="gcx:wf:arcgis::AddFeatureLayer",AddFeatureLayer.suite="gcx:wf:builtin",AddFeatureLayer=__decorate([activate(MapProvider)],AddFeatureLayer);export{AddFeatureLayer};

package/esm/activities/arcgis/AddFeatures.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="arcgis-js-api" />
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+/** 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: __esri.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: __esri.ApplyEditResults): void;
+}

package/esm/activities/arcgis/AddFeatures.js

@@ -0,0 +1 @@
+import{validation}from"../../Validation.js";import{inline,schedulePromiseCancellation,addToPath,post}from"./tools.js";class AddFeatures{execute(e,t){var a=validation.urlOrLayer(e),a=addToPath(a,"applyEdits"),s=validation.string("gdbVersion",e.gdbVersion),i=validation.number("timeout",e.timeout),s={adds:validation.array("features",e.features,validation.never),gdbVersion:s},i=post(a,s,i,t.cancellationToken.signal);schedulePromiseCancellation(t,i);const d=this;return inline(i,function(e){d.onApplyEditsComplete(e);var t=e.addResults&&e.addResults.every(e=>e.success);return{results:e.addResults,success:t}})}onApplyEditsComplete(e){}}AddFeatures.action="gcx:wf:arcgis::AddFeatures",AddFeatures.suite="gcx:wf:builtin";export{AddFeatures};

package/esm/activities/arcgis/AddGraphics.d.ts

@@ -0,0 +1,21 @@
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+import { MapProvider } from "./MapProvider";
+/** Defines inputs for the AddGraphics activity. */
+export interface AddGraphicsInputs {
+    /** The ID of the graphics layer to add the features to. */
+    layerId?: string | number;
+    /** The set of features to add to the layer. */
+    features: __esri.Graphic | __esri.FeatureSet | __esri.Graphic[];
+    /** Whether or not all features should be removed from the layer. Defauts to false. */
+    removeAllFeatures?: boolean;
+}
+/** Defines outputs for the AddGraphics activity. */
+export interface AddGraphicsOutputs {
+    /** Indicates the features that were added. */
+    features: __esri.Graphic[];
+}
+export declare class AddGraphics implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: AddGraphicsInputs, context: IActivityContext, type: typeof MapProvider): Deferrable<AddGraphicsOutputs>;
+}

package/esm/activities/arcgis/AddGraphics.js

@@ -0,0 +1 @@
+import{__decorate}from"tslib";import{activate}from"../../Hooks.js";import{validation}from"../../Validation.js";import{MapProvider}from"./MapProvider.js";import{inline,featuresToArray}from"./tools.js";let AddGraphics=class{execute(e,r,a){const i=validation.id("layerId",e.layerId,void 0),t=featuresToArray(validation.exists("features",e.features)),o=validation.boolean("removeAllFeatures",e.removeAllFeatures,!1),d=a.create();return inline(d.load(),function(){if(i){const e=d.findLayer(i);return inline(e&&e.load(),function(){return o&&e&&e.clearFeatures(),{features:(e||d).addFeatures(t,i)}})}return o&&d.view.graphics.removeAll(),d.view.graphics.addMany(t),{features:t}})}};AddGraphics.action="gcx:wf:arcgis::AddGraphicsLayerFeatures",AddGraphics.suite="gcx:wf:builtin",AddGraphics=__decorate([activate(MapProvider)],AddGraphics);export{AddGraphics};

package/esm/activities/arcgis/ArcadeScript.d.ts

@@ -0,0 +1,18 @@
+import { Lookup } from "../../Collections";
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+/** Defines inputs for the Arcade script. */
+export interface ArcadeScriptInputs {
+    /** The Arcade script to execute. */
+    script: string;
+    /** The parameters to pass to the Arcade script. */
+    parameters?: Lookup<any>;
+}
+/** Defines outputs for the Arcade script. */
+export interface ArcadeScriptOutputs {
+    result: any;
+}
+export declare class ArcadeScript implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: ArcadeScriptInputs, context: IActivityContext): Deferrable<ArcadeScriptOutputs>;
+}

package/esm/activities/arcgis/ArcadeScript.js

@@ -0,0 +1 @@
+import{parseAndExecuteScript}from"@arcgis/core/arcade/arcade";import{validation}from"../../Validation.js";class ArcadeScript{execute(r,a){var t=validation.string("script",r.script,validation.never);const e={};var c={vars:e};if(r.parameters)for(const s in r.parameters){var i=r.parameters[s];e["$"+s]=i}return{result:parseAndExecuteScript(t,c,null)}}}ArcadeScript.action="gcx:wf:arcgis::ArcadeScript",ArcadeScript.suite="gcx:wf:builtin";export{ArcadeScript};

package/esm/activities/arcgis/AreaEngineTask.d.ts

@@ -0,0 +1,20 @@
+import { IActivityHandler, Deferrable } from "../../IActivityHandler";
+/** Defines inputs for the Area activity. This activity relies on the geometry engine. */
+export interface AreaEngineTaskInputs {
+    /** The polygon whose area is being calculated. */
+    geometry: __esri.Polygon;
+    /** Determines whether the area to be calculated is geodesic. If not, the planar area is returned. Defaults to false. Note: geodesic areas only work with WGS84 (wkid: 4326) and Web Mercator spatial references. */
+    geodesic?: boolean;
+    /** Measurement unit of the return value. Defaults to the units of the input geometry. */
+    unit?: "acres" | "ares" | "hectares" | "square-feet" | "square-meters" | "square-yards" | "square-kilometers" | "square-miles" | string | number;
+}
+/** Defines outputs for the Area activity. */
+export interface AreaEngineTaskOutputs {
+    area: number;
+}
+export declare class AreaEngineTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    private executeUsing;
+    execute(inputs: AreaEngineTaskInputs): Deferrable<AreaEngineTaskOutputs>;
+}

package/esm/activities/arcgis/AreaEngineTask.js

@@ -0,0 +1 @@
+import{geodesicArea,planarArea}from"@arcgis/core/geometry/geometryEngineAsync";import{validation}from"../../Validation.js";import{inline}from"./tools.js";class AreaEngineTask{executeUsing(e,i,a){return(e?geodesicArea:planarArea)(i,a)}execute(e){var i=validation.exists("geometry",e.geometry),a=validation.boolean("geodesic",e.geodesic,!1),e=this.executeUsing(a,i,e.unit);return inline(e,function(e){return{area:e}})}}AreaEngineTask.action="gcx:wf:arcgis::AreaEngineTask",AreaEngineTask.suite="gcx:wf:builtin";export{AreaEngineTask};

package/esm/activities/arcgis/BufferEngineTask.d.ts

@@ -0,0 +1,27 @@
+import { IActivityHandler, Deferrable } from "../../IActivityHandler";
+/** Defines inputs to the Buffer activity. This activity makes use of the geometry engine. */
+export interface BufferEngineTaskInputs {
+    /** The buffer input geometry. The geometry and distance parameters must be specified as either both arrays or both non-arrays. */
+    geometry: __esri.Geometry | __esri.Geometry[];
+    /** The specified distance(s) for buffering. */
+    distance: number | number[];
+    /** Measurement unit of the distances. Defaults to the units of the input geometries. */
+    unit?: "meters" | "feet" | "kilometers" | "miles" | "nautical-miles" | "yards" | string;
+    /** Determines whether to use a geodesic buffer or a non-geodesic buffer */
+    geodesic?: boolean;
+    /** Determines whether the output geometries should be unioned into a single polygon. */
+    union?: boolean;
+}
+/** Defines outputs for the Buffer activity. */
+export interface BufferEngineTaskOutputs {
+    /** Indicates the first buffer or result (or the union result). */
+    geometry?: __esri.Polygon;
+    /** Indicates all buffer results. */
+    results?: __esri.Polygon[];
+}
+export declare class BufferEngineTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    private executeUsing;
+    execute(inputs: BufferEngineTaskInputs): Deferrable<BufferEngineTaskOutputs>;
+}

package/esm/activities/arcgis/BufferEngineTask.js

@@ -0,0 +1 @@
+import{buffer,geodesicBuffer}from"@arcgis/core/geometry/geometryEngineAsync";import{validation}from"../../Validation.js";import{inline}from"./tools.js";class BufferEngineTask{executeUsing(e,i,n,r,a){return(e?geodesicBuffer:buffer)(i,n,r,a)}execute(e){var i=validation.array("geometry",e.geometry,validation.never),n=validation.array("distance",e.distance,validation.never),r=validation.boolean("geodesic",e.geodesic,!1),a=validation.boolean("union",e.union,!1),a=this.executeUsing(r,i,n,e.unit,a);return inline(a,function(e){e=Array.isArray(e)?e:[e];return{geometry:e[0],results:e}})}}BufferEngineTask.action="gcx:wf:arcgis::BufferEngineTask",BufferEngineTask.suite="gcx:wf:builtin";export{BufferEngineTask};

package/esm/activities/arcgis/BufferServiceTask.d.ts

@@ -0,0 +1,33 @@
+import { IActivityHandler, IActivityContext } from "../../IActivityHandler";
+import { MapProvider } from "./MapProvider";
+/** Defines inputs for the Buffer activity. This activity relies on an ArcGIS Geometry Service REST endpoint. */
+export interface BufferServiceTaskInputs {
+    /** The URL of the ArcGIS geometry service. */
+    url: string;
+    /** The geometries to buffer. */
+    geometry: __esri.Geometry | __esri.Geometry[];
+    /** The distances the input geometries are buffered. */
+    distance: number | number[];
+    /** The units for calculating each buffer distance. If units are not specified, they are inferred from bufferSpatialReference. If bufferSpatialReference is not specified, units are derived from the features being buffered. */
+    unit?: "meters" | "feet" | "kilometers" | "miles" | "nautical-miles" | "yards" | string;
+    /** The spatial reference in which the geometries are buffered. If bufferSpatialReference is not specified, the geometries are buffered in the spatial reference specified by outSpatialReference. If outSpatialReference is also not specified, they are buffered in the spatial reference of the features. */
+    bufferSpatialReference?: number | string | __esri.SpatialReference;
+    /** The spatial reference for the returned geometries. If outSpatialReference is not specified, the geometries are output in the spatial reference specified by bufferSpatialReference. If bufferSpatialReference is also not specified, they are in the spatial reference of the features. */
+    outSpatialReference?: number | string | __esri.SpatialReference;
+    /** If the input geometries are in geographic coordinate system, set geodesic to true in order to generate a buffer polygon using a geodesic distance. Requires ArcGIS Server 10.1+ geometry service. */
+    geodesic?: boolean;
+    /** If true, all geometries buffered at a given distance are unioned into a single (possibly multipart) polygon, and the unioned geometry is placed in the output array. Defaults to false. */
+    union?: boolean;
+}
+/** Defines outputs for the Buffer activity. */
+export interface BufferServiceTaskOutputs {
+    /** Indicates the first buffer or result (or the union result). */
+    geometry?: __esri.Polygon;
+    /** Indicates all buffer results. */
+    results?: __esri.Polygon[];
+}
+export declare class BufferServiceTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: BufferServiceTaskInputs, context: IActivityContext, mapProvider: typeof MapProvider): Promise<BufferServiceTaskOutputs>;
+}

package/esm/activities/arcgis/BufferServiceTask.js

@@ -0,0 +1 @@
+import{__decorate}from"tslib";import{buffer}from"@arcgis/core/rest/geometryService";import BufferParameters from"@arcgis/core/rest/support/BufferParameters";import{activate}from"../../Hooks.js";import{validation}from"../../Validation.js";import{MapProvider}from"./MapProvider.js";let BufferServiceTask=class{async execute(e,r,a){var i=validation.string("url",e.url,validation.never);const t=new BufferParameters;t.bufferSpatialReference=a.getOutSR(e.bufferSpatialReference),t.outSpatialReference=a.getOutSR(e.outSpatialReference),t.geometries=validation.array("geometry",e.geometry,[]),t.distances=validation.array("distance",e.distance,[]),t.geodesic=validation.boolean("geodesic",e.geodesic,!1),t.unit=e.unit,t.unionResults=validation.boolean("union",e.union,!1);r={signal:r.cancellationToken.signal},r=await buffer(i,t,r);return{geometry:r[0],results:r}}};BufferServiceTask.action="gcx:wf:arcgis::BufferServiceTask",BufferServiceTask.suite="gcx:wf:builtin",BufferServiceTask=__decorate([activate(MapProvider)],BufferServiceTask);export{BufferServiceTask};

package/esm/activities/arcgis/CastGeometry.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="arcgis-js-api" />
+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/esm/activities/arcgis/CastGeometry.js

@@ -0,0 +1 @@
+import{validation}from"../../Validation.js";class CastGeometry{execute(e){var t=validation.exists("geometry",e.geometry);const a={};switch(t.type){case"point":a.point=t;break;case"circle":case"polygon":a.polygon=t;break;case"polyline":a.polyline=t;break;case"extent":a.extent=t;break;case"multipoint":a.multipoint=t}return a}}CastGeometry.action="gcx:wf:arcgis::CastGeometry",CastGeometry.suite="gcx:wf:builtin";export{CastGeometry};

package/esm/activities/arcgis/ClearGraphics.d.ts

@@ -0,0 +1,12 @@
+import { IActivityHandler, IActivityContext, EmptyOutputs } from "../../IActivityHandler";
+import { MapProvider } from "./MapProvider";
+/** Defines inputs for the ClearGraphics activity. */
+export interface ClearGraphicsInputs {
+    /** The ID of the graphics layer to clear. */
+    layerId?: string | number;
+}
+export declare class ClearGraphics implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: ClearGraphicsInputs, context: IActivityContext, type: typeof MapProvider): EmptyOutputs;
+}

package/esm/activities/arcgis/ClearGraphics.js

@@ -0,0 +1 @@
+import{__decorate}from"tslib";import{activate}from"../../Hooks.js";import{validation}from"../../Validation.js";import{MapProvider}from"./MapProvider.js";import{inline}from"./tools.js";let ClearGraphics=class{execute(r,a,i){const e=validation.id("layerId",r.layerId,void 0),o=i.create();return inline(o.load(),function(){if(e){const r=o.findLayer(e);return r&&r.clearFeatures(),{}}o.view.graphics.removeAll()})}};ClearGraphics.action="gcx:wf:arcgis::ClearGraphicsLayer",ClearGraphics.suite="gcx:wf:builtin",ClearGraphics=__decorate([activate(MapProvider)],ClearGraphics);export{ClearGraphics};

package/esm/activities/arcgis/ClipEngineTask.d.ts

@@ -0,0 +1,18 @@
+import { IActivityHandler, Deferrable } from "../../IActivityHandler";
+/** Defines inputs for the Clip activity. This activity makes use of the geometry engine. */
+export interface ClipEngineTaskInputs {
+    /** The geometry to be clipped. */
+    geometry: __esri.Geometry;
+    /** The envelope used to clip. */
+    extent: __esri.Extent;
+}
+/** Defines outputs for the Clip activity. */
+export interface ClipEngineTaskOutputs {
+    /** The clipped geometry. */
+    geometry: __esri.Geometry;
+}
+export declare class ClipEngineTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: ClipEngineTaskInputs): Deferrable<ClipEngineTaskOutputs>;
+}

package/esm/activities/arcgis/ClipEngineTask.js

@@ -0,0 +1 @@
+import{clip}from"@arcgis/core/geometry/geometryEngineAsync";import{validation}from"../../Validation.js";import{inline,extentOf}from"./tools.js";class ClipEngineTask{execute(e){var i=validation.exists("geometry",e.geometry);let t=validation.exists("extent",e.extent);t&&"polygon"==t.type&&(t=extentOf([t]));i=clip(i,t);return inline(i,function(e){return{geometry:e}})}}ClipEngineTask.action="gcx:wf:arcgis::ClipEngineTask",ClipEngineTask.suite="gcx:wf:builtin";export{ClipEngineTask};

package/esm/activities/arcgis/ClosestFacilityTask.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="arcgis-js-api" />
+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.ClosestFacilityParametersAttributeParameterValues[];
+    /** 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?: 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.Point[];
+    incidents: __esri.Point[];
+    messages: __esri.NAMessage[];
+    pointBarriers: __esri.Point[];
+    polygonBarriers: __esri.Polygon[];
+    polylineBarriers: __esri.Polyline[];
+    routes: __esri.Graphic[];
+}
+export declare class ClosestFacilityTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: ClosestFacilityTaskInputs, context: IActivityContext, mapProvider: typeof MapProvider): Promise<ClosestFacilityTaskOutputs>;
+}

package/esm/activities/arcgis/ClosestFacilityTask.js

@@ -0,0 +1 @@
+import{__decorate}from"tslib";import{solve}from"@arcgis/core/rest/closestFacility";import ClosestFacilityParameters from"@arcgis/core/rest/support/ClosestFacilityParameters";import{activate}from"../../Hooks.js";import{validation}from"../../Validation.js";import{MapProvider}from"./MapProvider.js";let ClosestFacilityTask=class{async execute(i,t,e){var r=validation.string("url",i.url,validation.never);const a=new ClosestFacilityParameters;a.facilities=validation.exists("facilities",i.facilities),a.incidents=validation.exists("incidents",i.incidents),a.accumulateAttributes=validation.array("accumulateAttributes",i.accumulateAttributes,void 0),a.attributeParameterValues=validation.exists("attributeParameterValues",i.attributeParameterValues,void 0),a.defaultCutoff=validation.number("defaultCutoff",i.defaultCutoff,void 0),a.defaultTargetFacilityCount=validation.number("defaultTargetFacilityCount",i.defaultTargetFacilityCount,void 0),a.directionsLanguage=validation.string("directionsLanguage",i.directionsLanguage,void 0),a.directionsLengthUnits=validation.string("directionsLengthUnits",i.directionsLengthUnits,void 0),a.directionsOutputType=validation.string("directionsOutputType",i.directionsOutputType,void 0),a.directionsStyleName=validation.string("directionsStyleName",i.directionsStyleName,void 0),a.directionsTimeAttribute=validation.string("directionsTimeAttribute",i.directionsTimeAttribute,void 0),a.impedanceAttribute=validation.string("impedanceAttribute",i.impedanceAttribute,void 0),a.impedanceAttribute||(a.impedanceAttribute=validation.string("impedenceAttribute",i.impedenceAttribute,void 0)),a.outputGeometryPrecision=validation.number("outputGeometryPrecision",i.outputGeometryPrecision,void 0),a.outputGeometryPrecisionUnits=validation.string("outputGeometryPrecisionUnits",i.outputGeometryPrecisionUnits,void 0),a.outputLines=validation.string("outputLines",i.outputLines,void 0),a.pointBarriers=validation.exists("pointBarriers",i.pointBarriers,void 0),a.polygonBarriers=validation.exists("polygonBarriers",i.polygonBarriers,void 0),a.polylineBarriers=validation.exists("polylineBarriers",i.polylineBarriers,void 0),a.restrictionAttributes=validation.exists("restrictionAttributes",i.restrictionAttributes,void 0),a.restrictUTurns=validation.string("restrictUTurns",i.restrictUTurns,void 0),a.returnDirections=validation.boolean("returnDirections",i.returnDirections,void 0),a.returnFacilities=validation.boolean("returnFacilities",i.returnFacilities,void 0),a.returnIncidents=validation.boolean("returnIncidents",i.returnIncidents,void 0),a.returnPointBarriers=validation.boolean("returnPointBarriers",i.returnPointBarriers,void 0),a.returnPolygonBarriers=validation.boolean("returnPolygonBarriers",i.returnPolygonBarriers,void 0),a.returnPolylineBarriers=validation.boolean("returnPolylineBarriers",i.returnPolylineBarriers,void 0),a.returnRoutes=validation.boolean("returnRoutes",i.returnRoutes,!0),a.timeOfDay=validation.exists("timeOfDay",i.timeOfDay,void 0),a.timeOfDayUsage=validation.string("timeOfDayUsage",i.timeOfDayUsage,void 0),a.travelDirection=validation.string("travelDirection",i.travelDirection,void 0),a.useHierarchy=validation.boolean("useHierarchy",i.useHierarchy,void 0);i=validation.exists("outSpatialReference",i.outSpatialReference,void 0);a.outSpatialReference=e.getOutSR(i);t={signal:t.cancellationToken.signal},t=await solve(r,a,t);return{directions:t.directions,facilities:t.facilities,incidents:t.incidents,messages:t.messages,pointBarriers:t.pointBarriers,polygonBarriers:t.polygonBarriers,polylineBarriers:t.polylineBarriers,routes:t.routes}}};ClosestFacilityTask.action="gcx:wf:arcgis::ClosestFacilityTask",ClosestFacilityTask.suite="gcx:wf:builtin",ClosestFacilityTask=__decorate([activate(MapProvider)],ClosestFacilityTask);export{ClosestFacilityTask};

package/esm/activities/arcgis/CompareGeometries.d.ts

@@ -0,0 +1,19 @@
+import { IActivityHandler, Deferrable } from "../../IActivityHandler";
+/** Defines imports for the CompareGeometries activity. This activity relies on the geometry engine. */
+export interface CompareGeometriesInputs {
+    /** The first geometry being compared. */
+    geometry1: __esri.Geometry;
+    /** The second geometry being compared. */
+    geometry2: __esri.Geometry;
+    /** The comparison operation. */
+    operation: "contains" | "crosses" | "disjoint" | "equals" | "intersects" | "overlaps" | "touches" | "within" | string;
+}
+export interface CompareGeometriesOutputs {
+    result: boolean;
+}
+export declare class CompareGeometries implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    private executeWith;
+    execute(inputs: CompareGeometriesInputs): Deferrable<CompareGeometriesOutputs>;
+}

package/esm/activities/arcgis/CompareGeometries.js

@@ -0,0 +1 @@
+import{contains,crosses,disjoint,equals,intersects,overlaps,touches,within}from"@arcgis/core/geometry/geometryEngineAsync";import{validation}from"../../Validation.js";import{inline}from"./tools.js";class CompareGeometries{executeWith(e,t,r){switch(e){case"contains":return contains(t,r);case"crosses":return crosses(t,r);case"disjoint":return disjoint(t,r);case"equals":return equals(t,r);case"intersects":return intersects(t,r);case"overlaps":return overlaps(t,r);case"touches":return touches(t,r);case"within":return within(t,r)}}execute(e){var t=validation.exists("geometry1",e.geometry1),r=validation.exists("geometry2",e.geometry2),e=validation.string("operation",e.operation),r=this.executeWith(e,t,r);return inline(r,function(e){return{result:e}})}}CompareGeometries.action="gcx:wf:arcgis::CompareGeometries",CompareGeometries.suite="gcx:wf:builtin";export{CompareGeometries};

package/esm/activities/arcgis/CreateFeatureSet.d.ts

@@ -0,0 +1,16 @@
+import { IActivityHandler, IActivityContext } from "../../IActivityHandler";
+/** Defines inputs for the Create Feature Set activity. */
+export interface CreateFeatureSetInputs {
+    geometries?: __esri.Geometry | __esri.Geometry[];
+    features?: __esri.Graphic | __esri.Graphic[];
+}
+/** Defines outputs for the Create Feature Set activity. */
+export interface CreateFeatureSetOutputs {
+    /** The FeatureSet. */
+    featureSet: __esri.FeatureSet;
+}
+export declare class CreateFeatureSet implements IActivityHandler {
+    static readonly action = "gcx:wf:arcgis::CreateFeatureSet";
+    static readonly suite = "gcx:wf:builtin";
+    execute(inputs: CreateFeatureSetInputs, context: IActivityContext): Promise<CreateFeatureSetOutputs>;
+}

package/esm/activities/arcgis/CreateFeatureSet.js

@@ -0,0 +1 @@
+import Graphic from"@arcgis/core/Graphic";import FeatureSet from"@arcgis/core/rest/support/FeatureSet";import{validation}from"../../Validation.js";class CreateFeatureSet{async execute(e,t){var r,a=validation.array("geometry",e.geometries,[]).map(e=>{const t=new Graphic;return t.geometry=e,t}),e=validation.array("feature",e.features,[]);const o=new FeatureSet;o.features=[...a,...e];for(const i of o.features)if(null!==(r=null===i||void 0===i?void 0:i.geometry)&&void 0!==r&&r.type){o.geometryType=i.geometry.type;break}return{featureSet:o}}}CreateFeatureSet.action="gcx:wf:arcgis::CreateFeatureSet",CreateFeatureSet.suite="gcx:wf:builtin";export{CreateFeatureSet};

package/esm/activities/arcgis/CreateGraphic.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="arcgis-js-api" />
+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/esm/activities/arcgis/CreateGraphic.js

@@ -0,0 +1 @@
+import Graphic from"@arcgis/core/Graphic";class CreateGraphic{execute(e,r){const t=new Graphic;return t.attributes=e.attributes,t.geometry=e.geometry,t.symbol=e.symbol,{feature:t}}}CreateGraphic.action="gcx:wf:arcgis::CreateGraphic",CreateGraphic.suite="gcx:wf:builtin";export{CreateGraphic};

package/esm/activities/arcgis/CreatePoint.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="arcgis-js-api" />
+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/esm/activities/arcgis/CreatePoint.js

@@ -0,0 +1 @@
+import Point from"@arcgis/core/geometry/Point";import SpatialReference from"@arcgis/core/geometry/SpatialReference";class CreatePoint{execute(e,t){let a="object"==typeof e.spatialReference?e.spatialReference:void 0;return"number"==typeof e.spatialReference?a=new SpatialReference({wkid:e.spatialReference}):"string"==typeof e.spatialReference&&(a=new SpatialReference({wkt:e.spatialReference})),{point:new Point({x:e.x,y:e.y,spatialReference:a})}}}CreatePoint.action="gcx:wf:arcgis::CreatePoint",CreatePoint.suite="gcx:wf:builtin";export{CreatePoint};

package/esm/activities/arcgis/CutEngineTask.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="arcgis-js-api" />
+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/esm/activities/arcgis/CutEngineTask.js

@@ -0,0 +1 @@
+import{cut}from"@arcgis/core/geometry/geometryEngineAsync";import{validation}from"../../Validation.js";import{inline}from"./tools.js";class CutEngineTask{execute(t){var e=validation.exists("geometry",t.geometry),t=validation.exists("cutter",t.cutter),t=cut(e,t);return inline(t,function(t){return{geometry:t}})}}CutEngineTask.action="gcx:wf:arcgis::CutEngineTask",CutEngineTask.suite="gcx:wf:builtin";export{CutEngineTask};

package/esm/activities/arcgis/DeleteAttachments.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="arcgis-js-api" />
+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/esm/activities/arcgis/DeleteAttachments.js

@@ -0,0 +1 @@
+import{GenericActivityError}from"../../Errors.js";import{validation}from"../../Validation.js";import{addToPath,inline,schedulePromiseCancellation,post}from"./tools.js";class DeleteAttachments{execute(t,e){var i=validation.urlOrLayer(t).trim(),n=validation.number("objectId",t.objectId,validation.never),a=validation.array("attachmentIds",t.attachmentIds,validation.never).join(","),r=validation.string("gdbVersion",t.gdbVersion),t=validation.number("timeout",t.timeout,void 0),n=addToPath(i,`${n}/deleteAttachments`);const o={attachmentIds:a};r&&(o.gdbVersion=r);t=post(n,o,t,e.cancellationToken.signal);return schedulePromiseCancellation(e,t),inline(t,function(t){t=t.deleteAttachmentResults;if(!t)throw new GenericActivityError('Error running the "Delete Attachments" activity. The response did not include the required "deleteAttachmentResults" property.');return{results:t}})}}DeleteAttachments.action="gcx:wf:arcgis::DeleteAttachments",DeleteAttachments.suite="gcx:wf:builtin";export{DeleteAttachments};

package/esm/activities/arcgis/DeleteFeatures.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="arcgis-js-api" />
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+/** 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: __esri.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: __esri.ApplyEditResults): void;
+}

package/esm/activities/arcgis/DeleteFeatures.js

@@ -0,0 +1 @@
+import{GenericActivityError}from"../../Errors.js";import{validation}from"../../Validation.js";import{combineGlobalIds,getFieldName}from"./shared.js";import{inline,schedulePromiseCancellation,addToPath,post}from"./tools.js";class DeleteFeatures{execute(e,t){var i=validation.urlOrLayer(e),i=addToPath(i,"applyEdits"),s=validation.boolean("useGlobalIds",e.useGlobalIds,!1),o=validation.string("objectIdField",e.objectIdField,s?"GlobalID":"OBJECTID"),r=validation.string("gdbVersion",e.gdbVersion),a=validation.number("timeout",e.timeout);const l=[],n=[];let d;for(const p of validation.array("features",e.features,validation.never))if("number"==typeof p)l.push(p);else if("string"==typeof p)s?n.push(p):(u=parseInt(p),isNaN(u)||l.push(u));else{var u=p.attributes;if("object"==typeof u){if(!d&&(d=getFieldName(o,u),!d))throw new GenericActivityError(`Error running the "Delete Features" activity. Feature does not have a "${o}" property.`);u=u[d];(s?n:l).push(u)}}r={deletes:s?combineGlobalIds(n):l.toString(),gdbVersion:r,useGlobalIds:s},a=post(i,r,a,t.cancellationToken.signal);schedulePromiseCancellation(t,a);const c=this;return inline(a,function(e){c.onApplyEditsComplete(e);var t=e.deleteResults&&e.deleteResults.every(e=>e.success);return{results:e.deleteResults,success:t}})}onApplyEditsComplete(e){}}DeleteFeatures.action="gcx:wf:arcgis::DeleteFeatures",DeleteFeatures.suite="gcx:wf:builtin";export{DeleteFeatures};

package/esm/activities/arcgis/DensifyEngineTask.d.ts

@@ -0,0 +1,20 @@
+import { IActivityHandler, Deferrable } from "../../IActivityHandler";
+/** Defines inputs for the Densify activity. This activity relies on the geometry engine. */
+export interface DensifyEngineTaskInputs {
+    /** The geometry to be densified. */
+    geometry: __esri.Geometry;
+    /** The maximum segment length allowed. Must be a positive value. */
+    maxSegmentLength: number;
+    /** Measurement unit for maxSegmentLength. Defaults to the units of the input geometry. Known values: meters | feet | kilometers | miles | nautical-miles | yards. */
+    unit?: string | number;
+}
+/** Defines outputs for the Densify activity. */
+export interface DensifyEngineTaskOutputs {
+    /** The densified geometry. */
+    geometry: __esri.Geometry;
+}
+export declare class DensifyEngineTask implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: DensifyEngineTaskInputs): Deferrable<DensifyEngineTaskOutputs>;
+}

package/esm/activities/arcgis/DensifyEngineTask.js

@@ -0,0 +1 @@
+import{densify}from"@arcgis/core/geometry/geometryEngineAsync";import{validation}from"../../Validation.js";import{inline}from"./tools.js";class DensifyEngineTask{execute(e){var n=validation.exists("geometry",e.geometry),i=validation.number("maxSegmentLength",e.maxSegmentLength),e=densify(n,i,e.unit);return inline(e,function(e){return{geometry:e}})}}DensifyEngineTask.action="gcx:wf:arcgis::DensifyEngineTask",DensifyEngineTask.suite="gcx:wf:builtin";export{DensifyEngineTask};