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

package/geometry/operators/withinOperator.d.ts

@@ -1,5 +1,27 @@
-import "../../interfaces";
+import type { GeometryUnion } from "../support/typeUtils.js";
 
-export const supportsCurves: __esri.withinOperator["supportsCurves"];
-export const accelerateGeometry: __esri.withinOperator["accelerateGeometry"];
-export const execute: __esri.withinOperator["execute"];
+/**
+ * Accelerate a geometry. This method prepares the geometry for faster within 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 within operation on two geometries.
+ *
+ * @param inner - The base geometry that is tested for the "within" relationship with `outer`.
+ * @param outer - The comparison geometry that is tested for the "contains" relationship with `inner`.
+ * @returns Returns `true` if `inner` is within `outer`.
+ * @example
+ * Returns true if a geometry is completely within another
+ * const isWithin = withinOperator.execute(polygon1, polygon2);
+ */
+export function execute(inner: GeometryUnion, outer: GeometryUnion): boolean;
+
+/**
+ * Indicates if the operator supports input geometries that contain curves.
+ * The value will always be `true`.
+ */
+export const supportsCurves: boolean;

package/geometry/support/MeshComponent.d.ts

@@ -1,4 +1,135 @@
-import "../../interfaces";
+import type MeshMaterial from "./MeshMaterial.js";
+import type MeshMaterialMetallicRoughness from "./MeshMaterialMetallicRoughness.js";
+import type { ClonableMixin, ClonableMixinProperties } from "../../core/Clonable.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
+import type { MeshMaterialProperties } from "./MeshMaterial.js";
+import type { MeshMaterialMetallicRoughnessProperties } from "./MeshMaterialMetallicRoughness.js";
 
