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

package/geometry/operators/simplifyOperator.d.ts

@@ -1,6 +1,64 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.simplifyOperator["supportsCurves"];
-export const execute: __esri.simplifyOperator["execute"];
-export const executeMany: __esri.simplifyOperator["executeMany"];
-export const isSimple: __esri.simplifyOperator["isSimple"];
+/**
+ * Performs the simplify operation on a single geometry.
+ *
+ * @param geometry - The geometry to be simplified.
+ * @returns Returns the simplified geometry or null.
+ * @example
+ * // Topologically simplifies a geometry
+ * const simplified = simplifyOperator.execute(polyline);
+ * console.log(simplifyOperator.isSimple(simplified)); // true
+ */
+export function execute(geometry: GeometryUnion): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Performs the 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 an array whose elements may either be simplified geometries or null.
+ */
+export function executeMany(geometries: GeometryUnion[]): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * Indicates if the given geometry is non-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 not taken into account.
+ *
+ * [Polyline](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polyline.html) geometries can have self-intersecting paths, however they cannot have degenerate segments.
+ * A degenerate segment is a zero-length segment where the start and end points are essentially the same.
+ * When the polyline has no z, degenerate segments are those that have a length in the xy plane less than or equal to the tolerance.
+ * When the polyline has z, degenerate segments are those that are shorter than the tolerance in the xy plane, and the change in the z-value along the segment is less than or equal to the z-tolerance.
+ *
+ * [Polygon](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html) geometries are considered simple if the following is true:
+ * * Contains no self-intersecting rings.
+ * * Exterior rings are clockwise, and interior rings (holes) are counterclockwise.
+ * * Rings can touch other rings in a finite number of points.
+ * * Rings can be self-tangent in a finite number of points.
+ * * Vertices are either exactly coincident, or further than the 2 * sqrt(2) * tolerance from each other.
+ * * If a vertex is not equal to any boundary point of a segment, it has to be further than sqrt(2) * tolerance from any segment.
+ * * No segment length is zero.
+ * * Each path contains at least three non-equal vertices.
+ * * No empty paths are allowed.
+ * * Order of rings does not matter.
+ *
+ * The tolerance value is 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.
+ *
+ * @param geometry - The input geometry.
+ * @returns Returns true if the geometry is simple, otherwise returns false.
+ * @example
+ * // returns true if given geometry is simple
+ * const simple = simplifyOperator.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;

package/geometry/operators/support/GeographicTransformation.d.ts

@@ -1,4 +1,62 @@
-import "../../../interfaces";
+import type Accessor from "../../../core/Accessor.js";
+import type GeographicTransformationStep from "./GeographicTransformationStep.js";
+import type { GeographicTransformationStepProperties } from "./GeographicTransformationStep.js";
 
