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

package/geometry/operators/offsetOperator.d.ts

@@ -1,5 +1,75 @@
-import "../../interfaces";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.offsetOperator["supportsCurves"];
-export const execute: __esri.offsetOperator["execute"];
-export const executeMany: __esri.offsetOperator["executeMany"];
+export interface Options {
+  /**
+   * The maximum distance of the resulting segments compared to the true circular arc (used only when joins is round).
+   * The algorithm never produces more than around 180 vertices for each round join.
+   *
+   * @default 0
+   */
+  flattenError?: number;
+  /**
+   * Defines the join type of the offset geometry. Inner corners are always mitered.
+   * * Round - a circular arc that is tangent to the ends of both offset line segments.
+   * * Miter - the offset line segments are extended to their intersection point forming a sharp angle, unless that extension exceeds the `miterLimit`, in which case the result is a bevel.
+   * * Bevel - the offset line segments are not extended; their endpoints are joined by a straight line.
+   * * Square - same as `miter` for minor arcs greater than 90 degrees. For all other minor arcs, the offset line segments are extended by an extra `distance` before their endpoints are joined.
+   *
+   * @default "round"
+   */
+  joins?: "round" | "miter" | "bevel" | "square";
+  /**
+   * Applicable only to mitered joins.
+   * Controls the appearance of angled lines to avoid excessively long and pointy corners.
+   * The miterLimit is multiplied by the offset distance
+   * and the result is the maximum mitered offset: joins which would result in a larger mitered offset will be beveled instead.
+   *
+   * @default 10
+   */
+  miterLimit?: number;
+  /**
+   * The length unit of the offset distance.
+   * The default is the input geometries spatial reference unit.
+   * An error will be thrown if this is set for Geographic Coordinate Systems.
+   */
+  unit?: LengthUnit;
+}
+
+/**
+ * Creates an offset version of the input geometry.
+ * This is not applicable to point geometries.
+ *
+ * @param geometry - The input geometry.
+ * Can be an extent, polyline, or polygon.
+ * Point and multipoint geometries are not supported.
+ * @param distance - The distance to offset the input geometry.
+ * Unless the `unit` option is set, the default is the geometry's spatial reference unit.
+ * @param options - Additional options.
+ * @returns Returns the offset geometry or null.
+ * Very acute angles can return null when an offset geometry segment cannot be created with the given parameters.
+ * @example
+ * // Create an offset polygon.
+ * const offsetPolygon = offsetOperator.execute(polygon, 100);
+ */
+export function execute(geometry: GeometryUnion, distance: number, options?: Options): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Creates offset versions of the input geometries.
+ *
+ * @param geometries - The set of input geometries.
+ * Can be extents, polylines, or polygons.
+ * Point and multipoint geometries are not supported.
+ * All the geometries must have the same spatial reference.
+ * @param distance - The distance to offset the input geometries.
+ * Unless the `unit` option is set, the default is the geometries spatial reference unit.
+ * @param options - Additional options.
+ * @returns Returns the offset geometry results or null. Very acute angles can return null when an offset geometry segment cannot be created with the given parameters.
+ */
+export function executeMany(geometries: GeometryUnion[], distance: number, options?: Options): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * 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/overlapsOperator.d.ts