-import MeshComponent = __esri.MeshComponent;
-export default MeshComponent;
+export interface MeshComponentProperties extends JSONSupportMixinProperties, ClonableMixinProperties, Partial<Pick<MeshComponent, "faces" | "name" | "shading">> {
+  /** The material determines how the component is visualized. */
+  material?: MeshMaterialProperties | MeshMaterialMetallicRoughnessProperties | null;
+}
+
+/**
+ * The MeshComponent class is used to apply one or more materials to
+ * a single [Mesh](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html). The [faces](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html#faces) property
+ * is a flat array of indices in the mesh
+ * [Mesh#vertexAttributes](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#vertexAttributes) and defines the region
+ * of vertices in the mesh on which to apply the material.
+ * Each triple of values in the flat array of indices specifies a triangle to be rendered.
+ *
+ * To define the material for the whole mesh, [faces](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html#faces) may be set to `null`,
+ * which indicates that all the vertices defined for the mesh should be rendered
+ * as consecutive triangles.
+ *
+ * A mesh component defines a [material](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html#material) that determines how the region
+ * of triangles is colored. This mesh color can either be a single value or
+ * an image that is mapped to the vertices by means of the uv coordinates specified
+ * in the mesh [Mesh#vertexAttributes](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#vertexAttributes).
+ * The [shading](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html#shading) specifies the type of normals that are used to calculate how
+ * lighting affects mesh coloring.
+ *
+ * Mesh components can be added to the [Mesh.components[]](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#components)
+ * array.
+ *
+ * ```js
+ * let component1 = new MeshComponent({
+ *   // Indices refer to vertices specified in the mesh vertexAttributes.
+ *   // Here we refer to 2 triangles composed of the first 6 vertices of the mesh.
+ *   faces: [0, 1, 2, 3, 4, 5],
+ *
+ *   material: {
+ *     color: "green"
+ *   }
+ * });
+ *
+ * let component2 = new MeshComponent({
+ *   faces: [6, 7, 8, 9, 10, 11],
+ *
+ *   material: {
+ *     color: "red"
+ *   },
+ *
+ *   shading: "smooth"
+ * });
+ *
+ * let mesh = new Mesh({
+ *   // ... specify vertex attributes
+ *
+ *   components: [component1, component2]
+ * });
+ * ```
+ *
+ * @since 4.7
+ * @see [Mesh](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html)
+ */
+export default class MeshComponent extends MeshComponentSuperclass {
+  constructor(properties?: MeshComponentProperties);
+  /**
+   * A flat array of indices that refer to vertices in the
+   * [Mesh#vertexAttributes](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#vertexAttributes) of the
+   * mesh to which the component belongs. Each triple of indices defines a triangle
+   * to render (i.e. the faces array must always have a length that is a multiple of 3).
+   * Note that the indices refer to **vertices** and not to the index of the first coordinate
+   * of a vertex in the [vertexAttributes.position](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#vertexAttributes)
+   * array.
+   *
+   * If faces is `null`, then all the vertices in the mesh will be rendered
+   * as triangles for this component.
+   *
+   * @example
+   * let mesh = new Mesh({
+   *   vertexAttributes: {
+   *     position: [
+   *       2.336006, 48.860818, 0
+   *       2.336172, 48.861114, 0
+   *       2.335724, 48.861229, 0
+   *       2.335563, 48.860922, 0
+   *     ]
+   *   },
+   *   // Create two components so we can have separate materials
+   *   // for the two triangles that we want to render.
+   *   components: [
+   *     {
+   *       faces: [0, 1, 2],
+   *       material: {
+   *         color: "red"
+   *       }
+   *     },
+   *     {
+   *       faces: [0, 2, 3],
+   *       material: {
+   *         color: "green"
+   *       }
+   *     }
+   *   ]
+   * });
+   */
+  accessor faces: Uint32Array<ArrayBuffer> | null | undefined;
+  /** The material determines how the component is visualized. */
+  get material(): MeshMaterial | MeshMaterialMetallicRoughness | null | undefined;
+  set material(value: MeshMaterialProperties | MeshMaterialMetallicRoughnessProperties | null | undefined);
+  /**
+   * Specifies a name of the component. The component name can be used to identify the component. Meshes created from
+   * glTF will have components with names that correspond to mesh names from the glTF.
+   *
+   * @see [Mesh#createFromGLTF()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#createFromGLTF)
+   */
+  accessor name: string | null | undefined;
+  /**
+   * Specifies the type of normals used for lighting. This determines whether the object
+   * has a smooth or an angular appearance. The following shading types are supported:
+   *
+   * | Type | Description |
+   * |------|-------------|
+   * | source | Shading uses the normals as defined in the vertex attributes. If no normals are defined, then shading defaults back to `flat` |
+   * | flat | Shading uses normals created per triangle face. This type of shading is good for objects with sharp edges such as boxes. |
+   * | smooth | Shading uses per-vertex normals that average the normals of all the faces a vertex is a part of. This type of shading is good for meshes that approximate curved surfaces such as spheres. |
+   *
+   * @default "source"
+   */
+  accessor shading: MeshComponentShading;
+}
+declare const MeshComponentSuperclass: typeof JSONSupport & typeof ClonableMixin
+
+export type MeshComponentShading = "source" | "flat" | "smooth";

package/geometry/support/MeshGeoreferencedVertexSpace.d.ts

@@ -1,4 +1,37 @@
-import "../../interfaces";
+import type { ClonableMixin, ClonableMixinProperties } from "../../core/Clonable.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
 
-import MeshGeoreferencedVertexSpace = __esri.MeshGeoreferencedVertexSpace;
-export default MeshGeoreferencedVertexSpace;
+export interface MeshGeoreferencedVertexSpaceProperties extends JSONSupportMixinProperties, ClonableMixinProperties, Partial<Pick<MeshGeoreferencedVertexSpace, "origin">> {}
+
+/**
+ * A mesh vertex space indicating that mesh vertices are either absolute georeferenced map coordinates or relative
+ * offsets in map space to a fully georeferenced
+ * origin. The map space is identified by the [spatial reference](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#spatialReference) of
+ * the mesh.
+ *
+ * The vertex space of a mesh allows users to specify how the coordinates of the mesh vertices are interpreted. Use the
+ * georeferenced vertex space if the coordinates are already in the spatial reference of the mesh. The coordinates can
+ * be relative to the [origin](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshGeoreferencedVertexSpace.html#origin) or absolute
+ * coordinates if the origin is not defined.
+ *
+ * See [mesh API](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#mesh-api) for more details.
+ *
+ * @since 4.27
+ * @see [Mesh](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html)
+ */
+export default class MeshGeoreferencedVertexSpace extends MeshGeoreferencedVertexSpaceSuperclass {
+  constructor(properties?: MeshGeoreferencedVertexSpaceProperties);
+  /**
+   * Origin of the vertex space. This will be interpreted as coordinates in the SpatialReference of the Mesh using the vertex space.
+   * If this is null, the coordinates are expected to be absolute. If not, then the coordinates are expected to be deltas relative
+   * to the origin.
+   */
+  accessor origin: readonly [
+      number,
+      number,
+      number
+  ] | null | undefined;
+  /** Type of the vertex space. */
+  readonly type: "georeferenced";
+}
+declare const MeshGeoreferencedVertexSpaceSuperclass: typeof JSONSupport & typeof ClonableMixin

