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

package/geometry/support/meshUtils/interfaces.d.ts

@@ -0,0 +1,150 @@
+import type Point from "../../Point.js";
+import type { AbortOptions } from "../../../core/promiseUtils.js";
+import type { LengthUnit } from "../../../core/units.js";
+import type { MeshMaterialProperties } from "../MeshMaterial.js";
+
+export interface VertexSpaceParameters {
+  /** The unit of the size (defaults to the unit of the location's spatial reference). */
+  unit?: LengthUnit;
+  /**
+   * Specifies the vertex space of the created mesh. If not specified, a vertex space is
+   *   chosen according to the spatial reference where a [MeshLocalVertexSpace](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshLocalVertexSpace.html) is used for geographic
+   *   or WebMercator spatial references and [MeshGeoreferencedVertexSpace](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshGeoreferencedVertexSpace.html) is used otherwise.
+   *   If vertexSpace is "georeferenced", then the vertex space will be also [MeshGeoreferencedVertexSpace](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshGeoreferencedVertexSpace.html)
+   *   where mesh vertices are georeferenced offsets to the location provided with the create function. If the vertexSpace is "georeferenced" and the spatial reference is geographic, then vertex data will be first created in a "local" vertex space and then converted to the "georeferenced" vertex space. In case of vertex space being "local", mesh vertices
+   *   will be defined in a local cartesian coordinate frame placed at the location provided with the create function. This will be
+   *   represented by [MeshLocalVertexSpace](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshLocalVertexSpace.html)
+   */
+  vertexSpace?: "local" | "georeferenced";
+}
+
+export interface GeographicParameters {
+  /**
+   * Whether to georeference relative to the globe or the
+   *   projected coordinate system (PCS). This parameter is only relevant for spatial references that can
+   *   be used in both local and global viewing modes (currently only WebMercator), and otherwise ignored.
+   *   The default value is true. When true, the transformation is applied in a Cartesian system with respect to the local
+   *   coordinate system on the globe.
+   *
+   * @deprecated Since version 4.30. Use mesh `vertexSpace` and spatial reference to control how operations are performed instead.
+   */
+  geographic?: boolean;
+  /**
+   * Indicates the unit of the source data. A linear scale will be applied to the position attributes
+   *   to convert the source data to the unit of the spatial reference at which the mesh is being georeferenced. By default the unit
+   *   of the source data is assumed to be the same as the target spatial reference.
+   */
+  unit?: LengthUnit;
+}
+
+export interface MaterialParameters {
+  /** The material to be used for the mesh. */
+  material?: MeshMaterialProperties;
+}
+
+export interface CreateParameters extends VertexSpaceParameters, MaterialParameters {
+  /**
+   * A uniform size value or an object containing individual
+   *   values width, height and depth. The unit of the size values is derived from the spatial reference
+   *   of the provided location, unless a specific unit is specified. The default unit for a GCS is always meters.
+   */
+  size?: number | Size;
+}
+
+/** Parameters used to configure box mesh creation. */
+export interface CreateBoxParameters extends CreateParameters {
+  /**
+   * The face for generating image uv coordinates. By default, a single set of unwrapped
+   *   UV coordinates are generated for all the faces. By setting the `imageFace` parameter to one of `east`, `west`,
+   *   `north`, `south`, `up` or `down`, the specified face will have full sized UV coordinates while the other faces
+   *   will pertain their regular unwrapped UV coordinates. This is useful for applying an image only to a single face of the box.
+   *   The provided `material` parameter will be applied to the specified `imageFace`. The resulting mesh will have two components,
+   *   the first contains the selected image face and the second contains the other faces of the box.
+   */
+  imageFace?: Facing | "all";
+}
+
+/** Parameters used to configure sphere mesh creation. */
+export interface CreateSphereParameters extends CreateParameters {
+  /**
+   * The additional number of subdivisions for generating
+   *   the mesh representing a sphere. A densificationFactor parameter of 0 will generate a default of
+   *   16-by-16 vertices to approximate the sphere. A densificationFactor of 1 will generate 32-by-32 vertices, etc.
+   *   The larger the densificationFactor, the better the mesh will approximate a perfect sphere (at the cost of
+   *   processing and rendering performance).
+   */
+  densificationFactor?: number;
+}
+
+/** Parameters used to configure cylinder mesh creation. */
+export interface CreateCylinderParameters extends CreateParameters {
+  /**
+   * The additional number of subdivisions for generating
+   *   the mesh representing a sphere. A densificationFactor parameter of 0 will generate a default of
+   *   16-by-16 vertices to approximate the sphere. A densificationFactor of 1 will generate 32-by-32 vertices, etc.
+   *   The larger the densificationFactor, the better the mesh will approximate a perfect sphere (at the cost of
+   *   processing and rendering performance).
+   */
+  densificationFactor?: number;
+}
+
+/** Parameters used to configure plane mesh creation. */
+export interface CreatePlaneParameters extends VertexSpaceParameters, MaterialParameters {
+  /**
+   * Direction the plane is facing.
+   *
+   * @default "up"
+   */
+  facing?: Facing;
+  /**
+   * A uniform size value or an object containing individual
+   *   values width and height. The unit of the size values is derived from the spatial reference
+   *   of the provided location, unless a specific unit is specified. The default unit for a GCS is always meters.
+   */
+  size?: number | Size2D;
+}
+
+/** Parameters used to configure gltf mesh creation. */
+export interface CreateFromGLTFParameters extends VertexSpaceParameters, AbortOptions {}
+
+export interface RotateParameters extends GeographicParameters {
+  /**
+   * The origin around which to rotate. If not specified,
+   *   the mesh will be rotated around the {@link geometry/support/meshUtils/interfaces#origin Mesh.origin}.
+   */
+  origin?: Point;
+}
+
+export interface ScaleParameters extends GeographicParameters {
+  /**
+   * The origin point for scaling. If not specified, the mesh will
+   *   be scaled around the {@link geometry/support/meshUtils/interfaces#origin Mesh.origin}.
+   */
+  origin?: Point;
+}
+
+export interface CenterAtParameters extends GeographicParameters {
+  /**
+   * The origin at which to center. If not specified,
+   *   the mesh will be centered at the mesh extent center.
+   */
+  origin?: Point;
+}
+
+export interface Size {
+  /** The depth of the created mesh. */
+  depth?: number;
+  /** The height of the created mesh. */
+  height?: number;
+  /** The width of the created mesh. */
+  width?: number;
+}
+
+export interface Size2D {
+  /** The height of the created mesh. */
+  height?: number;
+  /** The width of the created mesh. */
+  width?: number;
+}
+
+export type Facing = "east" | "west" | "north" | "south" | "up" | "down";