-import GeographicTransformation = __esri.GeographicTransformation;
-export default GeographicTransformation;
+export interface GeographicTransformationProperties {
+  /**
+   * An ordered list of geographic transformation steps that represent the process of transforming coordinates from one geographic coordinate system to another.
+   * The steps are applied in the order in which they are defined.
+   *
+   * To define the steps use the [GeographicTransformationStep](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-GeographicTransformationStep.html) module.
+   *
+   * @default []
+   */
+  steps?: GeographicTransformationStepProperties[];
+}
+
+/**
+ * Create a geographic transformation that can be used to project 2D geometries between different geographic coordinate systems to ensure that data is properly aligned within a map. These transformations are used to transform coordinates between spatial references that have different geographic coordinate systems, and thus different datums.
+ *
+ * A geographic transformation converts everything that needs to be changed including the units, prime meridian, and the ellipsoid. The transformation is defined by a series of [steps](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-GeographicTransformation.html#steps), each of which is defined by a well-known text (WKT) string or a well-known ID (WKID).
+ * Using the most suitable transformation ensures the best possible accuracy when
+ * converting geometries from one spatial reference to another.
+ *
+ * The `geographicTransformationUtils` module provides the [getTransformation()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-geographicTransformationUtils.html#getTransformation) and
+ * [getTransformations()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-geographicTransformationUtils.html#getTransformations) methods which return the default geographic transformation
+ * for the given projection or a list of suitable geographic transformations.
+ *
+ * > [!WARNING]
+ * >
+ * > **Known Limitations**
+ * >
+ * > Currently, the client-side [projectOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html) only supports
+ * > [equation-based geographic transformations](https://developers.arcgis.com/rest/services-reference/enterprise/using-spatial-references.htm).
+ *
+ * @since 4.32
+ * @see [projectOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html)
+ * @see [shapePreservingProjectOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-shapePreservingProjectOperator.html)
+ * @see [Spatial References](https://developers.arcgis.com/documentation/spatial-references/)
+ * @see [Coordinate systems, map projections, and transformations](https://pro.arcgis.com/en/pro-app/latest/help/mapping/properties/coordinate-systems-and-projections.htm)
+ * @see [Geographic datum transformations](https://pro.arcgis.com/en/pro-app/latest/help/mapping/properties/geographic-coordinate-system-transformation.htm)
+ * @see [Sample - Client-side projection](https://developers.arcgis.com/javascript/latest/sample-code/client-projection/)
+ */
+export default class GeographicTransformation extends Accessor {
+  constructor(properties?: GeographicTransformationProperties);
+  /**
+   * An ordered list of geographic transformation steps that represent the process of transforming coordinates from one geographic coordinate system to another.
+   * The steps are applied in the order in which they are defined.
+   *
+   * To define the steps use the [GeographicTransformationStep](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-GeographicTransformationStep.html) module.
+   *
+   * @default []
+   */
+  get steps(): GeographicTransformationStep[];
+  set steps(value: GeographicTransformationStepProperties[]);
+  /**
+   * Returns the inverse of this geographic transformation.
+   * The inverse of a transformation converts coordinates using the same method and parameters, but in the opposite
+   * direction of the original object. For example if the original object represents the `NAD_1983_HARN_To_NAD_1983_NSRS2007_1`
+   * transformation, then the inverse will transform from `NAD 83 (NSRS 2007)` to `NAD 83 (HARN)`.
+   */
+  getInverse(): GeographicTransformation;
+}

package/geometry/operators/support/GeographicTransformationStep.d.ts

@@ -1,4 +1,63 @@
-import "../../../interfaces";
+import type Accessor from "../../../core/Accessor.js";
 