package/geometry/support/MeshLocalVertexSpace.d.ts

@@ -1,4 +1,29 @@
-import "../../interfaces";
+import type { ClonableMixin, ClonableMixinProperties } from "../../core/Clonable.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
 
-import MeshLocalVertexSpace = __esri.MeshLocalVertexSpace;
-export default MeshLocalVertexSpace;
+export interface MeshLocalVertexSpaceProperties extends JSONSupportMixinProperties, ClonableMixinProperties, Partial<Pick<MeshLocalVertexSpace, "origin">> {}
+
+/**
+ * A mesh vertex space that indicates mesh vertices to be in a plain cartesian space as often encountered in 3D
+ * modeling and CAD applications. Georeferencing is done by using the coordinates in the
+ * [local tangent plane](https://en.wikipedia.org/wiki/Local_tangent_plane_coordinates)
+ * reference frame at the fully georeferenced [origin](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshLocalVertexSpace.html#origin)
+ * of the vertex space.
+ *
+ * See [mesh API](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#mesh-api) for details.
+ *
+ * @since 4.27
+ * @see [Mesh](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html)
+ */
+export default class MeshLocalVertexSpace extends MeshLocalVertexSpaceSuperclass {
+  constructor(properties?: MeshLocalVertexSpaceProperties);
+  /** Origin of the vertex space. This will be interpreted as coordinates in the SpatialReference of the Mesh using the vertex space. */
+  accessor origin: readonly [
+      number,
+      number,
+      number
+  ];
+  /** Type of the vertex space. */
+  readonly type: "local";
+}
+declare const MeshLocalVertexSpaceSuperclass: typeof JSONSupport & typeof ClonableMixin

package/geometry/support/MeshMaterial.d.ts

@@ -1,4 +1,198 @@
-import "../../interfaces";
+import type Color from "../../Color.js";
+import type MeshTexture from "./MeshTexture.js";
+import type MeshTextureTransform from "./MeshTextureTransform.js";
+import type { ClonableMixin, ClonableMixinProperties } from "../../core/Clonable.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
+import type { MeshTextureData } from "./interfaces.js";
+import type { ColorLike } from "../../Color.js";
+import type { MeshTextureProperties } from "./MeshTexture.js";
+import type { MeshTextureTransformProperties } from "./MeshTextureTransform.js";
 