package/geometry/support/meshUtils.d.ts

@@ -1,8 +1,144 @@
-import "../../interfaces";
-
-export const convertVertexSpace: __esri.meshUtils["convertVertexSpace"];
-export const createElevationSampler: __esri.meshUtils["createElevationSampler"];
-export const createFromElevation: __esri.meshUtils["createFromElevation"];
-export const georeference: __esri.meshUtils["georeference"];
-export const merge: __esri.meshUtils["merge"];
-export const ungeoreference: __esri.meshUtils["ungeoreference"];
+import type Ground from "../../Ground.js";
+import type Extent from "../Extent.js";
+import type Mesh from "../Mesh.js";
+import type Point from "../Point.js";
+import type ElevationLayer from "../../layers/ElevationLayer.js";
+import type ElevationSampler from "../../layers/support/ElevationSampler.js";
+import type { AbortOptions } from "../../core/promiseUtils.js";
+import type { MeshVertexSpace } from "./MeshVertexSpace.js";
+import type { CreateParams as ElevationCreateParams } from "./meshUtils/elevation.js";
+import type { CreateParameters as CreateElevationSamplerParameters } from "./meshUtils/elevationSampler.js";
+import type { VertexAttributes } from "./meshUtils/georeference.js";
+import type { GeographicParameters } from "./meshUtils/interfaces.js";
+
+/**
+ * Creates a mesh geometry by sampling elevation data from an elevation service on a regular grid.
+ *
+ * @param source - The source from which to query the elevation data.
+ * @param extent - The extent from which to create the mesh.
+ * @param options - Additional options.
+ * @returns A promise that resolves to a mesh geometry representing the elevation data at the specified extent.
+ * @example
+ * // Create a mesh by sampling the ground
+ * meshUtils.createFromElevation(map.ground, extent)
+ *     .then(function(mesh) {
+ *       // Do something with the mesh
+ *     });
+ *
+ * // Create a mesh by sampling the ground surface currently in view
+ * meshUtils.createFromElevation(view.groundView.elevationSampler, view.extent)
+ *     .then(function(mesh) {
+ *       // Do something with the mesh
+ *     });
+ */
+export function createFromElevation(source: ElevationLayer | Ground | ElevationSampler, extent: Extent, options?: ElevationCreateParams): Promise<Mesh>;
+
+/**
+ * Creates an elevation sampler from a mesh. The sampler can be used to query elevation values
+ * on the surface of the mesh. The elevation sampler uses a snapshot of the Mesh geometry and
+ * will not update if the mesh changes after the sampler has been created.
+ *
+ * @param mesh - The mesh geometry used to create the elevation sampler.
+ * @param options - Additional options.
+ * @returns An elevation sampler.
+ * @since 4.12
+ * @see [Sample - Low poly terrain using mesh geometry](https://developers.arcgis.com/javascript/latest/sample-code/geometry-mesh-elevation/)
+ */
+export function createElevationSampler(mesh: Mesh, options?: CreateElevationSamplerParameters): Promise<ElevationSampler>;
+
+/**
+ * Georeferences vertices specified in a Cartesian coordinate system. This is useful
+ * when converting general 3D model meshes not typically georeferenced. This method
+ * operates on mesh vertex attributes and will convert positions and normals (if specified)
+ * from a local (0, 0, 0) Cartesian system to the properly georeferenced coordinates at the
+ * specified `location`. The unit of the source data defaults to the unit of the `location`'s spatial reference.
+ * If the coordinate system is WGS84, metric units are used as the default. The unit of the source data may be
+ * specified in the additional `options` in which case a linear unit scale will automatically be applied to bring
+ * the source data in the unit of the spatial reference.
+ *
+ * @deprecated since version 4.30. Use [convertVertexSpace()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-meshUtils.html#convertVertexSpace) instead.
+ * @param vertexAttributes - The position and normal buffers to georeference.
+ * @param location - The location at which to georeference the position and normal buffers.
+ * @param options - Additional options.
+ * @returns The georeferenced position and normal buffers.
+ * @example
+ * const geoVertexAttributes = meshUtils.georeference(vertexAttributes, location);
+ * const mesh = new Mesh({
+ *   vertexAttributes: geoVertexAttributes,
+ *   spatialReference: location.spatialReference
+ * });
+ */
+export function georeference(vertexAttributes: VertexAttributes, location: Point, options?: GeographicParameters): VertexAttributes | null | undefined;
+
+/**
+ * Projects georeferenced vertices to a Cartesian coordinate system.
+ * This is useful for converting existing scene geometry so that it can be used
+ * as source material for generating new 3D meshes. This method
+ * operates on mesh vertex attributes and will convert positions and normals (if specified)
+ * from georeferenced coordinates at the specified `location` to a local (0, 0, 0) Cartesian system.
+ * The unit of the resulting data defaults to the unit of the `location`'s spatial reference.
+ * If the coordinate system is WGS84, metric units are used as the default. The unit of the resulting data may be
+ * specified in the additional `options` in which case a linear unit scale will automatically be applied.
+ *
+ * @deprecated since version 4.30. Use [convertVertexSpace()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-meshUtils.html#convertVertexSpace) instead.
+ * @param vertexAttributes - The georeferenced position and normal buffers.
+ * @param location - The location to which the position and normal buffers are georeferenced.
+ * @param options - Additional options.
+ * @returns The position and normal buffers in a local Cartesian coordinate system.
+ * @example const vertexAttributes = meshUtils.ungeoreference(geoVertexAttributes, location);
+ */
+export function ungeoreference(vertexAttributes: VertexAttributes, location: Point, options?: GeographicParameters): VertexAttributes | null | undefined;
+
+/**
+ * Merges multiple meshes into a single mesh. All mesh geometries
+ * must be in the same spatial reference.
+ *
+ * @param geometries - One or more meshes.
+ * @returns The merged mesh geometry.
+ * @example const mergedMesh = meshUtils.merge([mesh1, mesh2]);
+ */
+export function merge(geometries: Mesh[]): Mesh | null | undefined;
+
+/**
+ * Converts a mesh to a new vertex space. Any [transform](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshTransform.html) defined on
+ * the mesh will be applied to the vertex attributes as part of the conversion.
+ *
+ * @param mesh - the mesh geometry to convert.
+ * @param targetVertexSpace - the vertex space to convert to.
+ * @param options - Additional options.
+ * @returns The converted mesh.
+ * @since 4.30
+ * @example
+ * // convert cartesian model data to a mesh with absolute coordinates in WebMercator
+ * const converted = convertVertexSpace(
+ *   new Mesh({
+ *     vertexSpace: new MeshLocalVertexSpace({ origin: location }),
+ *     vertexAttributes,
+ *     spatialReference: SpatialReference.WebMercator
+ *   }),
+ *   new MeshGeoreferencedVertexSpace()
+ * );
+ * @example
+ * // convert a georeferenced WebMercator mesh to a mesh with a local tangent coordinate frame
+ * // at the center of the mesh
+ * const center = mesh.extent.center;
+ * const origin = [center.x, center.y, center.z];
+ * const converted = await convertVertexSpace(mesh, new MeshLocalVertexSpace({ origin }));
+ * @example
+ * // convert an existing mesh to absolute coordinates and place a graphic on the highest vertex
+ * const converted = await convertVertexSpace(mesh, new MeshGeoreferencedVertexSpace());
+ * const position = converted.vertexAttributes.position;
+ *
+ * const highestPoint = new Point({ x: 0, y: 0, z: 0, spatialReference: converted.spatialReference });
+ *
+ * for (let i = 0; i < position.length; i += 3) {
+ *   if (position[2] > highestPoint.z) {
+ *     highestPoint.x = position[0];
+ *     highestPoint.y = position[1];
+ *     highestPoint.z = position[2];
+ *   }
+ * }
+ *
+ * view.graphics.add(new Graphic({ geometry: highestPoint }));
+ */
+export function convertVertexSpace(mesh: Mesh, targetVertexSpace: MeshVertexSpace, options?: AbortOptions): Promise<Mesh>;