-import GeographicTransformationStep = __esri.GeographicTransformationStep;
-export default GeographicTransformationStep;
+export interface GeographicTransformationStepProperties extends Partial<Pick<GeographicTransformationStep, "isInverse" | "wkid" | "wkt">> {}
+
+/**
+ * Represents a step in the process of transforming coordinates from one geographic coordinate system to another.
+ * A geographic transformation step can be constructed from a
+ * well-known ID [(wkid)](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-GeographicTransformationStep.html#wkid) or a well known text [(wkt)](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-GeographicTransformationStep.html#wkt) that represents a geographic datum transformation.
+ *
+ * @since 4.32
+ * @see [GeographicTransformation](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-GeographicTransformation.html)
+ * @see [Spatial References](https://developers.arcgis.com/documentation/spatial-references/)
+ * @see [Coordinate systems, map projections, and transformations](https://pro.arcgis.com/en/pro-app/latest/help/mapping/properties/coordinate-systems-and-projections.htm)
+ * @see [Geographic datum transformations](https://pro.arcgis.com/en/pro-app/latest/help/mapping/properties/geographic-coordinate-system-transformation.htm)
+ * @see [About geographic transformations](https://www.esri.com/arcgis-blog/products/product/mapping/about-geographic-transformations-and-how-to-choose-the-right-one/)
+ * @see [Sample - Client-side projection](https://developers.arcgis.com/javascript/latest/sample-code/client-projection/)
+ */
+export default class GeographicTransformationStep extends Accessor {
+  constructor(properties?: GeographicTransformationStepProperties);
+  /**
+   * Indicates if the geographic transformation is inverted.
+   *
+   * @default false
+   */
+  accessor isInverse: boolean;
+  /**
+   * The well-known id (wkid) hat represents a known geographic transformation.
+   * See [Geographic datum transformations](https://pro.arcgis.com/en/pro-app/latest/help/mapping/properties/geographic-coordinate-system-transformation.htm)
+   * for the list of supported equation-based geographic transformations.
+   *
+   * @example
+   * // Create a geographic transformation step for Tokyo_To_WGS_1984_2001 using its wkid
+   * let geoStep = new GeographicTransformationStep({ wkid: 108106 });
+   */
+  accessor wkid: number | null | undefined;
+  /**
+   * The well-known text (wkt) that represents a known geographic transformation.
+   * See [Geographic datum transformations](https://pro.arcgis.com/en/pro-app/latest/help/mapping/properties/geographic-coordinate-system-transformation.htm)
+   * for the list of supported equation-based geographic transformations.
+   *
+   * @example
+   * // Create a geographic transformation step for NAD_1927_To_WGS_1984_1
+   * // using its well known text or wkt
+   * let wkt = "GEOGTRAN[\"NAD_1927_To_WGS_1984_1\",GEOGCS[\"GCS_North_American_1927\",DATUM[\"D_North_American_1927\",SPHEROID[\"Clarke_1866\",6378206.4,294.9786982]],PRIMEM[\"Greenwich\",0.0],UNIT[\"Degree\",0.0174532925199433]],GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137.0,298.257223563]],PRIMEM[\"Greenwich\",0.0],UNIT[\"Degree\",0.0174532925199433]],METHOD[\"Geocentric_Translation\"],PARAMETER[\"X_Axis_Translation\",-3.0],PARAMETER[\"Y_Axis_Translation\",142.0],PARAMETER[\"Z_Axis_Translation\",183.0]]";
+   *
+   * let geoStep = new GeographicTransformationStep({ wkt });
+   */
+  accessor wkt: string | null | undefined;
+  /**
+   * Returns the inverse of this geographic transformation step.
+   * The inverse of a transformation converts coordinates using the same method and parameters, but in the opposite
+   * direction of the original object. For example, if the original object represents the `NAD_1983_HARN_To_NAD_1983_NSRS2007_1`
+   * transformation, then the inverse will transform from `NAD 83 (NSRS 2007)` to `NAD 83 (HARN)`.
+   *
+   * @returns Returns the inverse of the geographic transformation step.
+   * @example
+   * // Get the inverse of the geographic transformation step for Tokyo_To_WGS_1984_2001 using its wkid
+   * let geoStep = new GeographicTransformationStep({ wkid: 108106 });
+   *
+   * let inverse = geoStep.getInverse();
+   */
+  getInverse(): GeographicTransformationStep;
+}

package/geometry/operators/support/Transformation.d.ts

@@ -1,4 +1,169 @@
-import "../../../interfaces";
+import type Point from "../../Point.js";
 
