@arcgis/core 5.0.0-next.51 → 5.0.0-next.53

package/geometry/geometryEngineInterfaces.d.ts

@@ -0,0 +1,59 @@
+
+/**
+ * Units for linear measurements.
+ * Use one of the string values below or a numerical value from
+ * [here](https://resources.arcgis.com/en/help/arcobjects-cpp/componenthelp/index.html#/esriSRUnitType_Constants/000w00000042000000/)
+ * or
+ * [here](https://resources.arcgis.com/en/help/arcobjects-cpp/componenthelp/index.html#/esriSRUnit2Type_Constants/000w00000041000000/).
+ *
+ * @deprecated since version 4.32. Use [LengthUnit](https://developers.arcgis.com/javascript/latest/api-reference/esri-core-units.html#LengthUnit) instead.
+ */
+export type LinearUnit = "feet" | "kilometers" | "meters" | "miles" | "nautical-miles" | "yards";
+
+/**
+ * Units for area measurements.
+ * Use one of the string values below or a numerical value from
+ * [here](https://resources.arcgis.com/en/help/arcobjects-cpp/componenthelp/index.html#/esriSRUnitType_Constants/000w00000042000000/)
+ * or
+ * [here](https://resources.arcgis.com/en/help/arcobjects-cpp/componenthelp/index.html#/esriSRUnit2Type_Constants/000w00000041000000/).
+ *
+ * @deprecated since version 4.32. Use [AreaUnit](https://developers.arcgis.com/javascript/latest/api-reference/esri-core-units.html#AreaUnit) instead.
+ */
+export type AreaUnit = "acres" | "ares" | "hectares" | "square-feet" | "square-kilometers" | "square-meters" | "square-miles" | "square-yards";
+
+/**
+ * The return object of the
+ * [extendedSpatialReferenceInfo()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-geometryEngine.html#extendedSpatialReferenceInfo)
+ * method.
+ *
+ * @deprecated since version 4.32.
+ * @see [extendedSpatialReferenceInfo()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-geometryEngine.html#extendedSpatialReferenceInfo)
+ */
+export interface ExtendedSpatialReferenceInfo {
+  /** The XY tolerance of the spatial reference. */
+  tolerance: number;
+  /** Base factor. */
+  unitBaseFactor: number;
+  /** Unit ID. */
+  unitID: number;
+  /** Square derivative. */
+  unitSquareDerivative: number;
+  /** Unit type. */
+  unitType: number;
+}
+
+/**
+ * Object returned from the [nearestCoordinate()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-geometryEngine.html#nearestCoordinate), [nearestVertex()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-geometryEngine.html#nearestVertex), and [nearestVertices()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-geometryEngine.html#nearestVertices) methods.
+ *
+ * @deprecated since version 4.32. Use [proximityOperator's ProximityResult](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-proximityResult.html#ProximityResult) instead.
+ */
+export interface NearestPointResult<Point> {
+  /** A vertex within the specified distance of the search. */
+  coordinate: Point;
+  /** The distance from the `inputPoint` in the units of the view's spatial reference. */
+  distance: number;
+  /** Indicates if it is an empty geometry. */
+  isEmpty: boolean;
+  /** The index of the vertex within the geometry's rings or paths. */
+  vertexIndex: number;
+}

package/geometry/interfaces.d.ts

@@ -0,0 +1,2 @@
+
+export type LatitudeLongitudeFormat = "dd" | "ddm" | "dms";

package/geometry/operators/affineTransformOperator.d.ts