package/geometry/support/normalizeUtils.d.ts

@@ -1,4 +1,67 @@
-import "../../interfaces";
+import type Extent from "../Extent.js";
+import type Mesh from "../Mesh.js";
+import type Multipoint from "../Multipoint.js";
+import type Point from "../Point.js";
+import type Polygon from "../Polygon.js";
+import type Polyline from "../Polyline.js";
+import type { RequestOptions } from "../../request/interfaces.js";
 
-export const getDenormalizedExtent: __esri.normalizeUtils["getDenormalizedExtent"];
-export const normalizeCentralMeridian: __esri.normalizeUtils["normalizeCentralMeridian"];
+export type Geometry = Extent | Multipoint | Point | Polygon | Polyline | Mesh;
+
+/**
+ * Normalizes geometries that intersect the central meridian or fall outside the
+ * world extent so they stay within the coordinate system of the view. Only supported
+ * for Web Mercator and WGS84 spatial references.
+ *
+ * @param geometries - An array of geometries to normalize.
+ * @param url - A geometry service URL used to
+ * perform the normalization. If this value is `null` then the default geometry service URL in
+ * [esriConfig.geometryServiceUrl](https://developers.arcgis.com/javascript/latest/api-reference/esri-config.html#ConfigWithGeometryServiceUrl) is used.
+ * @param requestOptions - Additional [options](https://developers.arcgis.com/javascript/latest/api-reference/esri-request.html#request) to be used for the data request.
+ * @returns Resolves to an array of the normalized geometries.
+ * @example
+ * // create a non-normalized line that crosses the dateline
+ * const polyline = new Polyline({
+ *   paths: [
+ *     [170, 52.68],
+ *     [190, 49.5]
+ *   ]
+ * });
+ *
+ * normalizeUtils.normalizeCentralMeridian([polyline])
+ *   .then(function(polylines){
+ *     // returns a line representing the same geometry, but
+ *     // now is normalized between -180 and 180 on the x-coordinate.
+ *     // but represents the same feature
+ *     const graphic = new Graphic({
+ *       geometry: polylines[0],
+ *       symbol: { type: "simple-line" }
+ *     });
+ */
+export function normalizeCentralMeridian(geometries: (Geometry | null | undefined) | (Geometry | null | undefined)[], url?: string | null, requestOptions?: RequestOptions): Promise<(Geometry | null | undefined)[]>;
+
+/**
+ * Returns an [Extent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Extent.html) over the dateline that is smaller than the normalized width if it visually contains the
+ * geometry. The input geometry must be normalized and its [Geometry#spatialReference](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Geometry.html#spatialReference) must be Web Mercator or WGS84.
+ *
+ * @param geometry - The geometry used to create the denormalized extent. The geometry should be
+ * a [Polygon](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html), [Polyline](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polyline.html), or a
+ * [Multipoint](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Multipoint.html) geometry.
+ * This method returns `null` if a [Point](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Point.html) or a [Multipoint](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Multipoint.html)
+ * with only one point is used as the input geometry.
+ * It returns a cloned extent if an [Extent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Extent.html) is used as the input geometry.
+ * @returns The denormalized extent. The new extent is either the same as the normal extent of the geometry
+ * or a smaller extent.
+ * @since 4.21
+ * @example
+ * // create an extent that goes over the dateline
+ * // as the points are cross the dateline
+ * const multipoint = new Multipoint({
+ *   points: [
+ *     [158.6082458495678, 59.91028747107214],
+ *     [-145.98220825200923, 60.23981116998903]
+ *   ]
+ * });
+ * const extent = normalizeUtils.getDenormalizedExtent(multipoint);
+ */
+export function getDenormalizedExtent(geometry: Polygon | Polyline | Multipoint | Extent | null | undefined): Extent | null | undefined;