-import Transformation = __esri.Transformation;
-export default Transformation;
+/**
+ * The Transformation class represents 2D transformations that can be applied to geometries using the [affineTransformOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-affineTransformOperator.html). All transformations are applied in the spatial reference units of the input geometries.
+ *
+ * @since 4.31
+ */
+export default class Transformation {
+  constructor();
+  /**
+   * Calculates distance errors for a transformation on a given set of the input points to the output points.
+   * This method is usually used to calculate errors for the transformation initialized by [initializeFromControlPoints()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-Transformation.html#initializeFromControlPoints).
+   *
+   * The length of the `input` and `output` arrays must be the same.
+   *
+   * @param input - The input points to transform from.
+   * @param output - The output points to transform to.
+   * @returns Returns an object representing the errors incurred during transformation.
+   * @example
+   * // Calculate the errors for a transformation
+   * const errors = transformation.calculateErrors(inputPoints, outputPoints);
+   * // Example returned object:
+   * // { rms: 0.5, errorsOut: [0.1, 0.2, 0.3, 0.4, 0.5] }
+   */
+  calculateErrors(input: Point[], output: Point[]): ErrorResult;
+  /**
+   * Flips all the `x` coordinates of geometries on the vertical y-axis (right or left) that is centered between `x0` and `x1`.
+   * For example, if `x0` is 0 and `x1` is 10, all the `x` coordinates of the geometries will be flipped, or mirrored, on the vertical axis centered at `x = 5`.
+   *
+   * ![FlipX transformation](https://developers.arcgis.com/javascript/latest/assets/img/apiref/operators/flipX.png "FlipX transformation")
+   *
+   * @param x0 - The x-coordinate of the first geometry.
+   * @param x1 - The x-coordinate of the second geometry.
+   * @example
+   * // Flip the x-coordinates of a geometry on the vertical axis
+   * const transform = new Transformation();
+   * transform.flipX(0, 10);
+   * const result = affineTransformOperator.execute(polygon, transform);
+   *
+   * // Flip the x-coordinates of a geometry on the vertical axis centered at the geometry's center
+   * const centerX = polygon.extent.center.x;
+   * transform.flipX(centerX, centerX);
+   * const result = affineTransformOperator.execute(polygon, transform);
+   */
+  flipX(x0: number, x1: number): this;
+  /**
+   * Flips all the `y` coordinates of geometries on the horizontal x-axis (up or down) that is centered between `y0` and `y1`.
+   * For example, if `y0` is 0 and `y1` is 10, all the `y` coordinates of the geometries will be flipped, or mirrored, on the horizontal axis centered at `y = 5`.
+   *
+   * ![FlipY transformation](https://developers.arcgis.com/javascript/latest/assets/img/apiref/operators/flipY.png "FlipY transformation")
+   *
+   * @param y0 - The y-coordinate of the first geometry.
+   * @param y1 - The y-coordinate of the second geometry.
+   * @example
+   * // Flip the y-coordinates of a geometry on the vertical axis
+   * transformation.flipY(0, 10);
+   * const result = affineTransformOperator.execute(polygon, transform);
+   *
+   * // Flip the y-coordinates of a geometry on the horizontal axis centered at the geometry's center
+   * const centerY = polygon.extent.center.y;
+   * transform.flipY(centerY, centerY);
+   * const result = affineTransformOperator.execute(polygon, transform);
+   */
+  flipY(y0: number, y1: number): this;
+  /**
+   * Initializes a new transformation from the input and output control points.
+   * Uses least squares method to find the best fit transformation.
+   * Adding control points allows you to snap lines and polygons to the input and output points on a map.
+   *
+   * The length of the `input` and `output` arrays must be the same.
+   *
+   * @param type - The type of transformation to initialize.
+   *
+   * Value | Description
+   * ------|------------
+   * "conformal" | Preserves the angles between curves.
+   * "general" | Preserves lines and parallelisms. Does not preserve angles or lengths.
+   * @param input - The input points to transform from.
+   * @param output - The output points to transform to.
+   * @param inverseOut - The transformation instance that is the inverse of the calculated transformation.
+   * @example
+   * // Initialize a transformation from control points
+   * transformation.initializeFromControlPoints("conformal", inputPoints, outputPoints);
+   */
+  initializeFromControlPoints(type: "conformal" | "general", input: Point[], output: Point[], inverseOut?: Transformation): void;
+  /**
+   * Determines if the transformation is in its default state, which is an identity matrix.
+   *
+   * @returns Returns `true` if the transformation is the default and has not been changed.
+   * There will be no change in the geometries when applying the transformation.
+   * @see [setIdentity()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-Transformation.html#setIdentity)
+   */
+  isIdentity(): boolean;
+  /**
+   * Rotates the geometries by the specified angle in degrees around the point specified by the x and y coordinates.
+   * The point can be the center of the geometries or any other point.
+   *
+   * ![Rotate transformation](https://developers.arcgis.com/javascript/latest/assets/img/apiref/operators/rotate.png "Rotate transformation")
+   *
+   * @param angleInDegrees - The angle to rotate the geometries in degrees.
+   * @param rotationX - The x-coordinate of the point to rotate around.
+   * @param rotationY - The y-coordinate of the point to rotate around.
+   * @example
+   * // Rotate a geometry
+   * transformation.rotate(90, 0, 0);
+   * const result = affineTransformOperator.execute(polygon, transform);
+   */
+  rotate(angleInDegrees: number, rotationX?: number, rotationY?: number): this;
+  /**
+   * Resizes the geometries by the specified scale factors defined by the x and y coordinates.
+   * The coordinates define how much scaling is applied to the geometries in the x and y directions.
+   *
+   * ![Scale transformation](https://developers.arcgis.com/javascript/latest/assets/img/apiref/operators/scale.png "Scale transformation")
+   *
+   * @param x - The x-coordinate that defines the horizontal scale factor.
+   * @param y - The y-coordinate that defines the vertical scale factor.
+   * @example
+   * // Scale a geometry
+   * transformation.scale(2, 2);
+   * const result = affineTransformOperator.execute(polygon, transform);
+   */
+  scale(x: number, y: number): this;
+  /**
+   * Use this method to reset the transformation to its default state, which is an identity matrix.
+   * This method is useful when reusing the class instance for multiple transformations.
+   *
+   * @see [Wikipedia - Identity Matrix](https://en.wikipedia.org/wiki/Identity_matrix)
+   */
+  setIdentity(): void;
+  /** Use this method to swap the x and y coordinate values in the transformation. An example usage is when slicing vertically with the [polgonSlicerOperator.findSlicesByArea()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-polygonSlicerOperator.html#findSlicesByArea) method. */
+  setSwapCoordinates(): this;
+  /**
+   * Shifts a geometry's points by the specified proportion in parallel to the x and y directions,
+   * except those points that are along the shear axis, which is a line defined by the x and y coordinates.
+   * This transformation preserves lines and parallelisms, however it may distort angles and distances.
+   * Applying this transformation will not change a geometry's area.
+   *
+   * ![Shear transformation](https://developers.arcgis.com/javascript/latest/assets/img/apiref/operators/shear.png "Shear transformation")
+   *
+   * @param proportionX - The proportion to shear the geometry in the x direction.
+   * @param proportionY - The proportion to shear the geometry in the y direction.
+   * @example
+   * // Shear a geometry
+   * transformation.shear(0.5, 0.5);
+   * const result = affineTransformOperator.execute(polygon, transform);
+   */
+  shear(proportionX: number, proportionY: number): this;
+  /**
+   * Shifts all the coordinates of the geometries by the distance and direction between the specified `x` and `y` coordinates and their current location. This operation does not change the size or shape of the geometries.
+   *
+   * ![Shift transformation](https://developers.arcgis.com/javascript/latest/assets/img/apiref/operators/shift.png "Shift transformation")
+   *
+   * @param x - The x-coordinate to shift by.
+   * @param y - The y-coordinate to shift by.
+   * @example
+   * // Shift the coordinates of a geometry
+   * transformation.shift(5, 2);
+   * const result = affineTransformOperator.execute(polygon, transform);
+   */
+  shift(x: number, y: number): this;
+}
+
+/** Object returned from the [calculateErrors()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-support-Transformation.html#calculateErrors) method. */
+export interface ErrorResult {
+  /** Contains the errors of the individual distance differences between specific pairs of points. */
+  errorsOut: number[];
+  /** The root mean square (`rms`) of the 'average' distance error between the specified `output` points and the transformed `input` points. */
+  rms: number;
+}

