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

package/geometry/operators/geodeticLengthOperator.d.ts

@@ -1,6 +1,56 @@
-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.geodeticLengthOperator["supportsCurves"];
-export const execute: __esri.geodeticLengthOperator["execute"];
-export const isLoaded: __esri.geodeticLengthOperator["isLoaded"];
-export const load: __esri.geodeticLengthOperator["load"];
+export interface Options {
+  /**
+   * The type of geodetic curve used to determine the length.
+   *
+   * @default "geodesic"
+   */
+  curveType?: GeodeticCurveType;
+  /**
+   * The length unit of the return value.
+   *
+   * @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-geodeticLengthOperator.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Calculates the geodetic length of the input Geometry.
+ * Unless the `unit` option is set, the default is meters.
+ *
+ * @param geometry - The input geometry.
+ * @param options - Additional options.
+ * @returns Returns the geodetic length of the input geometry.
+ * @example
+ * if (!geodeticLengthOperator.isLoaded()) {
+ *   await geodeticLengthOperator.load();
+ * }
+ *
+ * // Calculate the geodetic length of a polyline
+ * const length = geodeticLengthOperator.execute(polyline);
+ */
+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/geodeticUtilsOperator.d.ts

@@ -1,6 +1,105 @@
-import "../../interfaces";
+import type Point from "../Point.js";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeodeticCurveType } from "./support/geodeticCurveType.js";
 