@@ -1,5 +1,28 @@
-import "../../interfaces";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.overlapsOperator["supportsCurves"];
-export const accelerateGeometry: __esri.overlapsOperator["accelerateGeometry"];
-export const execute: __esri.overlapsOperator["execute"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster overlaps 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 overlaps operation on two geometries.
+ *
+ * @param geometry1 - The base geometry that is tested for the "overlaps" relationship with `geometry2`.
+ * @param geometry2 - The comparison geometry that is tested for the "overlaps" relationship with `geometry1`.
+ * @returns Returns `true` if the intersection set results in a geometry different from both of the input geometries, but of the same dimension. For example, if `geometry1` and `geometry2` are both polygons, then they must return a polygon in order to overlap. If two polygons cross each other at exactly one point then no overlap has occurred because points have a dimension of 0 and polygons have a dimension of 2. See the [Working with spatial relationship operators](https://developers.arcgis.com/javascript/latest/spatial-analysis/intro-geometry-operators/#dimensionality) guide topic on dimensionality for more details.
+ * @example
+ * // Returns true if one geometry overlaps another,
+ * // but is not contained or disjointed
+ * const isOverlapping = overlapsOperator.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/polygonOverlayOperator.d.ts

@@ -1,4 +1,62 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
 
-export const supportsCurves: __esri.polygonOverlayOperator["supportsCurves"];
-export const executeMany: __esri.polygonOverlayOperator["executeMany"];
+export interface Options {
+  /**
+   * Create polygons to fill gaps.
+   * Gaps are empty areas between different polygons, that have a closed boundary.
+   */
+  gaps?: boolean;
+  /**
+   * Create polygons to fill holes.
+   * Holes are empty areas completely enclosed by a single polygon.
+   * In addition to regular holes formed by the interior rings, the operator considers any empty area that has a closed boundary formed by the segments of same polygon to be a hole.
+   * For example, a gap between two or more exterior rings of same polygon is also considered a hole.
+   */
+  holes?: boolean;
+  /**
+   * Output multipart polygons.
+   * Multipart output requires more processing.
+   * If the option is not set, the output will contain single part polygons (one exterior ring and zero or more holes).
+   */
+  multiPart?: boolean;
+  /**
+   * Output non-overlapping areas of polygons.
+   *
+   * @default true
+   */
+  noOverlaps?: boolean;
+  /**
+   * Output overlapping areas of polygons.
+   *
+   * @default true
+   */
+  overlaps?: boolean;
+}
+
+/** Object returned by the [executeMany()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-polygonOverlayOperator.html#executeMany) method. */
+export interface ExecuteManyResult {
+  /** The corresponding set of ids for each result. Each id is the index of the polygon in the input array. result[0] corresponds to ids[0], result[1] to ids[1], etc. */
+  ids: number[][];
+  /** The array of polygons returned by the operator. */
+  results: Polygon[];
+}
+
+/**
+ * Performs the topological overlay of the geometry set in the XY plane.
+ *
+ * @param polygons - The set of polygons to overlay.
+ * All the polygons must have the same spatial reference.
+ * @param options - Additional options.
+ * @returns Returns the result polygons and ids.
+ * Overlaps have two or more ids, no-overlaps have one id, and gaps have no ids.
+ * @example
+ * // Overlay a set of polygons
+ * const result = polygonOverlayOperator.executeMany(polygons);
+ */
+export function executeMany(polygons: Polygon[], options?: Options): ExecuteManyResult;
+
+/**
+ * Indicates if the operator supports input polygons that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/polygonSlicerOperator.d.ts

@@ -1,6 +1,69 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
+import type Transformation from "./support/Transformation.js";
+import type { AreaUnit } from "../../core/units.js";
 
-export const supportsCurves: __esri.polygonSlicerOperator["supportsCurves"];
-export const findSlicesByArea: __esri.polygonSlicerOperator["findSlicesByArea"];
-export const recursiveSliceEqualArea: __esri.polygonSlicerOperator["recursiveSliceEqualArea"];
-export const sliceIntoStrips: __esri.polygonSlicerOperator["sliceIntoStrips"];
+export interface Options {
+  /**
+   * The affine transformation to apply to the polygon before slicing. When applying the transformation, the slicing starts from the bottom and proceeds to the top. The default is the identity transformation.
+   * For horizontal slices, use [Transformation#setIdentity()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-Transformation.html#setIdentity). To slice vertically, apply [Transformation#setSwapCoordinates()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-Transformation.html#setSwapCoordinates) that swaps x and y coordinate values, and for an arbitrary angle, use [Transformation#rotate()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-Transformation.html#rotate).
+   */
+  transform?: Transformation;
+}
+
+export interface FindSlicesByAreaOptions extends Options {
+  /**
+   * The area unit of the remaining area.
+   * 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;
+}
+
+/**
+ * Finds positions of the sliced strips for a given polygon given the number of equal area parts to slice the polygon into.
+ *
+ * @param polygon - The input polygon.
+ * @param partCount - The number of parts to slice into.
+ * @param remainingArea - The size of the remaining piece of the uncut polygon. Pass zero, if you want to slice the whole polygon.
+ * Unless the `unit` option is set, the default is the spatial reference unit of `polygon`.
+ * @param options - Additional options.
+ * @returns Returns the y-coordinate set for the slice positions sorted in increasing y-order. The set can be used as input to the [sliceIntoStrips()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-polygonSlicerOperator.html#sliceIntoStrips) method.
+ * @example
+ * // Find the slice positions for a polygon
+ * const slicePositions = polygonSlicerOperator.findSlicesByArea(polygon, 3, 0);
+ */
+export function findSlicesByArea(polygon: Polygon, partCount: number, remainingArea: number, options?: FindSlicesByAreaOptions): number[];
+
+/**
+ * Slices the given polygon into equal area parts, not necessarily strips. The slicing is done recursively, each time slicing the polygon into two parts along the larger dimension (height or width).
+ *
+ * @param polygon - The input polygon to slice.
+ * @param partCount - The number of equal area parts to slice the polygon into.
+ * @param options - Additional options.
+ * @returns Returns the array of polygons that are the result of the slicing.
+ * The number of output polygons will not necessarily match the number of requested slices. For example, if some of the slices became degenerate, they may not be output. The method uses topological operations that rely on the tolerance value in the input spatial reference. These operations may shift vertices in a way that affects result areas.
+ * @example
+ * // Slice a polygon into equal area parts
+ * const slicedPolygons = polygonSlicerOperator.recursiveSliceEqualArea(polygon, 3);
+ */
+export function recursiveSliceEqualArea(polygon: Polygon, partCount: number, options?: Options): Polygon[];
+
+/**
+ * Slices the given polygon into strips.
+ *
+ * @param polygon - The input polygon to slice.
+ * @param ySlices - The array of y coordinates, sorted in ascending order. The polygon will be transformed with the transform, and then it will be sliced horizontally at each y coordinate. That is, the `ySlices` are given in the coordinates after transform is applied to the polygon.
+ * @param options - Additional options.
+ * @returns Returns the array of polygons that are the result of the slicing.
+ * The number of output polygons will not necessarily match the number of requested slices. For example, if some of the slices became degenerate, they may not be output. The method uses topological operations that rely on the tolerance value in the input spatial reference. These operations may shift vertices in a way that affects result areas.
+ * @example
+ * // Slice a polygon into strips
+ * const slicedPolygons = polygonSlicerOperator.sliceIntoStrips(polygon, [100, 200, 300]);
+ */
+export function sliceIntoStrips(polygon: Polygon, ySlices: number[], options?: Options): Polygon[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/projectOperator.d.ts

@@ -1,7 +1,59 @@
-import "../../interfaces";
+import type SpatialReference from "../SpatialReference.js";
+import type { Options as ProjectionTransformationOptions } from "./support/projectionTransformation.js";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.projectOperator["supportsCurves"];
-export const execute: __esri.projectOperator["execute"];
-export const executeMany: __esri.projectOperator["executeMany"];
-export const isLoaded: __esri.projectOperator["isLoaded"];
-export const load: __esri.projectOperator["load"];
+export interface Options extends ProjectionTransformationOptions {}
+
+/**
+ * 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-projectOperator.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Projects a geometry to the specified output spatial reference.
+ *
+ * @param geometry - The geometry to project.
+ * @param outSpatialReference - The spatial reference to which the input geometry is projected.
+ * @param options - Additional options.
+ * @returns Returns the projected geometry or null.
+ * @example
+ * if (!projectOperator.isLoaded()) {
+ *   await projectOperator.load();
+ * }
+ *
+ * const outSpatialReference = new SpatialReference({
+ *   wkid: 53008 //Sphere_Sinusoidal projection
+ * });
+ *
+ * // Project a geometry to a different spatial reference
+ * const geometry = projectOperator.execute(polygon, outSpatialReference);
+ */
+export function execute(geometry: GeometryUnion, outSpatialReference: SpatialReference, options?: Options): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Projects an array of geometries to the specified output spatial reference.
+ *
+ * @param geometries - An array of geometries to project.
+ * All the geometries must have the same spatial reference.
+ * @param outSpatialReference - The spatial reference to which the input geometry is projected.
+ * @param options - Additional options.
+ * @returns Returns the projected geometries or null.
+ */
+export function executeMany(geometries: GeometryUnion[], outSpatialReference: SpatialReference, 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/proximityOperator.d.ts

@@ -1,6 +1,82 @@
-import "../../interfaces";
+import type Point from "../Point.js";
+import type { LengthUnit } from "../../core/units.js";
+import type { ProximityResult } from "./support/proximityResult.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.proximityOperator["supportsCurves"];
-export const getNearestCoordinate: __esri.proximityOperator["getNearestCoordinate"];
-export const getNearestVertex: __esri.proximityOperator["getNearestVertex"];
-export const getNearestVertices: __esri.proximityOperator["getNearestVertices"];
+export interface Options {
+  /**
+   * The length unit of the search radius and result distances.
+   * 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 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;
+  /**
+   * 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;
+}
+
+/**
+ * Returns the nearest coordinate on the geometry to the given input point.
+ *
+ * @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 proximity result which contains the nearest coordinate on the input `geometry` to the given `inputPoint`.
+ * @example
+ * // Return the nearest result on a polygon to the given point
+ * const proximityResult = proximityOperator.getNearestCoordinate(polygon, 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 proximity result which contains the nearest vertex on the `geometry` to the given `inputPoint`.
+ * @example
+ * // Return the nearest vertex on a polygon to the given point
+ * const proximityResult = proximityOperator.getNearestVertex(polygon, 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 planar distance from the `inputPoint` to search for vertices.
+ * Unless the `unit` option is set, the default is the geometry's spatial reference unit.
+ * @param maxVertexCountToReturn - The maximum number of vertices that will be returned. Must be a positive number.
+ * @param options - Additional options.
+ * @returns Returns an array of proximity results which contain the nearest vertices on `geometry` to the given `inputPoint` that are less than or equal to the planar distance of search radius.
+ * The array is sorted by distance to the `inputPoint` 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
+ * // Return the nearest vertices on a polygon to the given point
+ * const proximityResultsArray = proximityOperator.getNearestVertices(polygon, 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 will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/relateOperator.d.ts

@@ -1,6 +1,35 @@
-import "../../interfaces";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.relateOperator["supportsCurves"];
-export const accelerateGeometry: __esri.relateOperator["accelerateGeometry"];
-export const execute: __esri.relateOperator["execute"];
-export const isValidDE9IM: __esri.relateOperator["isValidDE9IM"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster relate 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;
+
+/**
+ * @param geometry1 - The first geometry for the relation.
+ * @param geometry2 - The second geometry for the relation.
+ * @param relation - The DE-9IM matrix relation encoded as a string to test against the relationship of the two geometries
+ * @returns Returns `true` if the two geometries satisfy the DE-9IM matrix relation.
+ * @example
+ * // Returns true if the polygon geometry completely
+ * // contains the polyline based on the DE-9IM string
+ * const isRelated = relateOperator.execute(polygon, polyline, "TTTFFTFFT");
+ */
+export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion, relation: string): boolean;
+
+/**
+ * Indicates if the DE-9IM matrix relation is valid.
+ *
+ * @param relation - The DE-9IM matrix relation encoded as a string.
+ * @returns Returns `true` if the DE-9IM matrix relation is valid.
+ */
+export function isValidDE9IM(relation: string): boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/reshapeOperator.d.ts

@@ -1,4 +1,25 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
+import type Polyline from "../Polyline.js";
 
-export const supportsCurves: __esri.reshapeOperator["supportsCurves"];
-export const execute: __esri.reshapeOperator["execute"];
+/**
+ * Performs the reshape operation on a polygon or polyline using a single path polyline as the reshaper.
+ *
+ * The output geometry takes the shape of the multipath where it first intersects the reshaper to the last intersection.
+ * The first and last intersection points of the reshaper are chosen closest to the end points of the reshaper in the case that multiple intersections are found.
+ * For polygons, only individual paths can be reshaped. However, polylines can be reshaped across paths.
+ *
+ * @param geometry - The polygon or polyline to be reshaped.
+ * @param reshaper - The single path polyline reshaper.
+ * @returns If the `geometry` is a polygon, the return type is polygon, and if the `geometry` is a polyline, the return type is polyline.
+ * If the `geometry` cannot be reshaped, then the return type is null.
+ * @example
+ * // Reshape a polygon geometry
+ * const reshapedPolygon = reshapeOperator.execute(polygon, reshaperPolyline);
+ */
+export function execute(geometry: Polygon | Polyline, reshaper: Polyline): Polygon | 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/shapePreservingProjectOperator.d.ts

@@ -1,7 +1,78 @@
-import "../../interfaces";
+import type Extent from "../Extent.js";
+import type SpatialReference from "../SpatialReference.js";
+import type GeographicTransformation from "./support/GeographicTransformation.js";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.shapePreservingProjectOperator["supportsCurves"];
-export const execute: __esri.shapePreservingProjectOperator["execute"];
-export const executeMany: __esri.shapePreservingProjectOperator["executeMany"];
-export const isLoaded: __esri.shapePreservingProjectOperator["isLoaded"];
-export const load: __esri.shapePreservingProjectOperator["load"];
+export interface Options {
+  /**
+   * An extent used to help pick the correct transform.
+   * This is not used if the `geographicTransformation` option is provided.
+   * The extent's spatial reference should be the same as the `geometries` spatial reference.
+   */
+  areaOfInterestExtent?: Extent;
+  /** The geographic transformation to use in the projections. */
+  geographicTransformation?: GeographicTransformation;
+  /**
+   * Controls how much the result of the projection is allowed to deviate from the true preserved shape.
+   * The default setting of 0 represents 100 * output tolerance.
+   *
+   * @default 0
+   */
+  maxDeviationInSrTo?: number;
+  /**
+   * A lower bound controlling the densification in the input coordinate system.
+   * The default setting of 0 represents 1e-5 degrees. If the input coordinate system is a projected coordinate system, then this value is translated to length in linear units at the equator.
+   *
+   * @default 0
+   */
+  minSegmentLengthInDegrees?: number;
+}
+
+/**
+ * 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-shapePreservingProjectOperator.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Performs the shape preserving project operation on a single geometry.
+ *
+ * @param geometry - The geometry to be projected.
+ * @param outSpatialReference - The spatial reference to which the input geometry is projected.
+ * @param options - Additional options.
+ * @returns The projected geometry or null.
+ * @example
+ * if (!shapePreservingProjectOperator.isLoaded()) {
+ *   await shapePreservingProjectOperator.load();
+ * }
+ *
+ * // Project a geometry to a different spatial reference while preserving its shape.
+ * const geometry = shapePreservingProjectOperator.execute(polyline, spatialReference);
+ */
+export function execute(geometry: GeometryUnion, outSpatialReference: SpatialReference, options?: Options): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Performs the shape preserving project operation on multiple geometries.
+ *
+ * @param geometries - The geometries to be projected.
+ * All the geometries must have the same spatial reference.
+ * @param outSpatialReference - The spatial reference to which the input geometries are projected.
+ * @param options - Additional options.
+ * @returns Returns the projected geometries or null.
+ */
+export function executeMany(geometries: GeometryUnion[], outSpatialReference: SpatialReference, 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 `false`.
+ */
+export const supportsCurves: boolean | null | undefined;

package/geometry/operators/simplifyOGCOperator.d.ts

@@ -1,6 +1,62 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.simplifyOGCOperator["supportsCurves"];
-export const execute: __esri.simplifyOGCOperator["execute"];
-export const executeMany: __esri.simplifyOGCOperator["executeMany"];
-export const isSimple: __esri.simplifyOGCOperator["isSimple"];
+/**
+ * Performs the OGC simplify operation on a single geometry.
+ *
+ * @param geometry - The geometry to be simplified.
+ * @returns Returns the simplified geometry, or null. Geometry's with non-finite x or y, or infinite Zs return null.
+ * The method will set NaN z values to 0.
+ * @example
+ * // Topologically simplifies a geometry
+ * const simplified = simplifyOGCOperator.execute(polyline);
+ * console.log(simplifyOGCOperator.isSimple(simplified)); // true
+ */
+export function execute(geometry: GeometryUnion): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Performs the OGC simplify operation on the geometry set.
+ *
+ * @param geometries - The array of geometries to be simplified,
+ * All the geometries must have the same spatial reference.
+ * @returns Returns the simplified geometry, or null. Geometry's with non-finite x or y, or infinite Zs return null.
+ * The method will set NaN z values to 0.
+ */
+export function executeMany(geometries: GeometryUnion[]): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * Indicates if the given geometry is OGC topologically simple. This operation takes into account z-values.
+ *
+ * [Point](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Point.html) geometries are always simple.
+ *
+ * [Multipoint](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Multipoint.html) geometries cannot have any points with exactly equal x and y.
+ * The tolerance is taken into account.
+ *
+ * For a given [Polyline](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polyline.html) path, there can be no intersections between segments with exception of the first and the last points of a path, which can coincide forming a closed path with no boundary points.
+ * Different paths can only intersect at the boundary points.
+ *
+ * [Polygon](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html) geometries are considered simple if the following is true:
+ * * Rings cannot have self intersections, or self-tangency.
+ * * Rings are sorted such that each exterior ring is followed by its immediate interior ring (holes). The exterior ring with the corresponding holes form the OGC polygon type.
+ * * The interior has to be a connected set. Any two points in the interior can be connected by a path that contains only interior points.
+ * * Exterior rings have to be oriented clockwise, holes are oriented counterclockwise.
+ *
+ * All tests for equality or segment intersections use the tolerance and resolution.
+ * The operator uses 2 * sqrt(2) * tolerance when checking whether two points are equal, and sqrt(2) * tolerance when checking if a point lies on a segment.
+ * Both values are obtained from the geometry's spatial reference.
+ * If it is null, then a small tolerance value is calculated from the geometry coordinates using double-precision.
+ * Resolution is added to take into account possible rounding errors.
+ *
+ * @param geometry - The input geometry.
+ * @returns Returns true if the geometry is simple, otherwise returns false.
+ * @example
+ * // returns true if given geometry is OGC simple
+ * const simple = simplifyOGCOperator.isSimple(polyline);
+ * console.log(simple); // true | false
+ */
+export function isSimple(geometry: GeometryUnion): boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;