package/geometry/operators/support/geodeticCurveType.d.ts

@@ -0,0 +1,2 @@
+
+export type GeodeticCurveType = "geodesic" | "loxodrome" | "great-elliptic" | "normal-section" | "shape-preserving";

package/geometry/operators/support/geographicTransformationUtils.d.ts

@@ -1,6 +1,114 @@
-import "../../../interfaces";
+import type Extent from "../../Extent.js";
+import type SpatialReference from "../../SpatialReference.js";
+import type GeographicTransformation from "./GeographicTransformation.js";
 
-export const getTransformation: __esri.geographicTransformationUtils["getTransformation"];
-export const getTransformations: __esri.geographicTransformationUtils["getTransformations"];
-export const isLoaded: __esri.geographicTransformationUtils["isLoaded"];
-export const load: __esri.geographicTransformationUtils["load"];
+/**
+ * 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-support-geographicTransformationUtils.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Returns the default equation-based, geographic transformation used to convert a geometry
+ * from the input spatial reference to the output spatial reference.
+ * The default transformation is used when projecting geometries using the [projectOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html)
+ * where the datum transformation is required but not specified in the operator's `geographicTransformation` parameter.
+ *
+ * > [!WARNING]
+ * >
+ * > **Known Limitations**
+ * >
+ * > This method returns only equation-based geographic transformations.
+ * > Geographic transformations are returned with their maximum number of {@link geometry/support/GeographicTransformation#steps}.
+ * > Currently, the number of steps is limited to 2.
+ *
+ * @param inSpatialReference - The input spatial reference from which to project geometries.
+ *   This is the spatial reference of the input geometries.
+ * @param outSpatialReference - The spatial reference to which you are converting the geometries.
+ * @param areaOfInterestExtent - An extent used to determine the suitability of the returned transformation.
+ * The extent's spatial reference should be the same as `inSpatialReference`.
+ * @returns Returns the default geographic transformation for the given parameters.
+ * If no transformation is required or there are no suitable transformations, then `null` is returned.
+ * @example
+ * const cs1 = new SpatialReference({
+ *   wkid: 4272 //PE_GCS_ED_1950
+ * });
+ *
+ * const cs2 = new SpatialReference({
+ *   wkid: 4167
+ * });
+ *
+ * const extent = new Extent({
+ *   xmin: -186.0,
+ *   ymin: -42.0,
+ *   xmax: -179.0,
+ *   ymax: -38.0,
+ *   spatialReference: cs1
+ * });
+ *
+ * if (!geographicTransformationUtils.isLoaded()) {
+ *   await geographicTransformationUtils.load();
+ * }
+ *
+ * const geogtrans = projection.getTransformation(cs1, cs2, extent);
+ */
+export function getTransformation(inSpatialReference: SpatialReference, outSpatialReference: SpatialReference, areaOfInterestExtent?: Extent | null): GeographicTransformation | null | undefined;
+
+/**
+ * Returns a list of all equation-based, geographic transformations suitable to convert geometries from the input spatial reference
+ * to the specified output spatial reference. The list is ordered in descending order by suitability, with the
+ * most suitable being first in the list.
+ *
+ * > [!WARNING]
+ * >
+ * > **Known Limitations**
+ * >
+ * > This method returns only equation-based geographic transformations.
+ * > Geographic transformations are returned with their maximum number of {@link geometry/support/GeographicTransformation#steps}.
+ * >   Currently, number of steps is limited to 2.
+ *
+ * @param inSpatialReference - The spatial reference that the geometries are currently using.
+ * @param outSpatialReference - The spatial reference to which you are converting the geometries to.
+ * @param areaOfInterestExtent - An extent used to help pick the correct transform.
+ * The extent's spatial reference should be the same as `inSpatialReference`.
+ * @returns Returns an array containing the maximum number the suitable
+ * geographic transformations that can be used to convert geometries between input and output spatial references.
+ * The list will be empty if the provided extent lies out of the area of use for the input spatial reference, or if no transformation is required, or there are no suitable transformations.
+ * @example
+ * const cs1 = new SpatialReference({
+ *   wkid: 4272 //PE_GCS_ED_1950
+ * });
+ *
+ * const cs2 = new SpatialReference({
+ *   wkid: 4167
+ * });
+ *
+ * const extent = new Extent({
+ *   xmin: -186.0,
+ *   ymin: -42.0,
+ *   xmax: -179.0,
+ *   ymax: -38.0,
+ *   spatialReference: cs1
+ * });
+ *
+ * if (!geographicTransformationUtils.isLoaded()) {
+ *   await geographicTransformationUtils.load();
+ * }
+ *
+ * const geogtrans = projection.getTransformations(cs1, cs2, extent);
+ * geogtrans.forEach((geogtran, index) => {
+ *   geogtran.steps.forEach((step, index) => {
+ *     console.log("step wkid: ", step.wkid);
+ *   });
+ * });
+ */
+export function getTransformations(inSpatialReference: SpatialReference, outSpatialReference: SpatialReference, areaOfInterestExtent?: Extent | null): GeographicTransformation[];