package/geometry/support/typeUtils.d.ts

@@ -0,0 +1,14 @@
+import type Extent from "../Extent.js";
+import type Mesh from "../Mesh.js";
+import type Multipoint from "../Multipoint.js";
+import type Point from "../Point.js";
+import type Polygon from "../Polygon.js";
+import type Polyline from "../Polyline.js";
+
+export type FeatureGeometryType = "point" | "multipoint" | "polyline" | "polygon";
+
+export type GeometryType = "point" | "multipoint" | "polyline" | "polygon" | "extent" | "mesh";
+
+export type GeometryUnion = Extent | Multipoint | Point | Polygon | Polyline | Mesh;
+
+export type GeometrySansMeshUnion = Extent | Multipoint | Point | Polygon | Polyline;

package/geometry/support/webMercatorUtils.d.ts

@@ -1,8 +1,75 @@
-import "../../interfaces";
-
-export const canProject: __esri.webMercatorUtils["canProject"];
-export const geographicToWebMercator: __esri.webMercatorUtils["geographicToWebMercator"];
-export const lngLatToXY: __esri.webMercatorUtils["lngLatToXY"];
-export const project: __esri.webMercatorUtils["project"];
-export const webMercatorToGeographic: __esri.webMercatorUtils["webMercatorToGeographic"];
-export const xyToLngLat: __esri.webMercatorUtils["xyToLngLat"];
+import type SpatialReference from "../SpatialReference.js";
+import type { GeometryUnion } from "./typeUtils.js";
+
+/**
+ * Returns `true` if the `source` spatial reference can be projected to the `target` spatial reference with the [project()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-webMercatorUtils.html#project) function, or
+ * if the `source` and `target` are the same [SpatialReference](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-SpatialReference.html).
+ *
+ * @param source - The input [SpatialReference](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-SpatialReference.html) or an object with
+ *                                                                  `spatialReference` property such as [Geometry](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Geometry.html)
+ *                                                                  or [Map](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html).
+ * @param target - The target [SpatialReference](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-SpatialReference.html) or an object with
+ *                                                                  `spatialReference` property such as [Geometry](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Geometry.html)
+ *                                                                  or [Map](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html).
+ * @returns Returns `true` if `source` can be projected to `target`.
+ * @see [project()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-webMercatorUtils.html#project)
+ */
+export function canProject(source: object | SpatialReference | null | undefined, target: object | SpatialReference | null | undefined): boolean;
+
+/**
+ * Projects the geometry clientside (if possible). You should test the input geometry in [canProject()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-webMercatorUtils.html#canProject) prior to using this function.
+ * If the result of [canProject()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-webMercatorUtils.html#canProject) is `true`, then proceed to project. If [canProject()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-webMercatorUtils.html#canProject) returns `false`, then
+ * `project()` won't return useful results. Use [project()](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-geometryService.html#project) instead.
+ *
+ * @param geometry - The input geometry.
+ * @param spatialReference - The target [SpatialReference](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-SpatialReference.html) or an object with
+ *                                                                  `spatialReference` property such as [Geometry](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Geometry.html)
+ *                                                                  or [Map](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html).
+ * @returns Returns the projected geometry if the projection is successful.
+ * @see [project()](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-geometryService.html#project)
+ * @see [ProjectParameters](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-ProjectParameters.html)
+ */
+export function project(geometry: GeometryUnion | null | undefined, spatialReference: SpatialReference | null | undefined): GeometryUnion | null | undefined;
+
+/**
+ * Translates the given latitude and longitude (decimal degree) values to Web Mercator XY values.
+ *
+ * @param long - The longitude value to convert.
+ * @param lat - The latitude value to convert.
+ * @returns Returns the converted values in an array.
+ */
+export function lngLatToXY(long: number, lat: number): [
+    number,
+    number
+];
+
+/**
+ * Translates the given Web Mercator coordinates to Longitude and Latitude values (decimal degrees).
+ * By default the returned longitude is normalized so that it is within -180 and +180.
+ *
+ * @param x - The X coordinate value to convert.
+ * @param y - The Y coordinate value to convert.
+ * @returns Returns the converted values in an array.
+ */
+export function xyToLngLat(x: number, y: number): [
+    number,
+    number
+];
+
+/**
+ * Converts a geometry from geographic units (wkid: 4326) to Web Mercator units (wkid: 3857).
+ *
+ * @param geometry - The input geometry to convert.
+ * @returns Returns the converted geometry in Web Mercator units.
+ */
+export function geographicToWebMercator(geometry: GeometryUnion): GeometryUnion;
+
+/**
+ * Converts a geometry from Web Mercator units (wkid: 3857) to geographic units (wkid: 4326).
+ *
+ * @param geometry - The input geometry to convert.
+ * @param isLinear - = false - Indicates whether to work with linear values, i.e., do not normalize. By default, this conversion method normalizes xmin and xmax values.
+ * If this is not desired, specify this value as `true`. Default value is `false`.
+ * @returns Returns the converted geometry in geographic units.
+ */
+export function webMercatorToGeographic(geometry: GeometryUnion, isLinear?: boolean): GeometryUnion;

