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

package/geometry/operators/disjointOperator.d.ts

@@ -1,5 +1,28 @@
-import "../../interfaces";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.disjointOperator["supportsCurves"];
-export const accelerateGeometry: __esri.disjointOperator["accelerateGeometry"];
-export const execute: __esri.disjointOperator["execute"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster disjoint 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 a disjoint operation on two geometries.
+ *
+ * @param geometry1 - The base geometry that is tested for the "disjoint" relationship with `geometry2`.
+ * @param geometry2 - The comparison geometry that is tested for the "disjoint" relationship with `geometry1`.
+ * @returns Returns `true` if `geometry1` and `geometry2` are disjoint (don't intersect in any way).
+ * @example
+ * // Returns true if a geometry is not contained in another.
+ * // Operates the opposite of contains.
+ * const isDisjointed = disjointOperator.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/distanceOperator.d.ts

@@ -1,4 +1,30 @@
-import "../../interfaces";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.distanceOperator["supportsCurves"];
-export const execute: __esri.distanceOperator["execute"];
+export interface Options {
+  /**
+   * The length unit of the distance.
+   * 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;
+}
+
+/**
+ * Returns the planar distance between two geometries.
+ *
+ * @param geometry1 - The first input geometry.
+ * @param geometry2 - The second input geometry.
+ * @param options - Additional options.
+ * @returns The distance between the two geometries. Can return NaN for empty geometries.
+ * @example
+ * // Calculate the planar distance between two points
+ * const distance = distanceOperator.execute(point1, point2);
+ */
+export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion, options?: Options): number;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/equalsOperator.d.ts

@@ -1,5 +1,27 @@
-import "../../interfaces";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.equalsOperator["supportsCurves"];
-export const accelerateGeometry: __esri.equalsOperator["accelerateGeometry"];
-export const execute: __esri.equalsOperator["execute"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster equals 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 equals operation on two geometries. The number of vertices and ordering of the vertices is not considered.
+ *
+ * @param geometry1 - The first geometry.
+ * @param geometry2 - The second geometry.
+ * @returns Returns `true` if the two geometries are topologically equal.
+ * @example
+ * // Returns true if two geometries are equal
+ * const isEqual = equalOperator.execute(polyline1, polyline2);
+ */
+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/extendOperator.d.ts

@@ -1,4 +1,41 @@
-import "../../interfaces";
+import type Polyline from "../Polyline.js";
 
-export const supportsCurves: __esri.extendOperator["supportsCurves"];
-export const execute: __esri.extendOperator["execute"];
+export interface Options {
+  /**
+   * If an extension is performed at an end, do not extrapolate the end-segment's attributes for the new point. Instead, make its attributes the same as the current end.
+   * Incompatible with `noEndAttributes`.
+   */
+  keepEndAttributes?: boolean;
+  /**
+   * If an extension is performed at an end, do not extrapolate the end-segment's attributes for the new point.
+   * Instead, make its attributes empty.
+   * Incompatible with `keepEndAttributes`.
+   */
+  noEndAttributes?: boolean;
+  /** Do not extend the 'from' end of any part. */
+  noExtendAtFrom?: boolean;
+  /** Do not extend the 'to' end of any part. */
+  noExtendAtTo?: boolean;
+  /** If an extension is performed at an end, relocate the end point to the new position instead of leaving the old point and adding a new point at the new position. */
+  relocateEnds?: boolean;
+}
+
+/**
+ * Performs the extend operation on a polyline using a polyline as the extender.
+ *
+ * @param polyline1 - The polyline to be extended.
+ * @param polyline2 - The polyline to extend to.
+ * @param options - Additional options.
+ * @returns Returns the extended polyline or null.
+ * The output polyline will have the first and last segment of each path extended to `polyline2` if the segments can be interpolated to intersect it.
+ * In the case that the segments can be extended to multiple segments of the extender, `polyline2`, the shortest extension is chosen.
+ * Only end points for paths that are not shared by the end points of other paths will be extended.
+ * If the polyline cannot be extended, then null is returned.
+ */
+export function execute(polyline1: Polyline, polyline2: Polyline, options?: Options): Polyline | 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/generalizeOperator.d.ts

@@ -1,5 +1,56 @@
-import "../../interfaces";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.generalizeOperator["supportsCurves"];
-export const execute: __esri.generalizeOperator["execute"];
-export const executeMany: __esri.generalizeOperator["executeMany"];
+export interface Options {
+  /**
+   * Preserves degenerate parts.
+   * The operator will try to output three distinct vertices for closed polyline paths and polygon rings,
+   * and it will output two distinct vertices for open polyline paths.
+   *
+   * When set to `true`, the degenerate parts of the geometries will be removed from the output.
+   * This may not be desirable for displaying the geometries.
+   *
+   * @default false
+   */
+  removeDegenerateParts?: boolean;
+  /**
+   * The length unit of `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 generalize operation on the input geometry.
+ *
+ * @param geometry - The input geometry to be generalized.
+ * @param maxDeviation - The maximum allowed deviation from the generalized geometry to the original geometry.
+ * If maxDeviation <= 0 the operator returns the input geometry.
+ * Unless the `unit` option is set, the default is the spatial reference unit of `geometry`.
+ * @param options - Additional options.
+ * @returns Returns the generalized geometry or null.
+ * @example
+ * // Generalize a polyline geometry
+ * const generalizedPolyline = generalizeOperator.execute(polyline, 10);
+ */
+export function execute(geometry: GeometryUnion, maxDeviation: number, options?: Options): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Performs the generalize operation on the input geometries.
+ *
+ * @param geometries - The input geometries to be generalized.
+ * All the geometries must have the same spatial reference.
+ * @param maxDeviation - The maximum allowed deviation from the generalized geometry to the original geometry.
+ * If the value is less than or equal to zero, then the operator returns the input geometries.
+ * Unless the `unit` option is set, the default is the spatial reference unit of `geometries`.
+ * @param options - Additional options.
+ * @returns Returns an array of generalized geometries. Geometries with a dimension of < 1 are simply passed along.
+ */
+export function executeMany(geometries: GeometryUnion[], maxDeviation: 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/geodesicBufferOperator.d.ts

@@ -1,7 +1,89 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeodeticCurveType } from "./support/geodeticCurveType.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.geodesicBufferOperator["supportsCurves"];
-export const execute: __esri.geodesicBufferOperator["execute"];
-export const executeMany: __esri.geodesicBufferOperator["executeMany"];
-export const isLoaded: __esri.geodesicBufferOperator["isLoaded"];
-export const load: __esri.geodesicBufferOperator["load"];
+export interface ExecuteOptions {
+  /**
+   * The type of geodetic curve used to determine the buffer.
+   *
+   * @default "geodesic"
+   */
+  curveType?: GeodeticCurveType;
+  /**
+   * The deviation offset to use for convergence.
+   * Unless the `unit` option is set, the default is meters.
+   * The geodesic arcs of the resulting buffer will be closer than the max deviation of the true buffer.
+   * The default value of NaN will be a maximum of 0.01 meters and (up-to) 0.2% of the buffer distance.
+   *
+   * @default NaN
+   */
+  maxDeviation?: number;
+  /**
+   * The length unit of the buffer distances and max deviation.
+   *
+   * @default "meters"
+   */
+  unit?: LengthUnit;
+}
+
+export interface ExecuteManyOptions extends ExecuteOptions {
+  /**
+   * If true, the resulting buffer geometries will be unioned.
+   *
+   * @default false
+   */
+  union?: boolean;
+}
+
+/**
+ * Indicates if all dependencies of this module have been loaded.
+ *
+ * @returns Returns `true` if this module's dependencies have been loaded.
+ */
+export function isLoaded(): boolean;
+
+/**
+ * Loads this module's dependencies. This method must be called first if `isLoaded` returns `false`.
+ *
+ * @returns Resolves when the dependencies have been loaded.
+ * @see [isLoaded()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-geodesicBufferOperator.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Creates a geodesic buffer around the input geometry.
+ *
+ * @param geometry - The geometry to buffer.
+ * @param distance - The buffer distance for the geometry. Unless the `unit` option is set, the default is meters.
+ * @param options - Additional options.
+ * @returns Returns the buffered geometry or null.
+ * @example
+ * if (!geodesicBufferOperator.isLoaded()) {
+ *   await geodesicBufferOperator.load();
+ * }
+ *
+ * // Calculate the buffer of a polyline geometry
+ * const bufferGeometry = geodesicBufferOperator.execute(polyline, 100);
+ */
+export function execute(geometry: GeometryUnion, distance: number, options?: ExecuteOptions): Polygon | null | undefined;
+
+/**
+ * Creates a geodesic buffer around the input geometries.
+ *
+ * @param geometries - The set of geometries to buffer.
+ * All the geometries must have the same spatial reference.
+ * @param distances - The buffer distance for each of the geometries. Unless the `unit` option is set, the default is meters.
+ * If the size of the distances array is less than the number of geometries in the input geometries,
+ * the last distance value is used for the rest of geometries.
+ * @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 is `null` or `undefined` until the operator is loaded, then it will always be `true`.
+ * This will produce densified output geometries.
+ */
+export const supportsCurves: boolean | null | undefined;

package/geometry/operators/geodesicProximityOperator.d.ts

@@ -1,8 +1,122 @@
-import "../../interfaces";
-
-export const supportsCurves: __esri.geodesicProximityOperator["supportsCurves"];
-export const getNearestCoordinate: __esri.geodesicProximityOperator["getNearestCoordinate"];
-export const getNearestVertex: __esri.geodesicProximityOperator["getNearestVertex"];
-export const getNearestVertices: __esri.geodesicProximityOperator["getNearestVertices"];
-export const isLoaded: __esri.geodesicProximityOperator["isLoaded"];
-export const load: __esri.geodesicProximityOperator["load"];
+import type Point from "../Point.js";
+import type * as proximityResult from "./support/proximityResult.js";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
+
+/** Object returned from the [getNearestCoordinate()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-geodesicProximityOperator.html#getNearestCoordinate), {@link geometry/operators/geodesicProximityOperator#nearestVegetNearestVertex getNearestVertex()}, and [getNearestVertices()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-geodesicProximityOperator.html#getNearestVertices) methods. */
+export type ProximityResult = proximityResult.ProximityResult;
+
+export interface Options {
+  /**
+   * The length unit of the result distance.
+   *
+   * @default "meters"
+   */
+  unit?: LengthUnit;
+}
+
+export interface GetNearestCoordinateOptions extends Options {
+  /**
+   * When the parameter is set to true, this function will calculate the left/right side of a polyline or polygon.
+   * Look for the result in the `isRightSide` property of the returned `ProximityResult` object.
+   *
+   * @default false
+   */
+  calculateLeftRightSide?: boolean;
+  /**
+   * The value controls the error of calculation.
+   * The method uses shape preserving densification to approximate the input segments with great piecewise elliptical arcs.
+   * When the value is zero or NaN, internally the operator uses 0.01 meters.
+   * For other values, unless the `unit` option is set, the default is meters.
+   *
+   * @default NaN
+   */
+  maxDeviation?: number;
+  /**
+   * When `geometry` is a polygon, the function will test if `point` is inside of the polygon.
+   * Points that are inside of the polygon have zero distance to the polygon.
+   * When set to `false`, the function will not check if the point is inside of the polygon, but will only determine proximity to the boundary.
+   *
+   * @default true
+   */
+  testPolygonInterior?: boolean;
+}
+
+/**
+ * Indicates if all dependencies of this module have been loaded.
+ *
+ * @returns Returns `true` if this module's dependencies have been loaded.
+ */
+export function isLoaded(): boolean;
+
+/**
+ * Loads this module's dependencies. This method must be called first if `isLoaded` returns `false`.
+ *
+ * @returns Resolves when the dependencies have been loaded.
+ * @see [isLoaded()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-geodesicProximityOperator.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Returns the nearest coordinate on the geometry to the given input point.
+ * The operator interprets all segments in the shape preserving manner, that is it treats segments as if they are densified with a small step in the input spatial reference and then the calculation is performed geodesicly.
+ *
+ * @param geometry - The input geometry.
+ * @param point - The point used to search for the nearest coordinate in `geometry`.
+ * @param options - Additional options.
+ * @returns Returns the result of proximity operation.
+ * @example
+ * if (!geodesicProximityOperator.isLoaded()) {
+ *   await geodesicProximityOperator.load();
+ * }
+ *
+ * // Calculate the nearest coordinate on a polyline to the given point
+ * const result = geodesicProximityOperator.getNearestCoordinate(polyline, point);
+ */
+export function getNearestCoordinate(geometry: GeometryUnion, point: Point, options?: GetNearestCoordinateOptions): ProximityResult;
+
+/**
+ * Returns the nearest vertex on the geometry.
+ *
+ * @param geometry - The input geometry.
+ * @param point - The point used to search for the nearest coordinate in the input `geometry`.
+ * @param options - Additional options.
+ * @returns Returns the result of proximity operation.
+ * @example
+ * if (!geodesicProximityOperator.isLoaded()) {
+ *   await geodesicProximityOperator.load();
+ * }
+ *
+ * // Calculate the nearest vertex on a polyline to the given point
+ * const result = geodesicProximityOperator.getNearestVertex(polyline, point);
+ */
+export function getNearestVertex(geometry: GeometryUnion, point: Point, options?: Options): ProximityResult;
+
+/**
+ * Returns vertices of the geometry that are closer to the given point than the given radius.
+ *
+ * @param geometry - The input geometry.
+ * @param point - The point used to search for the nearest coordinate in `geometry`.
+ * @param searchRadius - The distance to search from the `point` to the nearest vertices in the `geometry`.
+ * Unless the `unit` option is set, the default is meters.
+ * @param maxVertexCountToReturn - The maximum number of vertices that will be returned. Must be a positive number.
+ * @param options - Additional options.
+ * @returns The array of vertices that are in the given search radius to the point.
+ * The array is sorted by distance to the queryPoint with the closest point first.
+ * When there are more than the `maxVertexCountToReturn` vertices to return, it returns the closest vertices.
+ * The array will be empty when `geometry` is empty.
+ * @example
+ * if (!geodesicProximityOperator.isLoaded()) {
+ *   await geodesicProximityOperator.load();
+ * }
+ *
+ * // Calculate the nearest vertices on a polyline to the given point
+ * const result = geodesicProximityOperator.getNearestVertices(polyline, point, 100, 5);
+ */
+export function getNearestVertices(geometry: GeometryUnion, point: Point, searchRadius: number, maxVertexCountToReturn: number, options?: Options): ProximityResult[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value is `null` or `undefined` until the operator is loaded, then it will always be `true`.
+ */
+export const supportsCurves: boolean | null | undefined;

package/geometry/operators/geodeticAreaOperator.d.ts

@@ -1,6 +1,56 @@
-import "../../interfaces";
+import type { AreaUnit } from "../../core/units.js";
+import type { GeodeticCurveType } from "./support/geodeticCurveType.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.geodeticAreaOperator["supportsCurves"];
-export const execute: __esri.geodeticAreaOperator["execute"];
-export const isLoaded: __esri.geodeticAreaOperator["isLoaded"];
-export const load: __esri.geodeticAreaOperator["load"];
+export interface Options {
+  /**
+   * The type of geodetic curve used to determine the area.
+   *
+   * @default "geodesic"
+   */
+  curveType?: GeodeticCurveType;
+  /**
+   * The area unit of the return value.
+   *
+   * @default "square-meters"
+   */
+  unit?: AreaUnit;
+}
+
+/**
+ * Indicates if all dependencies of this module have been loaded.
+ *
+ * @returns Returns `true` if this module's dependencies have been loaded.
+ */
+export function isLoaded(): boolean;
+
+/**
+ * Loads this module's dependencies. This method must be called first if `isLoaded` returns `false`.
+ *
+ * @returns Resolves when the dependencies have been loaded.
+ * @see [isLoaded()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-geodeticAreaOperator.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Calculates the geodetic area of the input Geometry.
+ * Unless the `unit` option is set, the default is square-meters.
+ *
+ * @param geometry - The input geometry.
+ * @param options - Additional options.
+ * @returns Returns the geodetic area of the input geometry.
+ * @example
+ * if (!geodeticAreaOperator.isLoaded()) {
+ *   await geodeticAreaOperator.load();
+ * }
+ *
+ * // Calculate the geodetic area of a polygon.
+ * const area = geodeticAreaOperator.execute(polygon);
+ */
+export function execute(geometry: GeometryUnion, options?: Options): number;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value is `null` or `undefined` until the operator is loaded, then it will always be `true`.
+ */
+export const supportsCurves: boolean | null | undefined;

package/geometry/operators/geodeticDensifyOperator.d.ts

@@ -1,7 +1,68 @@
-import "../../interfaces";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeodeticCurveType } from "./support/geodeticCurveType.js";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.geodeticDensifyOperator["supportsCurves"];
-export const execute: __esri.geodeticDensifyOperator["execute"];
-export const executeMany: __esri.geodeticDensifyOperator["executeMany"];
-export const isLoaded: __esri.geodeticDensifyOperator["isLoaded"];
-export const load: __esri.geodeticDensifyOperator["load"];
+export interface Options {
+  /**
+   * The type of geodetic curve used to densify the geometries.
+   *
+   * @default "geodesic"
+   */
+  curveType?: GeodeticCurveType;
+  /**
+   * The length unit of `maxSegmentLength`.
+   *
+   * @default "meters"
+   */
+  unit?: LengthUnit;
+}
+
+/**
+ * Indicates if all dependencies of this module have been loaded.
+ *
+ * @returns Returns `true` if this module's dependencies have been loaded.
+ */
+export function isLoaded(): boolean;
+
+/**
+ * Loads this module's dependencies. This method must be called first if `isLoaded` returns `false`.
+ *
+ * @returns Resolves when the dependencies have been loaded.
+ * @see [isLoaded()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-geodeticDensifyOperator.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Densifies the input geometry.
+ *
+ * @param geometry - The input geometry to be densified.
+ * @param maxSegmentLength - The maximum segment length allowed. Unless the `unit` option is set, the default is meters. Must be a positive value.
+ * @param options - Additional options.
+ * @returns Returns the densified geometry or null. Geometries with a dimension of < 1 are simply passed along.
+ * @example
+ * if (!geodeticDensifyOperator.isLoaded()) {
+ *   await geodeticDensifyOperator.load();
+ * }
+ *
+ * // Densify a polyline geometry
+ * const densifiedPolyline = geodeticDensifyOperator.execute(polyline, 100);
+ */
+export function execute(geometry: GeometryUnion, maxSegmentLength: number, options?: Options): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Densifies the input geometries.
+ *
+ * @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. Unless the `unit` option is set, the default is meters. Must be a positive value.
+ * @param options - Additional options.
+ * @returns Returns an array whose elements may either be densified geometries or null.
+ */
+export function executeMany(geometries: GeometryUnion[], maxSegmentLength: number, options?: Options): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value is `null` or `undefined` until the operator is loaded, then it will always be `true`.
+ * This will produce densified output geometries.
+ */
+export const supportsCurves: boolean | null | undefined;

package/geometry/operators/geodeticDistanceOperator.d.ts

@@ -1,6 +1,57 @@
-import "../../interfaces";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeodeticCurveType } from "./support/geodeticCurveType.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.geodeticDistanceOperator["supportsCurves"];
-export const execute: __esri.geodeticDistanceOperator["execute"];
-export const isLoaded: __esri.geodeticDistanceOperator["isLoaded"];
-export const load: __esri.geodeticDistanceOperator["load"];
+export interface Options {
+  /**
+   * The type of geodetic curve used to determine the distance.
+   *
+   * @default "geodesic"
+   */
+  curveType?: Exclude<GeodeticCurveType, "shape-preserving">;
+  /**
+   * The length unit of the distance.
+   *
+   * @default "meters"
+   */
+  unit?: LengthUnit;
+}
+
+/**
+ * Indicates if all dependencies of this module have been loaded.
+ *
+ * @returns Returns `true` if this module's dependencies have been loaded.
+ */
+export function isLoaded(): boolean;
+
+/**
+ * Loads this module's dependencies. This method must be called first if `isLoaded` returns `false`.
+ *
+ * @returns Resolves when the dependencies have been loaded.
+ * @see [isLoaded()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-geodeticDistanceOperator.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Calculates the shortest geodetic distance between two geometries.
+ * Unless the `unit` option is set, the default is meters.
+ *
+ * @param geometry1 - The first input geometry.
+ * @param geometry2 - The second input geometry.
+ * @param options - Additional options.
+ * @returns Returns the distance between the two geometries. Can return NaN for empty geometries.
+ * @example
+ * if (!geodeticDistanceOperator.isLoaded()) {
+ *   await geodeticDistanceOperator.load();
+ * }
+ *
+ * // Calculate the geodetic distance between two geometries
+ * const distance = geodeticDistanceOperator.execute(polyline1, polyline2);
+ */
+export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion, options?: Options): number;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value is `null` or `undefined` until the operator is loaded, then it will always be `true`.
+ */
+export const supportsCurves: boolean | null | undefined;