package/geometry/operators/support/projectionTransformation.d.ts

@@ -0,0 +1,16 @@
+import type Extent from "../../Extent.js";
+import type GeographicTransformation from "./GeographicTransformation.js";
+
+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 | null;
+  /**
+   * The geographic transformation used to transform the geometries.
+   * Specify this parameter to project a geometry when the default transformation is not appropriate for your requirements.
+   */
+  geographicTransformation?: GeographicTransformation | null;
+}

package/geometry/operators/support/proximityResult.d.ts

@@ -0,0 +1,24 @@
+import type Point from "../../Point.js";
+
+/** Object returned from the [getNearestCoordinate()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-proximityOperator.html#getNearestCoordinate), {@link geometry/operators/proximityOperator#nearestVegetNearestVertex getNearestVertex()}, and [getNearestVertices()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-proximityOperator.html#getNearestVertices) methods. */
+export interface ProximityResult {
+  /** The nearest coordinate on the geometry to the given input point. */
+  coordinate: Point;
+  /**
+   * The planar distance between the input point and the nearest coordinate on the geometry.
+   * Unless the `unit` option is set, the default is the spatial reference unit of the input geometries.
+   */
+  distance: number;
+  /** Indicates if the result is empty. */
+  isEmpty: boolean;
+  /**
+   * Indicates if the nearest coordinate is on the right side or left side of the input point.
+   *
+   * > [!WARNING]
+   * >
+   * > Note: This property will only be present when `calculateLeftRightSide` is set to `true` when calling `getNearestCoordinate()`.
+   */
+  isRightSide?: boolean;
+  /** The index of the vertex on the geometry that is closest to the input point. */
+  vertexIndex: number;
+}