package/geometry.d.ts

@@ -1,15 +1,98 @@
-import "./interfaces";
-
-export type SpatialReference = __esri.geometry.SpatialReference;
-export const SpatialReference: typeof __esri.geometry.SpatialReference;
-export type Geometry = __esri.geometry.Geometry;
-export type Extent = __esri.geometry.Extent;
-export const Extent: typeof __esri.geometry.Extent;
-export type Multipoint = __esri.geometry.Multipoint;
-export const Multipoint: typeof __esri.geometry.Multipoint;
-export type Point = __esri.geometry.Point;
-export const Point: typeof __esri.geometry.Point;
-export type Polygon = __esri.geometry.Polygon;
-export const Polygon: typeof __esri.geometry.Polygon;
-export type Polyline = __esri.geometry.Polyline;
-export const Polyline: typeof __esri.geometry.Polyline;
+import type ExtentClass from "./geometry/Extent.js";
+import type MultipointClass from "./geometry/Multipoint.js";
+import type PointClass from "./geometry/Point.js";
+import type PolygonClass from "./geometry/Polygon.js";
+import type PolylineClass from "./geometry/Polyline.js";
+import type SpatialReferenceClass from "./geometry/SpatialReference.js";
+import type { GeometryUnion } from "./geometry/support/typeUtils.js";
+
+/**
+ * Spatial Reference.
+ *
+ * @deprecated since version 4.32. Import [SpatialReference](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-SpatialReference.html) directly instead.
+ */
+export const SpatialReference: typeof SpatialReferenceClass;
+
+/**
+ * Spatial Reference.
+ *
+ * @deprecated since version 4.32. Import [SpatialReference](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-SpatialReference.html) directly instead.
+ */
+export type SpatialReference = SpatialReferenceClass;
+
+/**
+ * Geometry types.
+ *
+ * @deprecated since version 4.32. Use [GeometryUnion](https://developers.arcgis.com/javascript/latest/api-reference/esri-unionTypes.html#GeometryUnion) instead.
+ */
+export type Geometry = GeometryUnion;
+
+/**
+ * Extent.
+ *
+ * @deprecated since version 4.32. Import [Extent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Extent.html) directly instead.
+ */
+export const Extent: typeof ExtentClass;
+
+/**
+ * Extent.
+ *
+ * @deprecated since version 4.32. Import [Extent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Extent.html) directly instead.
+ */
+export type Extent = ExtentClass;
+
+/**
+ * Multipoint.
+ *
+ * @deprecated since version 4.32. Import [Multipoint](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Multipoint.html) directly instead.
+ */
+export const Multipoint: typeof MultipointClass;
+
+/**
+ * Multipoint.
+ *
+ * @deprecated since version 4.32. Import [Multipoint](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Multipoint.html) directly instead.
+ */
+export type Multipoint = MultipointClass;
+
+/**
+ * Point.
+ *
+ * @deprecated since version 4.32. Import [Point](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Point.html) directly instead.
+ */
+export const Point: typeof PointClass;
+
+/**
+ * Point.
+ *
+ * @deprecated since version 4.32. Import [Point](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Point.html) directly instead.
+ */
+export type Point = PointClass;
+
+/**
+ * Polygon.
+ *
+ * @deprecated since version 4.32. Import [Polygon](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html) directly instead.
+ */
+export const Polygon: typeof PolygonClass;
+
+/**
+ * Polygon.
+ *
+ * @deprecated since version 4.32. Import [Polygon](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html) directly instead.
+ */
+export type Polygon = PolygonClass;
+
+/**
+ * Polyline.
+ *
+ * @deprecated since version 4.32. Import [Polyline](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polyline.html) directly instead.
+ */
+export const Polyline: typeof PolylineClass;
+
+/**
+ * Polyline.
+ *
+ * @deprecated since version 4.32. Import [Polyline](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polyline.html) directly instead.
+ */
+export type Polyline = PolylineClass;