-import MeshMaterial = __esri.MeshMaterial;
-export default MeshMaterial;
+export interface MeshMaterialProperties extends JSONSupportMixinProperties, ClonableMixinProperties, Partial<Pick<MeshMaterial, "alphaCutoff" | "alphaMode" | "doubleSided">> {
+  /**
+   * Specifies a single, uniform color for the mesh component. This can be autocast with
+   * a named string, hex string, array of rgb or rgba values, an object with `r`, `g`, `b`, and `a`
+   * properties, or a [Color](https://developers.arcgis.com/javascript/latest/api-reference/esri-Color.html) object.
+   */
+  color?: ColorLike | null;
+  /**
+   * Specifies a texture from which to get color information.
+   * The texture is accessed using the uv coordinate specified for each vertex
+   * in the [Mesh#vertexAttributes](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#vertexAttributes).
+   */
+  colorTexture?: MeshTextureProperties | string | MeshTextureData | null;
+  /**
+   * A transformation of UV mesh coordinates used to sample the color texture. Texture transformations
+   * can be used to optimize re-use of textures, for example by packing many images into a single
+   * texture "atlas" and using the texture transform offset and scale to sample a specific region
+   * within this larger texture.
+   *
+   * @since 4.27
+   */
+  colorTextureTransform?: MeshTextureTransformProperties | null;
+  /**
+   * Specifies a texture from which to get normal information.
+   * The texture is accessed using the uv coordinate specified for each vertex
+   * in the [Mesh#vertexAttributes](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#vertexAttributes).
+   */
+  normalTexture?: MeshTextureProperties | string | MeshTextureData | null;
+  /**
+   * A transformation of UV mesh coordinates used to sample the normal texture. Texture transformations
+   * can be used to optimize re-use of textures, for example by packing many images into a single
+   * texture "atlas" and using the texture transform offset and scale to sample a specific region
+   * within this larger texture.
+   *
+   * @since 4.27
+   */
+  normalTextureTransform?: MeshTextureTransformProperties | null;
+}
+
+/**
+ * The material determines how a [MeshComponent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html) is visualized.
+ * One of the major characteristics of a material is its [color](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterial.html#color). The [color](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterial.html#color) property
+ * can be used to set a uniform color for the whole [MeshComponent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html).
+ * Use the [colorTexture](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterial.html#colorTexture) property to map an image onto the mesh component, using the uv
+ * coordinate specified for each vertex in the [Mesh#vertexAttributes](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#vertexAttributes).
+ *
+ * The material properties support a number of convenience autocast types, including
+ * hex color strings and well known color strings (autocasts to
+ * [Color](https://developers.arcgis.com/javascript/latest/api-reference/esri-Color.html)), or strings representing urls to images,
+ * [HTMLImageElements](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement),
+ * [HTMLCanvasElements](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement),
+ * [HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement),
+ * or [ImageData](https://developer.mozilla.org/en-US/docs/Web/API/ImageData)
+ * (autocasts to [MeshTexture](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshTexture.html)).
+ *
+ * ```js
+ *
+ * // create a material that uses a color
+ *
+ * const meshWithColor = new MeshComponent({
+ *   // autocasts to MeshMaterial
+ *   material: {
+ *     color: "#ff00ff"
+ *   }
+ * });
+ *
+ * // create a material that uses a texture by linking to
+ * // an image url
+ *
+ * const meshTextureByUrl = new MeshTexture({
+ *   url: "./image.png"
+ * });
+ *
+ * const boxMesh = Mesh.createBox(location, {
+ *   material: {
+ *     colorTexture: meshTextureByUrl
+ *   }
+ * });
+ *
+ * // create a material that uses a texture from
+ * // a canvas element
+ *
+ * function createLinearGradient() {
+ *   const canvas = document.createElement("canvas");
+ *   canvas.width = 32;
+ *   canvas.height = 32;
+ *
+ *   const ctx = canvas.getContext("2d");
+ *
+ *   // Create the linear gradient with which to fill the canvas
+ *   const gradient = ctx.createLinearGradient(0, 0, 0, 32);
+ *   gradient.addColorStop(0, "#00ff00");
+ *   gradient.addColorStop(1, "#009900");
+ *
+ *   // Fill the canvas with the gradient pattern
+ *   ctx.fillStyle = gradient;
+ *   ctx.fillRect(0, 0, 32, 32);
+ *
+ *   return canvas;
+ * }
+ *
+ * const component = new MeshComponent({
+ *   material: {
+ *     // Autocast canvas element to MeshTexture instance
+ *     colorTexture: createLinearGradient()
+ *   }
+ * });
+ * ```
+ *
+ * @since 4.11
+ * @see [MeshComponent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html)
+ * @see [Sample - Working with 3d mesh primitives](https://developers.arcgis.com/javascript/latest/sample-code/geometry-mesh-primitives/)
+ * @see [Sample - Low poly terrain using mesh geometry](https://developers.arcgis.com/javascript/latest/sample-code/geometry-mesh-elevation/)
+ */
+export default class MeshMaterial extends MeshMaterialSuperclass {
+  constructor(properties?: MeshMaterialProperties);
+  /**
+   * Specifies how transparency on the object is handled.
+   * If [alphaMode](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterial.html#alphaMode) is set to either `mask` or `auto` this property specifies the cutoff value below which
+   * masking happens (that is, the corresponding part of the Mesh is rendered fully transparent).
+   *
+   * @default 0.5
+   */
+  accessor alphaCutoff: number;
+  /**
+   * Specifies how transparency on the object is handled. See also [alphaCutoff](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterial.html#alphaCutoff).
+   *
+   * | Type | Description |
+   * |------|-------------|
+   * | opaque | Alpha is ignored, and the object is rendered fully opaque. |
+   * | blend | Alpha values are used for gradual transparency, blending between the object and its background. |
+   * | mask | Alpha values are used for binary transparency, either displaying the object, or its background. See also [alphaCutoff](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterial.html#alphaCutoff). |
+   * | auto | The implementation mixes the `mask` and `blend` settings, masking below `alphaCutoff` and blending above it. |
+   *
+   * @default "auto"
+   */
+  accessor alphaMode: MeshMaterialAlphaMode;
+  /**
+   * Specifies a single, uniform color for the mesh component. This can be autocast with
+   * a named string, hex string, array of rgb or rgba values, an object with `r`, `g`, `b`, and `a`
+   * properties, or a [Color](https://developers.arcgis.com/javascript/latest/api-reference/esri-Color.html) object.
+   */
+  get color(): Color | null | undefined;
+  set color(value: ColorLike | null | undefined);
+  /**
+   * Specifies a texture from which to get color information.
+   * The texture is accessed using the uv coordinate specified for each vertex
+   * in the [Mesh#vertexAttributes](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#vertexAttributes).
+   */
+  get colorTexture(): MeshTexture | null | undefined;
+  set colorTexture(value: MeshTextureProperties | string | MeshTextureData | null | undefined);
+  /**
+   * A transformation of UV mesh coordinates used to sample the color texture. Texture transformations
+   * can be used to optimize re-use of textures, for example by packing many images into a single
+   * texture "atlas" and using the texture transform offset and scale to sample a specific region
+   * within this larger texture.
+   *
+   * @since 4.27
+   */
+  get colorTextureTransform(): MeshTextureTransform | null | undefined;
+  set colorTextureTransform(value: MeshTextureTransformProperties | null | undefined);
+  /**
+   * Specifies whether both sides of each triangle are displayed, or only the front sides.
+   *
+   * @default true
+   */
+  accessor doubleSided: boolean;
+  /**
+   * Specifies a texture from which to get normal information.
+   * The texture is accessed using the uv coordinate specified for each vertex
+   * in the [Mesh#vertexAttributes](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Mesh.html#vertexAttributes).
+   */
+  get normalTexture(): MeshTexture | null | undefined;
+  set normalTexture(value: MeshTextureProperties | string | MeshTextureData | null | undefined);
+  /**
+   * A transformation of UV mesh coordinates used to sample the normal texture. Texture transformations
+   * can be used to optimize re-use of textures, for example by packing many images into a single
+   * texture "atlas" and using the texture transform offset and scale to sample a specific region
+   * within this larger texture.
+   *
+   * @since 4.27
+   */
+  get normalTextureTransform(): MeshTextureTransform | null | undefined;
+  set normalTextureTransform(value: MeshTextureTransformProperties | null | undefined);
+}
+declare const MeshMaterialSuperclass: typeof JSONSupport & typeof ClonableMixin
+
+export type MeshMaterialAlphaMode = "opaque" | "blend" | "mask" | "auto";