package/geometry/operators/symmetricDifferenceOperator.d.ts

@@ -1,5 +1,28 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.symmetricDifferenceOperator["supportsCurves"];
-export const execute: __esri.symmetricDifferenceOperator["execute"];
-export const executeMany: __esri.symmetricDifferenceOperator["executeMany"];
+/**
+ * Performs the symmetric difference (XOR) operation on two geometries.
+ *
+ * @param leftGeometry - The first geometry to be XOR'd.
+ * @param rightGeometry - The second geometry to be XOR'd.
+ * @returns Returns the symmetric difference of the two geometries. The result has the higher of dimensions of the two geometries.
+ * @example
+ * // Calculate the symmetric difference of two polygons.
+ * const differencePolygon = symmetricDifferenceOperator.execute(polygon1, polygon2);
+ */
+export function execute(leftGeometry: GeometryUnion, rightGeometry: GeometryUnion): GeometrySansMeshUnion;
+
+/**
+ * Performs the symmetric difference (XOR) operation on every geometry in `inputGeometries` with `rightGeometry`.
+ *
+ * @param inputGeometries - The set of geometries to be XOR'd by the `rightGeometry`.
+ * @param rightGeometry - The geometry being XOR'd with the `inputGeometries`.
+ * @returns Returns an array of the result geometries.
+ */
+export function executeMany(inputGeometries: GeometryUnion[], rightGeometry: GeometryUnion): GeometrySansMeshUnion[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/touchesOperator.d.ts

@@ -1,5 +1,27 @@
-import "../../interfaces";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.touchesOperator["supportsCurves"];
-export const accelerateGeometry: __esri.touchesOperator["accelerateGeometry"];
-export const execute: __esri.touchesOperator["execute"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster touches 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 touches operation on two geometries.
+ *
+ * @param geometry1 - The base geometry that is tested for the "touches" relationship with `geometry2`.
+ * @param geometry2 - The comparison geometry that is tested for the "touches" relationship with `geometry1`.
+ * @returns Returns `true` if the two geometries touch.
+ * @example
+ * // Returns true if the line vertex touches the edge of the polygon
+ * const isTouching = touchOperator.execute(polygon, line);
+ */
+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/unionOperator.d.ts

@@ -1,5 +1,28 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.unionOperator["supportsCurves"];
-export const execute: __esri.unionOperator["execute"];
-export const executeMany: __esri.unionOperator["executeMany"];
+/**
+ * Perform a topological union operation on two geometries.
+ *
+ * @param geometry1 - The first geometry to union with.
+ * @param geometry2 - The second geometry to union with.
+ * @returns Returns the union of the two geometries as a geometry or null.
+ * @example
+ * // Return the union of two polygons
+ * const union = unionOperator.execute(polygon1, polygon2);
+ */
+export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Perform a topological union operation on a geometry set.
+ *
+ * @param geometries - The array of geometries to union.
+ * All the geometries must have the same spatial reference.
+ * @returns Returns the union of `geometries` as a geometry or null.
+ */
+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;