package/geometry.js

@@ -2,4 +2,4 @@
 All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
 */
-import{deprecatedModule as e}from"./core/deprecate.js";import o from"./core/Logger.js";import r from"./geometry/Extent.js";import t from"./geometry/Multipoint.js";import m from"./geometry/Point.js";import i from"./geometry/Polygon.js";import g from"./geometry/Polyline.js";import n from"./geometry/SpatialReference.js";const p=n,s=r,y=t,f=m,c=i,j=g;function l(){}e(o.getLogger("esri.geometry"),"esri.geometry",{replacement:"Individual geometry module imports",version:"4.32",warnOnce:!0});export{s as Extent,y as Multipoint,f as Point,c as Polygon,j as Polyline,p as SpatialReference,l as __exported__};
+import{deprecatedModule as e}from"./core/deprecate.js";import o from"./core/Logger.js";import r from"./geometry/Extent.js";import t from"./geometry/Multipoint.js";import m from"./geometry/Point.js";import i from"./geometry/Polygon.js";import g from"./geometry/Polyline.js";import p from"./geometry/SpatialReference.js";const s=p,n=r,y=t,f=m,j=i,l=g;e(o.getLogger("esri.geometry"),"esri.geometry",{replacement:"Individual geometry module imports",version:"4.32",warnOnce:!0});export{n as Extent,y as Multipoint,f as Point,j as Polygon,l as Polyline,s as SpatialReference};

package/graphic/GraphicOrigin.d.ts

@@ -1,4 +1,16 @@
-import "../interfaces";
 
-import GraphicOrigin = __esri.GraphicOrigin;
-export default GraphicOrigin;
+/**
+ * The base class for graphic origins. This class has no constructor.
+ * Provides contextual information about where a graphic originates from, when available.
+ * Origin details may be returned by methods such as [MapView#hitTest()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#hitTest) or `queryFeatures()`.
+ * This information can include the source layer or other origin-related metadata, depending on the origin type.
+ *
+ * @since 4.34
+ * @see [MapView#hitTest()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#hitTest)
+ * @see [SceneView#hitTest()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html#hitTest)
+ * @see [Map component hitTest()](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-map/#hitTest)
+ * @see [Scene component hitTest()](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/#hitTest)
+ * @see [FeatureLayer#queryFeatures()](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html#queryFeatures)
+ * @see [FeatureLayerView#queryFeatures()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-FeatureLayerView.html#queryFeatures)
+ */
+export default abstract class GraphicOrigin {}