@@ -1,5 +1,27 @@
-import "../../interfaces";
+import type Transformation from "./support/Transformation.js";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.affineTransformOperator["supportsCurves"];
-export const execute: __esri.affineTransformOperator["execute"];
-export const executeMany: __esri.affineTransformOperator["executeMany"];
+/**
+ * Executes an affine transformation on the geometry.
+ *
+ * @param geometry - The geometry to be transformed.
+ * @param transformation - The transformation to apply to the `geometry`.
+ * @returns Returns the transformed geometry.
+ */
+export function execute(geometry: GeometryUnion, transformation: Transformation): GeometrySansMeshUnion;
+
+/**
+ * Executes an affine transformation on multiple geometries.
+ *
+ * @param geometries - The geometries to be transformed.
+ * All the geometries must have the same spatial reference.
+ * @param transformation - The transformation to apply to the `geometries`.
+ * @returns Returns the transformed geometries.
+ */
+export function executeMany(geometries: GeometryUnion[], transformation: Transformation): GeometrySansMeshUnion[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/alphaShapeOperator.d.ts

@@ -1,5 +1,55 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.alphaShapeOperator["supportsCurves"];
-export const execute: __esri.alphaShapeOperator["execute"];
-export const executeMany: __esri.alphaShapeOperator["executeMany"];
+/** Object returned by the [executeMany()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-alphaShapeOperator.html#executeMany) method. */
+export interface ExecuteResult {
+  /** The alpha shape polygon. */
+  alphaShape: Polygon;
+  /** The calculated alpha value used to generate the alpha shape. */
+  calculatedAlpha: number;
+}
+
+export interface Options {
+  /**
+   * Indicates if the alpha shape polygons should be merged.
+   * Set to `true` to merge the polygons into a single polygon.
+   */
+  merge?: boolean;
+}
+
+/**
+ * Calculates the alpha shape on the input geometry.
+ *
+ * @param geometry - The input geometry.
+ * Only geometry vertices are used to compute the alpha shape.
+ * @param alpha - Controls the level of detail and concavity of the boundary.
+ * The value represents the square of the alpha radius for the alpha shape. Values of 0.0 or small positive numbers will yield an empty alpha shape.
+ * A negative number or NaN will lead to the alpha shape being computed with the minimal alpha value necessary to produce a connected result.
+ * @returns Returns an object containing a polygon of the alpha shape and the calculated alpha value.
+ * The result polygon is not guaranteed to be simple in the sense that it may contain very short segments.
+ * @example
+ * // Calculate the alpha shape of a multipoint geometry
+ * const result = alphaShapeOperator.execute(geometry, 100);
+ */
+export function execute(geometry: GeometryUnion, alpha: number): ExecuteResult;
+
+/**
+ * Calculates the alpha shape on a set of geometries with the option to aggregate the result.
+ *
+ * @param geometries - The input geometries.
+ * Only geometry vertices are used to compute the alpha shape.
+ * All the geometries must have the same spatial reference.
+ * @param alpha - Controls the level of detail and concavity of the boundary.
+ * The value represents the square of the alpha radius for the alpha shape. Values of 0.0 or small positive numbers will yield an empty alpha shape.
+ * A negative number or NaN will lead to the alpha shape being computed with the minimal alpha value necessary to produce a connected result.
+ * @param options - Additional options.
+ * @returns Returns the polygons of the alpha shapes or null.
+ * The result polygons are not guaranteed to be simple in the sense that they may contain very short segments.
+ */
+export function executeMany(geometries: GeometryUnion[], alpha: number, options?: Options): (Polygon | null | undefined)[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `false`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/areaOperator.d.ts

@@ -1,4 +1,31 @@
-import "../../interfaces";
+import type { AreaUnit } from "../../core/units.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.areaOperator["supportsCurves"];
-export const execute: __esri.areaOperator["execute"];
+export interface Options {
+  /**
+   * The area unit of the return value.
+   * The default is the input geometry's spatial reference unit.
+   * An error will be thrown if this is set for Geographic Coordinate Systems.
+   */
+  unit?: AreaUnit;
+}
+
+/**
+ * Calculates the planar area of the input geometry.
+ *
+ * @param geometry - The geometry to calculate the area from.
+ * @param options - Additional options.
+ * @returns Returns the planar area of the geometry.
+ * @example
+ * // Calculate the area of a polygon
+ * const area = areaOperator.execute(polygon);
+ */
+export function execute(geometry: GeometryUnion, options?: Options): number;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ *
+ * @default true
+ */
+export const supportsCurves: boolean;

package/geometry/operators/autoCompleteOperator.d.ts

@@ -1,4 +1,22 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
+import type Polyline from "../Polyline.js";
 
-export const supportsCurves: __esri.autoCompleteOperator["supportsCurves"];
-export const execute: __esri.autoCompleteOperator["execute"];
+/**
+ * Fills the gaps between polygons using the polylines as additional boundaries.
+ *
+ * @param polygons - The polygons to fill.
+ * @param polylines - The polylines to use as boundaries.
+ * @returns Returns the new polygons that were created in the closed empty areas bounded by some of the edges of `polygons` and `polylines`.
+ * The newly created polygons do not overlap any existing `polygons` or `polylines`, and the boundary of a new polygon must contain at least one edge from `polylines`.
+ * Since only polygons that intersect polylines will be used, it may be necessary to prefilter the input.
+ * @example
+ * // Auto complete a set of polygons using polylines as boundaries
+ * const result = autoCompleteOperator.execute(polygons, polylines);
+ */
+export function execute(polygons: Polygon[], polylines: Polyline[]): Polygon[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/boundaryOperator.d.ts

@@ -1,5 +1,35 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.boundaryOperator["supportsCurves"];
-export const execute: __esri.boundaryOperator["execute"];
-export const executeMany: __esri.boundaryOperator["executeMany"];
+/**
+ * Calculates the boundary on the input geometry.
+ *
+ * @param geometry - The input geometry.
+ * @returns Returns the boundary geometry or null.
+ * - Using point or multipoint as the input geometry returns null.
+ * - Extent returns a polyline that bounds the extent.
+ * - Polyline returns a multipoint containing the end points of the polyline's parts.
+ * - Polygon returns a polyline describing its outer and inner rings.
+ * @example
+ * // Calculate the boundary of a polygon
+ * const boundaryGeometry = boundaryOperator.execute(polygon);
+ */
+export function execute(geometry: GeometryUnion): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Calculates the boundaries on a set of geometries.
+ *
+ * @param geometries - The input geometries.
+ * All the geometries must have the same spatial reference.
+ * @returns Returns the boundary geometries or null.
+ * - Using point or multipoint as the input geometry returns null.
+ * - Extent returns a polyline that bounds the extent.
+ * - Polyline returns a multipoint containing the end points of the polyline's parts.
+ * - Polygon returns a polyline describing its outer and inner rings.
+ */
+export function executeMany(geometries: GeometryUnion[]): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/bufferOperator.d.ts

@@ -1,5 +1,70 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.bufferOperator["supportsCurves"];
-export const execute: __esri.bufferOperator["execute"];
-export const executeMany: __esri.bufferOperator["executeMany"];
+export interface ExecuteOptions {
+  /**
+   * The length unit of the buffer distances and max deviation.
+   *  The default is the input geometry's spatial reference unit.
+   * An error will be thrown if this is set for Geographic Coordinate Systems.
+   */
+  unit?: LengthUnit;
+}
+
+export interface ExecuteManyOptions extends ExecuteOptions {
+  /**
+   * The max deviation of the result buffer from the true buffer.
+   * When the value is NaN, internal logic is used to select deviation based on the buffer distance.
+   * Unless the `unit` option is set, the default is the geometries spatial reference unit.
+   *
+   * @default NaN
+   */
+  maxDeviation?: number;
+  /**
+   * The maximum number of vertices in the polygon produced from a buffered point.
+   *
+   * @default 96
+   */
+  maxVerticesInFullCircle?: number;
+  /**
+   * Indicates if the buffer geometries should be unioned. When set to `true`, the output will be a single geometry.
+   *
+   * @default false
+   */
+  union?: boolean;
+}
+
+/**
+ * Creates a buffer around the input geometry.
+ *
+ * @param geometry - The input geometry to be buffered.
+ * @param distance - The buffer distance for the geometry. Unless the `unit` option is set, the default is the geometry's spatial reference unit.
+ * @param options - Additional options.
+ * @returns Returns the buffered geometry or null.
+ * @example
+ * // Buffer a polyline geometry
+ * const bufferGeometry = bufferOperator.execute(polyline, 1000);
+ */
+export function execute(geometry: GeometryUnion, distance: number, options?: ExecuteOptions): Polygon | null | undefined;
+
+/**
+ * Creates a buffer around the input geometries.
+ *
+ * Both `maxDeviation` and `maxVerticesInFullCircle` control the quality of round joins that are in the buffers.
+ * The precision of each buffer is `maxDeviation` unless the number of required vertices is too large.
+ *
+ * @param geometries - The input geometries to be buffered.
+ * All the geometries must have the same spatial reference.
+ * @param distances - The buffer distances for the geometries.
+ * If the size of this array is less than the number of geometries in the input `geometries`, the last distance value is used for the rest of geometries.
+ * Unless the `unit` option is set, the default is the geometries spatial reference unit.
+ * @param options - Additional options.
+ * @returns Returns the buffered geometries.
+ */
+export function executeMany(geometries: GeometryUnion[], distances: number[], options?: ExecuteManyOptions): Polygon[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`. This will produce densified output geometries.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/centroidOperator.d.ts

@@ -1,4 +1,20 @@
-import "../../interfaces";
+import type Point from "../Point.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.centroidOperator["supportsCurves"];
-export const execute: __esri.centroidOperator["execute"];
+/**
+ * Performs the centroid operation on a geometry.
+ *
+ * @param geometry - The geometry in which to calculate the centroid.
+ * @returns The centroid of the geometry.
+ * @example
+ * // Return the centroid of a polygon
+ * const centroid = centroidOperator.execute(polygon);
+ * console.log(`x: ${centroid.x}, y: ${centroid.y}`);
+ */
+export function execute(geometry: GeometryUnion): Point;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/clipOperator.d.ts

@@ -1,5 +1,30 @@
-import "../../interfaces";
+import type Extent from "../Extent.js";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.clipOperator["supportsCurves"];
-export const execute: __esri.clipOperator["execute"];
-export const executeMany: __esri.clipOperator["executeMany"];
+/**
+ * Perform the clip operation on the input geometry.
+ *
+ * @param geometry - The geometry to be clipped.
+ * @param extent - The extent used to clip the geometry.
+ * @returns Returns the clipped geometry or null.
+ * @example
+ * // return a new geometry of a polygon clipped by the view's extent
+ * const clippedGeometry = clipOperator.execute(polygon, view.extent);
+ */
+export function execute(geometry: GeometryUnion, extent: Extent): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Perform the clip operation on the input geometries.
+ *
+ * @param geometries - The array of geometries to be clipped.
+ * All the geometries must have the same spatial reference.
+ * @param extent - The extent used to clip the geometries.
+ * @returns Returns an array whose elements may either be clipped geometries or null.
+ */
+export function executeMany(geometries: GeometryUnion[], extent: Extent): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/containsOperator.d.ts

@@ -1,5 +1,27 @@
-import "../../interfaces";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.containsOperator["supportsCurves"];
-export const accelerateGeometry: __esri.containsOperator["accelerateGeometry"];
-export const execute: __esri.containsOperator["execute"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster contains operations when the same geometry is tested multiple times (e.g. in a loop with hundreds of iterations). See the [Acceleration](https://developers.arcgis.com/javascript/latest/spatial-analysis/intro-geometry-operators/#acceleration) guide topic for more information.
+ *
+ * @param geometry - The geometry to accelerate.
+ * @returns Returns `true` if the geometry was successfully accelerated.
+ */
+export function accelerateGeometry(geometry: GeometryUnion): boolean;
+
+/**
+ * Perform the contains operation on two geometries.
+ *
+ * @param geometry1 - The geometry that is tested for the "contains" relationship to `geometry2`.
+ * @param geometry2 - The geometry that is tested for the "within" relationship to `geometry1`.
+ * @returns Returns `true` if `geometry1` contains `geometry2`.
+ * @example
+ * // Returns true if one geometry contains another
+ * const isContained = containsOperator.execute(polygon1, polygon2);
+ */
+export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion): boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/convexHullOperator.d.ts

@@ -1,6 +1,46 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.convexHullOperator["supportsCurves"];
-export const execute: __esri.convexHullOperator["execute"];
-export const executeMany: __esri.convexHullOperator["executeMany"];
-export const isConvex: __esri.convexHullOperator["isConvex"];
+export interface Options {
+  /**
+   * Indicates if the convex hull geometries should be merged.
+   * Set to `true` to merge the geometries into a single geometry.
+   *
+   * @default false
+   */
+  merge?: boolean;
+}
+
+/**
+ * Calculates the convex hull geometry.
+ *
+ * @param geometry - The input geometry.
+ * @returns Returns the convex hull geometry or null.
+ * @example
+ * // Create a convex hull around a polygon.
+ * const convexHull = convexHullOperator.execute(polygon);
+ */
+export function execute(geometry: GeometryUnion): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Calculates the convex hull.
+ *
+ * @param geometries - The input geometries.
+ * All the geometries must have the same spatial reference.
+ * @param options - Additional options.
+ * @returns Returns the convex hull geometries or null.
+ */
+export function executeMany(geometries: GeometryUnion[], options?: Options): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * Checks if a geometry is convex.
+ *
+ * @param geometry - The input geometry.
+ * @returns Returns `true` if the geometry is convex.
+ */
+export function isConvex(geometry: GeometryUnion): boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/crossesOperator.d.ts

@@ -1,5 +1,30 @@
-import "../../interfaces";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.crossesOperator["supportsCurves"];
-export const accelerateGeometry: __esri.crossesOperator["accelerateGeometry"];
-export const execute: __esri.crossesOperator["execute"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster crosses operations when the same geometry is tested multiple times (e.g. in a loop with hundreds of iterations). See the [Acceleration](https://developers.arcgis.com/javascript/latest/spatial-analysis/intro-geometry-operators/#acceleration) guide topic for more information.
+ *
+ * @param geometry - The geometry to accelerate.
+ * @returns Returns `true` if the geometry was successfully accelerated.
+ */
+export function accelerateGeometry(geometry: GeometryUnion): boolean;
+
+/**
+ * Perform the crosses operation on two geometries.
+ * This relation is true when geometries have some but not all interior points in common.
+ * The interiors must intersect and produce a geometry of smaller dimension than the maximum dimension of the two geometries.
+ * This relation may return true only between polygon and polyline, polygon and point, polyline and polyline, and polyline and point.
+ *
+ * @param geometry1 - The geometry to cross.
+ * @param geometry2 - The geometry being crossed.
+ * @returns Returns `true` if `geometry1` crosses `geometry2`.
+ * @example
+ * // Returns true if a geometry crosses another geometry
+ * const isCrossed = crossesOperator.execute(polygon, polyline);
+ */
+export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion): boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/cutOperator.d.ts

@@ -1,4 +1,20 @@
-import "../../interfaces";
+import type Polyline from "../Polyline.js";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.cutOperator["supportsCurves"];
-export const execute: __esri.cutOperator["execute"];
+/**
+ * Performs the cut operation on a geometry.
+ *
+ * @param geometry - The input geometry to be cut.
+ * @param polyline - The polyline that will be used to divide the input `geometry` into pieces where they cross the `polyline`.
+ * @returns Returns an array of geometries created by cutting the input geometry with the `polyline`.
+ * @example
+ * // Cut a polygon with a polyline
+ * const cutGeometries = cutOperator.execute(polygon, polyline);
+ */
+export function execute(geometry: GeometryUnion, polyline: Polyline): GeometrySansMeshUnion[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/densifyOperator.d.ts

@@ -1,5 +1,74 @@
-import "../../interfaces";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.densifyOperator["supportsCurves"];
-export const execute: __esri.densifyOperator["execute"];
-export const executeMany: __esri.densifyOperator["executeMany"];
+export interface Options {
+  /**
+   * The maximum angle allowed for densification by angle. The number must be greater than or equal to zero and is only applicable on curves. The default value of `0` disables densification by angle. The value will be capped at 90 degrees (π/2). This specifies the maximum angle that a new vertex can deviate from the original geometry.
+   *
+   * @default 0
+   */
+  maxAngleInDegrees?: number;
+  /**
+   * The maximum distance a newly placed vertex on a densified polyline can deviate from the original location on the curve.
+   * The number must be greater than or equal to zero. Applicable only on curves.
+   * The default of passing `0` disables densification by deviation.
+   * Unless the `unit` option is set, the default is the geometry's spatial reference unit.
+   *
+   * @default 0
+   */
+  maxDeviation?: number;
+  /**
+   * The length unit of `maxSegmentLength` and `maxDeviation`.
+   * The default is the input geometry's spatial reference unit.
+   * An error will be thrown if this is set for Geographic Coordinate Systems.
+   */
+  unit?: LengthUnit;
+}
+
+/**
+ * Performs the densify operation on the geometry.
+ *
+ * @param geometry - The geometry to be densified.
+ * @param maxSegmentLength - The maximum distance between vertices when the input geometry is densified.
+ * The number must be greater than or equal to zero.
+ *
+ * When the parameter is set to `0`, this operation only applies to curves and disables densification by length.
+ * Curves are densified to straight segments using the given length.
+ * And, curves are split into shorter subcurves such that the length of subcurves is shorter than `maxSegmentLength`.
+ * After that the curves are replaced with straight segments.
+ * Unless the `unit` option is set, the default is the spatial reference unit of `geometry`.
+ * @param options - Additional options.
+ * @returns Returns the densified geometry that does not contain any curves.
+ * @example
+ * // Returns a densified polyline.
+ * const densified = densifyOperator.execute(polyline, 100);
+ * @example
+ * // Returns a polyline where all curve segments have been densified.
+ * if (polyline.curvePaths) {
+ *   const densified = densifyOperator.execute(polyline, 0, { maxAngleInDegrees: 1 });
+ * }
+ */
+export function execute(geometry: GeometryUnion, maxSegmentLength: number, options?: Options): GeometrySansMeshUnion;
+
+/**
+ * Performs the Densify operation on the geometry set.
+ *
+ * @param geometries - The set of geometries to be densified.
+ * All the geometries must have the same spatial reference.
+ * @param maxSegmentLength - The maximum segment length allowed. The number must be greater than or equal to zero.
+ *
+ * When the parameter is set to `0`, this operation only applies to curves and disables densification by length.
+ * Curves are densified to straight segments using the given length.
+ * And, curves are split into shorter subcurves such that the length of subcurves is shorter than `maxSegmentLength`.
+ * After that the curves are replaced with straight segments.
+ * Unless the `unit` option is set, the default is the geometries spatial reference unit.
+ * @param options - Additional options.
+ * @returns Returns the densified geometries that do not contain any curves.
+ */
+export function executeMany(geometries: GeometryUnion[], maxSegmentLength: number, options?: Options): GeometrySansMeshUnion[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`. This will produce densified output geometries.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/differenceOperator.d.ts

@@ -1,5 +1,29 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.differenceOperator["supportsCurves"];
-export const execute: __esri.differenceOperator["execute"];
-export const executeMany: __esri.differenceOperator["executeMany"];
+/**
+ * Performs the topological difference operation on the two geometries.
+ *
+ * @param geometry - The geometry instance on the left hand side of the subtraction.
+ * @param subtractor - The geometry on the right hand side being subtracted.
+ * @returns Returns the result of the subtraction from the `geometry`, or null. The result has the dimensions of the `geometry`.
+ * @example
+ * // Creates a new geometry based on the difference of two polygons
+ * const difference = differenceOperator.execute(polygon1, polygon2);
+ */
+export function execute(geometry: GeometryUnion, subtractor: GeometryUnion): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Performs the Topological difference operation on the geometry set.
+ *
+ * @param geometries - The set of geometry instance to be subtracted by the `subtractor`.
+ * All the geometries must have the same spatial reference.
+ * @param subtractor - The geometry on the right hand side being subtracted.
+ * @returns Returns an array whose elements are the result of subtracting each input geometry from `geometries`, or null. The result has the dimensions of the `geometries`.
+ */
+export function executeMany(geometries: GeometryUnion[], subtractor: GeometryUnion): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;