package/geometry/support/MeshMaterialMetallicRoughness.d.ts

@@ -1,4 +1,150 @@
-import "../../interfaces";
+import type Color from "../../Color.js";
+import type MeshMaterial from "./MeshMaterial.js";
+import type MeshTexture from "./MeshTexture.js";
+import type MeshTextureTransform from "./MeshTextureTransform.js";
+import type { MeshTextureData } from "./interfaces.js";
+import type { MeshMaterialProperties } from "./MeshMaterial.js";
+import type { ColorLike } from "../../Color.js";
+import type { MeshTextureProperties } from "./MeshTexture.js";
+import type { MeshTextureTransformProperties } from "./MeshTextureTransform.js";
 
-import MeshMaterialMetallicRoughness = __esri.MeshMaterialMetallicRoughness;
-export default MeshMaterialMetallicRoughness;
+export interface MeshMaterialMetallicRoughnessProperties extends MeshMaterialProperties, Partial<Pick<MeshMaterialMetallicRoughness, "emissiveStrength" | "metallic" | "roughness">> {
+  /**
+   * Specifies a single, uniform emissive color for the [MeshComponent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html).
+   * The emissiveColor is added to the base color of the component.
+   * This can be autocast with a named string, hex string, array of rgb values, an object with `r`, `g`, `b`
+   * properties, or a [Color](https://developers.arcgis.com/javascript/latest/api-reference/esri-Color.html) object. Note that the alpha channel is ignored for emissive colors.
+   */
+  emissiveColor?: ColorLike | null;
+  /**
+   * Specifies a texture from which to get emissive color information. The texture is accessed using the uv coordinate
+   * specified for each vertex in the mesh vertex attributes. The colors in the texture are added to the base color of
+   * the component. When using both an `emissiveTexture` and an [emissiveColor](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterialMetallicRoughness.html#emissiveColor) their values are
+   * multiplied and then added to the base color of the component.
+   */
+  emissiveTexture?: MeshTextureProperties | string | MeshTextureData | null;
+  /**
+   * A transformation of UV mesh coordinates used to sample the emissive texture. Texture transformations can be used to
+   * optimize re-use of textures, for example by packing many images into a single texture "atlas" and using the texture
+   * transform offset and scale to sample a specific region within this larger texture.
+   *
+   * @since 4.27
+   */
+  emissiveTextureTransform?: MeshTextureTransformProperties | null;
+  /**
+   * Specifies a texture from which to get the combined metallic/roughness information. The metallic value should be
+   * stored in the `blue` channel, while the roughness value should be stored in the `green` channel. The `red` and
+   * `alpha` channels are ignored.
+   *
+   * The texture is accessed using the uv coordinate specified for each vertex in the mesh vertex attributes.
+   */
+  metallicRoughnessTexture?: MeshTextureProperties | string | MeshTextureData | null;
+  /**
+   * Allows to specify a texture to get the occlusion information from. This can be used to simulate the effect of
+   * ambient light on the object. The texture is accessed using the uv coordinate specified for each vertex in the mesh
+   * vertex attributes. The occlusion value should be encoded in the red channel of the texture.
+   */
+  occlusionTexture?: MeshTextureProperties | string | MeshTextureData | null;
+  /**
+   * A transformation of UV mesh coordinates used to sample the occlusion texture. Texture transformations can be used
+   * to optimize re-use of textures, for example by packing many images into a single texture "atlas" and using the
+   * texture transform offset and scale to sample a specific region within this larger texture.
+   *
+   * @since 4.27
+   */
+  occlusionTextureTransform?: MeshTextureTransformProperties | null;
+}
+
+/**
+ * A material determines how a [MeshComponent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html) is visualized. This particular
+ * material (based on [MeshMaterial](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterial.html)) uses the metallic/roughness lighting model to
+ * enable physically based lighting. The metallic and roughness properties can be used to model various realistic
+ * materials including metals and plastics.
+ *
+ * In this image you can see how [metallic](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterialMetallicRoughness.html#metallic) and [roughness](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterialMetallicRoughness.html#roughness) property values influence the display
+ * of the material:
+ *
+ * <img src="https://developers.arcgis.com/javascript/latest/assets/img/apiref/geometry/mesh-metal-roughness.png" width="400"/>
+ *
+ * The [metallicRoughnessTexture](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterialMetallicRoughness.html#metallicRoughnessTexture) can be used to map specific metallic/roughness properties
+ * on different parts of the model.
+ *
+ * @since 4.15
+ * @see [MeshComponent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html)
+ * @see [MeshMaterial](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterial.html)
+ * @see [Sample - Low poly terrain using mesh geometry](https://developers.arcgis.com/javascript/latest/sample-code/geometry-mesh-elevation/)
+ */
+export default class MeshMaterialMetallicRoughness extends MeshMaterial {
+  constructor(properties?: MeshMaterialMetallicRoughnessProperties);
+  /**
+   * Specifies a single, uniform emissive color for the [MeshComponent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html).
+   * The emissiveColor is added to the base color of the component.
+   * This can be autocast with a named string, hex string, array of rgb values, an object with `r`, `g`, `b`
+   * properties, or a [Color](https://developers.arcgis.com/javascript/latest/api-reference/esri-Color.html) object. Note that the alpha channel is ignored for emissive colors.
+   */
+  get emissiveColor(): Color | null | undefined;
+  set emissiveColor(value: ColorLike | null | undefined);
+  /**
+   * Specifies a strength value as multiplier for emissive color for the [MeshComponent](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshComponent.html).
+   * Emissive strength will be read or stored using the [KHR_materials_emissive_strength](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md)
+   * extension when importing or exporting GLTFs.
+   */
+  accessor emissiveStrength: number | null | undefined;
+  /**
+   * Specifies a texture from which to get emissive color information. The texture is accessed using the uv coordinate
+   * specified for each vertex in the mesh vertex attributes. The colors in the texture are added to the base color of
+   * the component. When using both an `emissiveTexture` and an [emissiveColor](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-support-MeshMaterialMetallicRoughness.html#emissiveColor) their values are
+   * multiplied and then added to the base color of the component.
+   */
+  get emissiveTexture(): MeshTexture | null | undefined;
+  set emissiveTexture(value: MeshTextureProperties | string | MeshTextureData | null | undefined);
+  /**
+   * A transformation of UV mesh coordinates used to sample the emissive texture. Texture transformations can be used to
+   * optimize re-use of textures, for example by packing many images into a single texture "atlas" and using the texture
+   * transform offset and scale to sample a specific region within this larger texture.
+   *
+   * @since 4.27
+   */
+  get emissiveTextureTransform(): MeshTextureTransform | null | undefined;
+  set emissiveTextureTransform(value: MeshTextureTransformProperties | null | undefined);
+  /**
+   * Specifies how much the material behaves like a metal. Values must be in the range 0 (non metal material) to 1
+   * (metal material). Physically accurate materials are usually either a metal (1) or a non-metal (0) and not something
+   * inbetween.
+   *
+   * @default 1
+   */
+  accessor metallic: number;
+  /**
+   * Specifies a texture from which to get the combined metallic/roughness information. The metallic value should be
+   * stored in the `blue` channel, while the roughness value should be stored in the `green` channel. The `red` and
+   * `alpha` channels are ignored.
+   *
+   * The texture is accessed using the uv coordinate specified for each vertex in the mesh vertex attributes.
+   */
+  get metallicRoughnessTexture(): MeshTexture | null | undefined;
+  set metallicRoughnessTexture(value: MeshTextureProperties | string | MeshTextureData | null | undefined);
+  /**
+   * Allows to specify a texture to get the occlusion information from. This can be used to simulate the effect of
+   * ambient light on the object. The texture is accessed using the uv coordinate specified for each vertex in the mesh
+   * vertex attributes. The occlusion value should be encoded in the red channel of the texture.
+   */
+  get occlusionTexture(): MeshTexture | null | undefined;
+  set occlusionTexture(value: MeshTextureProperties | string | MeshTextureData | null | undefined);
+  /**
+   * A transformation of UV mesh coordinates used to sample the occlusion texture. Texture transformations can be used
+   * to optimize re-use of textures, for example by packing many images into a single texture "atlas" and using the
+   * texture transform offset and scale to sample a specific region within this larger texture.
+   *
+   * @since 4.27
+   */
+  get occlusionTextureTransform(): MeshTextureTransform | null | undefined;
+  set occlusionTextureTransform(value: MeshTextureTransformProperties | null | undefined);
+  /**
+   * Indicates how rough the surface of the material is. Values must be in the range 0 (fully smooth surface) to 1
+   * (fully diffuse surface).
+   *
+   * @default 1
+   */
+  accessor roughness: number;
+}