-export const calculateDistanceAndAzimuth: __esri.geodeticUtilsOperator["calculateDistanceAndAzimuth"];
-export const isLoaded: __esri.geodeticUtilsOperator["isLoaded"];
-export const load: __esri.geodeticUtilsOperator["load"];
-export const pointFromDistance: __esri.geodeticUtilsOperator["pointFromDistance"];
+export interface Options {
+  /**
+   * The type of geodetic curve along which distance will be measured.
+   * The default curveType of geodesic returns the shortest distance between `point1` and `point2`.
+   *
+   * @default "geodesic"
+   */
+  curveType?: Exclude<GeodeticCurveType, "shape-preserving">;
+  /**
+   * The length unit of the distance.
+   *
+   * @default "meters"
+   */
+  unit?: LengthUnit;
+}
+
+/**
+ * Object returned by the [calculateDistanceAndAzimuth()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-geodeticUtilsOperator.html#calculateDistanceAndAzimuth) method.
+ * Azimuths are in positive degrees from 0 to 360, measured clockwise from due north.
+ */
+export interface CalculateDistanceAndAzimuthResult {
+  /** The azimuth in degrees from `point1` to `point2`. */
+  azimuth12: number;
+  /**
+   * The azimuth in degrees from `point2` to `point1`.
+   *
+   * For example, Berlin is almost due north of Rome.
+   * The azimuth from Rome to Berlin is 3°; close to due north (0°) but a little east.
+   * The azimuth from Berlin to Rome is 183°; close to due south (180°) but a little west.
+   *
+   * For another example, Shanghai is almost due east of Wuhan.
+   * The azimuth from Wuhan to Shanghai is 82°; close to due east (90°) but a little north.
+   * The azimuth from Shanghai to Wuhan is 266°; close to due west (270°) but a little south.
+   */
+  azimuth21: number;
+  /** The geodetic distance between `point1` and `point2`. */
+  distance: 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-geodeticUtilsOperator.html#isLoaded)
+ */
+export function load(): Promise<void>;
+
+/**
+ * Geodetically calculates the distance and direction between two points.
+ * Unless the `unit` option is set, the default is meters.
+ *
+ * ![Calculate Distance and Azimuth operator](https://developers.arcgis.com/javascript/latest/assets/img/apiref/operators/calculateDistanceAndAzimuth.png "Calculate Distance and Azimuth operator")
+ *
+ * @param point1 - The starting point.
+ * @param point2 - The ending point.
+ * @param options - Additional options.
+ * @returns Returns an object containing the distance and azimuths between the two points.
+ * @example
+ * if (!geodeticUtilsOperator.isLoaded()) {
+ *   await geodeticUtilsOperator.load();
+ * }
+ *
+ * const distanceAndAzimuthResult = geodeticUtilsOperator.calculateDistanceAndAzimuth(
+ *   new Point({ x: -118.805, y: 34.027, spatialReference: { wkid: 4326 } }),
+ *   new Point({ x: -118.802, y: 34.029, spatialReference: { wkid: 4326 } })
+ * );
+ */
+export function calculateDistanceAndAzimuth(point1: Point, point2: Point, options?: Options): CalculateDistanceAndAzimuthResult;
+
+/**
+ * Geodetically calculates a point location at a defined distance and direction from a known point.
+ * Unless the `unit` option is set, the default is meters.
+ *
+ * ![Point From Distance operator](https://developers.arcgis.com/javascript/latest/assets/img/apiref/operators/pointFromDistance.png "Point From Distance operator")
+ *
+ * @param point - Origin location.
+ * @param distance - Distance from the origin point.
+ * @param azimuth - Direction in degrees (0 +/- 360) from the origin point, where both 0 and 360 degrees represent due north.
+ * A positive azimuth is measured clockwise from north.
+ * A negative azimuth is measured counter-clockwise from north.
+ * @param options - Additional options.
+ * @returns Returns the new point or `null` if the point cannot be represented in the spatial reference.
+ * @example
+ * if (!geodeticUtilsOperator.isLoaded()) {
+ *   await geodeticUtilsOperator.load();
+ * }
+ *
+ * const point = geodeticUtilsOperator.pointFromDistance(
+ *   new Point({ x: -118.805, y: 34.027, spatialReference: { wkid: 4326 } }),
+ *   350,
+ *   45
+ * );
+ */
+export function pointFromDistance(point: Point, distance: number, azimuth: number, options?: Options): Point | null | undefined;

package/geometry/operators/graphicBufferOperator.d.ts

@@ -1,4 +1,75 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.graphicBufferOperator["supportsCurves"];
-export const executeMany: __esri.graphicBufferOperator["executeMany"];
+export interface Options {
+  /**
+   * The max deviation of the result buffer from the true buffer in the geometries spatial reference units.
+   * When the value is NaN, internal logic is used to select the deviation based on the buffer distance.
+   * Unless the `unit` option is set, the default is the geometries spatial reference unit.
+   *
+   * @default NaN
+   */
+  maxDeviation?: number;
+  /**
+   * The maximum number of vertices in the polygon produced from a buffered point.
+   *
+   * @default 96
+   */
+  maxVerticesInFullCircle?: number;
+  /**
+   * Defines when miter joins are replaced with bevel joins.
+   *
+   * @default 10
+   */
+  miterLimit?: number;
+  /**
+   * Indicates if the buffer geometries should be unioned. When set to `true`, the output will be a single geometry.
+   *
+   * @default false
+   */
+  union?: boolean;
+  /**
+   * The length unit of the buffer distances and max deviation.
+   * 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 a buffer around the input geometries, using graphical joins and caps.
+ *
+ * Both `maxDeviation` and `maxVerticesInFullCircle` control the quality of round joins that are in the buffers.
+ * The precision of each buffer is defined by `maxDeviation` unless the number of required vertices is too large.
+ *
+ * @param geometries - The input geometries to be buffered.
+ * All the geometries must have the same spatial reference.
+ * @param distances - The buffer distances for the geometries.
+ * If the size of this array is less than the number of geometries in the input `geometries`, the last distance value is used for the rest of geometries.
+ * Unless the `unit` option is set, the default is the geometries spatial reference unit.
+ * @param joins - Defines the buffers shape where geometries are joined.
+ * * Miter joins are replaced with bevel when the ratio of the miter thickness to the buffer distance is greater than miter limit. The miter thickness is the distance from the vertex to the mitered corner of the buffer that this vertex generates.
+ * @param caps - Defines the buffers shape at the end points of the geometries.
+ * * Points with square caps will be drawn as squares.
+ * * Open polylines paths with square caps degenerate to a point and will be drawn as squares (degenerate with zero tolerance).
+ * * Open polylines paths with round caps degenerate to a point and will be drawn as circles (degenerate with zero tolerance).
+ * @param options - Additional options.
+ * @returns Returns the buffered geometries.
+ * @example
+ * // Buffer two polylines with different distances and buffer styles.
+ * const buffers = graphicBufferOperator.executeMany(
+ *   [polyline1, polyline2],
+ *   [1000, 1500],
+ *   "square",
+ *   "round",
+ *   10,
+ * );
+ */
+export function executeMany(geometries: GeometryUnion[], distances: number[], joins: "round" | "miter" | "bevel", caps: "round" | "butt" | "square", options?: Options): Polygon[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`. This will produce densified output geometries.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/integrateOperator.d.ts

@@ -1,4 +1,20 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.integrateOperator["supportsCurves"];
-export const executeMany: __esri.integrateOperator["executeMany"];
+/**
+ * Performs the topological integration of the geometry set in the XY plane.
+ *
+ * @param geometries - The set of geometries to integrate.
+ * All the geometries must have the same spatial reference.
+ * @returns Returns the result of the subtraction.
+ * The operation filters out degenerate segments and returns `null` for empty geometries.
+ * @example
+ * // Integrate a set of geometries
+ * const result = integrateOperator.executeMany(geometries);
+ */
+export function executeMany(geometries: GeometryUnion[]): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/intersectionOperator.d.ts

@@ -1,6 +1,75 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.intersectionOperator["supportsCurves"];
-export const accelerateGeometry: __esri.intersectionOperator["accelerateGeometry"];
-export const execute: __esri.intersectionOperator["execute"];
-export const executeMany: __esri.intersectionOperator["executeMany"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster intersection 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;
+
+/**
+ * Performs the topological intersection operation on two geometries.
+ *
+ * If the input geometries have different dimensions (i.e. point = 0; polyline = 1; polygon = 2),
+ * then the result's dimension will be equal to the lowest dimension of the inputs.
+ *
+ * The table below describes the expected output for various combinations of geometry
+ * types. Note that the geometries are interchangeable in this operation
+ * and will return the same result if flipped.
+ *
+ * `geometry1` type | `geometry2` type | Result geometry type
+ * --------------|---------------------------|---------------------
+ * Polygon/Extent | Polygon/Extent | Polygon
+ * Polygon/Extent | Polyline | Polyline
+ * Polygon | Point | Point
+ * Polygon | Multipoint | Multipoint
+ * Polyline | Polyline | Polyline
+ * Polyline | Point | Point
+ * Polyline | Multipoint | Multipoint
+ * Point | Point | Point
+ * Multipoint | Multipoint | Multipoint
+ *
+ * Note that two intersecting polylines will not return point geometries. Instead, this operator will return polyline paths that are equal or overlap between the two geometries. See [executyMany()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-intersectionOperator.html#executeMany) to find the point intersections of two polylines.
+ *
+ * @param geometry1 - The geometry to intersect with  `geometry2`.
+ * @param geometry2 - The geometry to intersect with `geometry1`.
+ * @returns Returns the result of the intersection of the two geometries or null.
+ * @example
+ * // Creates a new geometry based on the intersection of two polygons
+ * const intersection = intersectionOperator.execute(polygon1, polygon2);
+ */
+export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion): GeometrySansMeshUnion | null | undefined;
+
+/**
+ * Performs the topological intersection operation on the geometry set.
+ *
+ * The table below describes the potential results for various combinations of geometry
+ * types based on how they intersect. For example, a polyline that touches a polygon would return a multipoint.
+ * If the geometries do not intersect, an empty array will be returned.
+ *
+ * Input geometry type | Intersector geometry type | Result geometry types
+ * --------------|---------------------------|---------------------
+ * Point/Multipoint | Point/Multipoint | Multipoint
+ * Point/Multipoint | Polyline | Multipoint
+ * Point/Multipoint | Polygon/Extent | Multipoint
+ * Polyline | Point, Multipoint | Multipoint
+ * Polyline | Polyline | Polyline, Multipoint
+ * Polyline | Polygon/Extent | Polyline, Multipoint
+ * Polygon/Extent | Point/Multipoint | Multipoint
+ * Polygon/Extent | Polyline | Multipoint, Polyline
+ * Polygon/Extent | Polygon/Extent | Multipoint, Polyline, Polygon
+ *
+ * @param geometries - The set of input geometries to be intersected by the `intersector`.
+ * All the geometries must have the same spatial reference.
+ * @param intersector - The geometry to intersect with the `geometries`.
+ * @returns Returns an array of geometries created by intersecting
+ * every geometry in the input geometries with the `intersector`, or an empty array if there is no intersection.
+ */
+export function executeMany(geometries: GeometryUnion[], intersector: 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/intersectsOperator.d.ts

@@ -1,5 +1,27 @@
-import "../../interfaces";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.intersectsOperator["supportsCurves"];
-export const accelerateGeometry: __esri.intersectsOperator["accelerateGeometry"];
-export const execute: __esri.intersectsOperator["execute"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster intersects 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 intersects operation on two geometries.
+ *
+ * @param geometry1 - The geometry that is tested for the intersects relationship to `geometry2`.
+ * @param geometry2 - The geometry being intersected.
+ * @returns Returns `true` if `geometry1` intersects with `geometry2`.
+ * @example
+ * // Returns true if two geometries intersect
+ * const isIntersecting = intersectsOperator.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/isNearOperator.d.ts

@@ -1,4 +1,32 @@
-import "../../interfaces";
+import type { LengthUnit } from "../../core/units.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.isNearOperator["supportsCurves"];
-export const execute: __esri.isNearOperator["execute"];
+export interface Options {
+  /**
+   * The length unit of the distance.
+   * Unless the `unit` option is set, the default is the geometry's spatial reference unit.
+   * An error will be thrown if this is set for Geographic Coordinate Systems.
+   */
+  unit?: LengthUnit;
+}
+
+/**
+ * Returns true if the geometries are not further than the given 2D distance from each other.
+ *
+ * @param geometry1 - The first geometry.
+ * @param geometry2 - The second geometry.
+ * @param distance - The distance (must be positive).
+ * Unless the `unit` option is set, the default is the geometry's spatial reference unit.
+ * @param options - Additional options.
+ * @returns Returns `true` if the minimum distance between the two geometries is equal or less than `distance`.
+ * @example
+ * // Check if two geometries are near each other
+ * const isNear = isNearOperator.execute(point, polyline, 100);
+ */
+export function execute(geometry1: GeometryUnion, geometry2: GeometryUnion, distance: number, options?: Options): boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/labelPointOperator.d.ts

@@ -1,5 +1,28 @@
-import "../../interfaces";
+import type Point from "../Point.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.labelPointOperator["supportsCurves"];
-export const execute: __esri.labelPointOperator["execute"];
-export const executeMany: __esri.labelPointOperator["executeMany"];
+/**
+ * Performs the label point operation on the geometry.
+ *
+ * @param geometry - The input geometry.
+ * @returns Returns the label point.
+ * @example
+ * // Perform the label point operation
+ * const labelPoint = labelPointOperator.execute(polygon);
+ */
+export function execute(geometry: GeometryUnion): Point;
+
+/**
+ * Performs the label point operation on the geometry set.
+ *
+ * @param geometries - The set of input geometries.
+ * All the geometries must have the same spatial reference.
+ * @returns Returns the label points for each geometry.
+ */
+export function executeMany(geometries: GeometryUnion[]): Point[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/lengthOperator.d.ts

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

package/geometry/operators/linesToPolygonsOperator.d.ts

@@ -1,4 +1,20 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.linesToPolygonsOperator["supportsCurves"];
-export const executeMany: __esri.linesToPolygonsOperator["executeMany"];
+/**
+ * Performs the topological lines to polygons operation.
+ *
+ * @param geometries - The set of input geometries.
+ * All the geometries must have the same spatial reference.
+ * @returns Returns the result of polygons.
+ * @example
+ * // Perform the lines to polygons operation
+ * const polygons = linesToPolygonsOperator.executeMany([polyline1, polyline2]);
+ */
+export function executeMany(geometries: GeometryUnion[]): Polygon[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/locateBetweenOperator.d.ts

@@ -1,4 +1,24 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.locateBetweenOperator["supportsCurves"];
-export const executeMany: __esri.locateBetweenOperator["executeMany"];
+/**
+ * Performs the locate between or locate along operation on the geometry.
+ * For locate along, the start and end M values are equal.
+ *
+ * @param geometries - The set of input geometries.
+ * All the geometries must have the same spatial reference.
+ * @param startM - The M value to start the operation.
+ * @param endM - The M value to end the operation.
+ * @returns Returns the result of geometries.
+ * For 1-dimensional geometries, the result could be either point, multipoint, or polyline.
+ * For polylines, the result can be both polyline and multipoint.
+ * @example
+ * // Perform the locate between operation
+ * const geometries = locateBetweenOperator.executeMany([polyline1, polyline2], 100, 200);
+ */
+export function executeMany(geometries: GeometryUnion[], startM: number, endM: number): (GeometrySansMeshUnion | null | undefined)[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/minimumBoundingCircleOperator.d.ts

@@ -1,5 +1,39 @@
-import "../../interfaces";
+import type Polygon from "../Polygon.js";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.minimumBoundingCircleOperator["supportsCurves"];
-export const execute: __esri.minimumBoundingCircleOperator["execute"];
-export const executeMany: __esri.minimumBoundingCircleOperator["executeMany"];
+export interface Options {
+  /**
+   * If `true`, the input geometries will be merged into a single geometry before
+   * calculating the minimum bounding circle.
+   *
+   * @default false
+   */
+  merge?: boolean;
+}
+
+/**
+ * Performs the minimum bounding circle operation on the geometry.
+ *
+ * @param geometry - The input geometry.
+ * @returns Returns the minimum bounding circle polygon with [curves](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html#curveRings).
+ * @example
+ * // Perform the minimum bounding circle operation
+ * const minimumBoundingCircle = minimumBoundingCircleOperator.execute(polygon);
+ */
+export function execute(geometry: GeometryUnion): Polygon;
+
+/**
+ * Performs the minimum bounding circle operation on the geometry set.
+ *
+ * @param geometries - The set of input geometries.
+ * All the geometries must have the same spatial reference.
+ * @param options - Additional options.
+ * @returns Returns the minimum bounding circle polygons with [curves](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html#curveRings).
+ */
+export function executeMany(geometries: GeometryUnion[], options?: Options): Polygon[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `false`.
+ */
+export const supportsCurves: boolean;

package/geometry/operators/multiPartToSinglePartOperator.d.ts

@@ -1,4 +1,34 @@
-import "../../interfaces";
+import type { GeometryUnion, GeometrySansMeshUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.multiPartToSinglePartOperator["supportsCurves"];
-export const executeMany: __esri.multiPartToSinglePartOperator["executeMany"];
+export interface Options {
+  /**
+   * When this parameter is set to false, the input polygons will not be simplified before converting them to single part geometries. Make sure the input polygons are topologically simple.
+   * Otherwise, the operation may assume incorrect ring orientation or order of rings.
+   *
+   * @default true
+   */
+  simplifyPolygons?: boolean;
+}
+
+/**
+ * Performs the multipart to single part operation on the input geometries.
+ * Single part geometries will not be affected (i.e. they just get passed along) with the exception of multipoints, which always become points.
+ * By default, polygons will be simplified before producing single parts.
+ *
+ * @param geometries - The input geometries to be converted to single part geometries.
+ * All the geometries must have the same spatial reference.
+ * @param options - Additional options.
+ * @returns Returns the single part geometries.
+ * For non-simple polygons, the output of the method is not guaranteed to be correct if the `simplifyPolgons` option is set to `false`.
+ * In that case, the method may either throw an error, or produce some output which is not guaranteed to be correct.
+ * @example
+ * // Convert multipart geometries to single part geometries
+ * const singlePartGeometries = multiPartToSinglePartOperator.executeMany(multiPartGeometries);
+ */
+export function executeMany(geometries: GeometryUnion[], options?: Options): GeometrySansMeshUnion[];
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;