@types/three 0.164.0 → 0.165.0

three/examples/jsm/renderers/common/nodes/NodeUniform.d.ts

@@ -0,0 +1,63 @@
+import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from "three";
+import NodeUniform from "../../../nodes/core/NodeUniform.js";
+import {
+    ColorUniform,
+    FloatUniform,
+    Matrix3Uniform,
+    Matrix4Uniform,
+    Vector2Uniform,
+    Vector3Uniform,
+    Vector4Uniform,
+} from "../Uniform.js";
+declare class FloatNodeUniform extends FloatUniform {
+    nodeUniform: NodeUniform<number>;
+    constructor(nodeUniform: NodeUniform<number>);
+    getValue(): number;
+}
+declare class Vector2NodeUniform extends Vector2Uniform {
+    nodeUniform: NodeUniform<Vector2>;
+    constructor(nodeUniform: NodeUniform<Vector2>);
+    getValue(): Vector2;
+}
+declare class Vector3NodeUniform extends Vector3Uniform {
+    nodeUniform: NodeUniform<Vector3>;
+    constructor(nodeUniform: NodeUniform<Vector3>);
+    getValue(): Vector3;
+}
+declare class Vector4NodeUniform extends Vector4Uniform {
+    nodeUniform: NodeUniform<Vector4>;
+    constructor(nodeUniform: NodeUniform<Vector4>);
+    getValue(): Vector4;
+}
+declare class ColorNodeUniform extends ColorUniform {
+    nodeUniform: NodeUniform<Color>;
+    constructor(nodeUniform: NodeUniform<Color>);
+    getValue(): Color;
+}
+declare class Matrix3NodeUniform extends Matrix3Uniform {
+    nodeUniform: NodeUniform<Matrix3>;
+    constructor(nodeUniform: NodeUniform<Matrix3>);
+    getValue(): Matrix3;
+}
+declare class Matrix4NodeUniform extends Matrix4Uniform {
+    nodeUniform: NodeUniform<Matrix4>;
+    constructor(nodeUniform: NodeUniform<Matrix4>);
+    getValue(): Matrix4;
+}
+export {
+    ColorNodeUniform,
+    FloatNodeUniform,
+    Matrix3NodeUniform,
+    Matrix4NodeUniform,
+    Vector2NodeUniform,
+    Vector3NodeUniform,
+    Vector4NodeUniform,
+};
+export type NodeUniformGPU =
+    | FloatNodeUniform
+    | Vector2NodeUniform
+    | Vector3NodeUniform
+    | Vector4NodeUniform
+    | ColorNodeUniform
+    | Matrix3NodeUniform
+    | Matrix4NodeUniform;

three/examples/jsm/renderers/common/nodes/NodeUniformsGroup.d.ts

@@ -0,0 +1,12 @@
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import UniformNode from "../../../nodes/core/UniformNode.js";
+import UniformsGroup from "../UniformsGroup.js";
+declare class NodeUniformsGroup extends UniformsGroup {
+    id: number;
+    groupNode: UniformGroupNode;
+    readonly isNodeUniformsGroup: true;
+    constructor(name: string, groupNode: UniformGroupNode);
+    get shared(): boolean;
+    getNodes(): UniformNode<unknown>[];
+}
+export default NodeUniformsGroup;

three/examples/jsm/renderers/common/nodes/Nodes.d.ts

@@ -0,0 +1,94 @@
+import { Camera, Color, CubeTexture, FogBase, Material, Object3D, Scene, Texture } from "three";
+import Node from "../../../nodes/core/Node.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import ComputeNode from "../../../nodes/gpgpu/ComputeNode.js";
+import LightsNode from "../../../nodes/lighting/LightsNode.js";
+import { NodeFrame, ShaderNodeObject } from "../../../nodes/Nodes.js";
+import Backend from "../Backend.js";
+import ChainMap from "../ChainMap.js";
+import DataMap from "../DataMap.js";
+import Renderer from "../Renderer.js";
+import RenderObject from "../RenderObject.js";
+import NodeBuilderState from "./NodeBuilderState.js";
+import NodeUniformsGroup from "./NodeUniformsGroup.js";
+interface NodeUniformsGroupData {
+    renderId?: number | undefined;
+    frameId?: number | undefined;
+}
+interface RenderObjectData {
+    nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface ComputeNodeData {
+    nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface SceneData {
+    background?: Color | Texture | CubeTexture | undefined;
+    backgroundNode?: Node | undefined;
+    fog?: FogBase | undefined;
+    fogNode?: Node | undefined;
+    environment?: Texture | undefined;
+    environmentNode?: Node | undefined;
+}
+declare class Nodes extends DataMap<{
+    nodeUniformsGroup: {
+        key: NodeUniformsGroup;
+        value: NodeUniformsGroupData;
+    };
+    renderObject: {
+        key: RenderObject;
+        value: RenderObjectData;
+    };
+    computeNode: {
+        key: ComputeNode;
+        value: ComputeNodeData;
+    };
+    scene: {
+        key: Scene;
+        value: SceneData;
+    };
+}> {
+    renderer: Renderer;
+    backend: Backend;
+    nodeFrame: NodeFrame;
+    nodeBuilderCache: Map<string, NodeBuilderState>;
+    callHashCache: ChainMap<readonly [Scene, LightsNode], {
+        callId: number;
+        cacheKey: string;
+    }>;
+    groupsData: ChainMap<readonly [UniformGroupNode, NodeUniformsGroup], {
+        version?: number;
+    }>;
+    constructor(renderer: Renderer, backend: Backend);
+    updateGroup(nodeUniformsGroup: NodeUniformsGroup): boolean;
+    getForRenderCacheKey(renderObject: RenderObject): string;
+    getForRender(renderObject: RenderObject): NodeBuilderState;
+    delete(
+        object: NodeUniformsGroup | RenderObject | ComputeNode | Scene,
+    ): SceneData | RenderObjectData | NodeUniformsGroupData | ComputeNodeData;
+    getForCompute(computeNode: ComputeNode): NodeBuilderState;
+    _createNodeBuilderState(nodeBuilder: NodeBuilder): NodeBuilderState;
+    getEnvironmentNode(scene: Scene): Node | null;
+    getBackgroundNode(scene: Scene): Node | null;
+    getFogNode(scene: Scene): Node | null;
+    getCacheKey(scene: Scene, lightsNode: LightsNode): string;
+    updateScene(scene: Scene): void;
+    get isToneMappingState(): boolean;
+    updateBackground(scene: Scene): void;
+    updateFog(scene: Scene): void;
+    updateEnvironment(scene: Scene): void;
+    getNodeFrame(
+        renderer?: Renderer,
+        scene?: Scene | null,
+        object?: Object3D | null,
+        camera?: Camera | null,
+        material?: Material | null,
+    ): NodeFrame;
+    getNodeFrameForRender(renderObject: RenderObject): NodeFrame;
+    getOutputNode(outputTexture: Texture): ShaderNodeObject<Node>;
+    updateBefore(renderObject: RenderObject): void;
+    updateForCompute(computeNode: ComputeNode): void;
+    updateForRender(renderObject: RenderObject): void;
+    dispose(): void;
+}
+export default Nodes;

three/examples/jsm/utils/SceneUtils.d.ts

@@ -33,19 +33,25 @@ export function reduceVertices<TValue>(
 ): TValue;
 
 /**
- * @param object Object to traverse.
+ * A generator based version of {@link Object3D.traverse}.
+ *
+ * @param object The 3D object to traverse.
  * @yields Objects that passed the filter condition.
  */
 export function traverseGenerator(object: Object3D): Generator<Object3D, void, unknown>;
 
 /**
- * @param object Object to traverse.
+ * A generator based version of {@link Object3D.traverseVisible}.
+ *
+ * @param object The 3D object to traverse.
  * @yields Objects that passed the filter condition.
  */
 export function traverseVisibleGenerator(object: Object3D): Generator<Object3D, void, unknown>;
 
 /**
- * @param object Object to traverse.
+ * A generator based version of {@link Object3D.traverseAncestors}.
+ *
+ * @param object The 3D object to traverse.
  * @yields Objects that passed the filter condition.
  */
 export function traverseAncestorsGenerator(object: Object3D): Generator<Object3D, void, unknown>;

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.164.0",
+    "version": "0.165.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -45,6 +45,6 @@
         "fflate": "~0.8.2",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "58c6d9927d6ac01a5c65fdd023a998d808d352da3e1d79f7bb0b3b290f2d5443",
+    "typesPublisherContentHash": "49d047af400101035815c93fc592aa882a686de2432be990ac9df6ee209b2854",
     "typeScriptVersion": "4.7"
 }

three/src/animation/tracks/StringKeyframeTrack.d.ts

@@ -1,8 +1,7 @@
-import { InterpolationModes } from "../../constants.js";
 import { KeyframeTrack } from "../KeyframeTrack.js";
 
 export class StringKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<any>, interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<any>);
 
     /**
      * @default 'string'

three/src/core/BufferGeometry.d.ts

@@ -15,6 +15,24 @@ export type NormalOrGLBufferAttributes = Record<
     BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute
 >;
 
+export interface GeometryGroup {
+    /**
+     * Specifies the first element in this draw call – the first vertex for non-indexed geometry, otherwise the first triangle index.
+     * @remarks Expects a `Integer`
+     */
+    start: number;
+    /**
+     * Specifies how many vertices (or indices) are included.
+     * @remarks Expects a `Integer`
+     */
+    count: number;
+    /**
+     * Specifies the material array index to use.
+     * @remarks Expects a `Integer`
+     */
+    materialIndex?: number | undefined;
+}
+
 /**
  * A representation of mesh, line, or point geometry
  * Includes vertex positions, face indices, normals, colors, UVs, and custom attributes within buffers, reducing the cost of passing all this data to the GPU.
@@ -144,23 +162,7 @@ export class BufferGeometry<
      * @remarks Use {@link addGroup | .addGroup} to add groups, rather than modifying this array directly.
      * @defaultValue `[]`
      */
-    groups: Array<{
-        /**
-         * Specifies the first element in this draw call – the first vertex for non-indexed geometry, otherwise the first triangle index.
-         * @remarks Expects a `Integer`
-         */
-        start: number;
-        /**
-         * Specifies how many vertices (or indices) are included.
-         * @remarks Expects a `Integer`
-         */
-        count: number;
-        /**
-         * Specifies the material array index to use.
-         * @remarks Expects a `Integer`
-         */
-        materialIndex?: number | undefined;
-    }>;
+    groups: GeometryGroup[];
 
     /**
      * Bounding box for the {@link THREE.BufferGeometry | BufferGeometry}, which can be calculated with {@link computeBoundingBox | .computeBoundingBox()}.

three/src/core/InterleavedBuffer.d.ts

@@ -10,6 +10,8 @@ import { InterleavedBufferAttribute } from "./InterleavedBufferAttribute.js";
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBuffer.js | Source}
  */
 export class InterleavedBuffer {
+    readonly isInterleavedBuffer: true;
+
     /**
      * Create a new instance of {@link InterleavedBuffer}
      * @param array A {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray | TypedArray} with a shared buffer. Stores the geometry data.

three/src/loaders/LoaderUtils.d.ts

@@ -1,7 +1,10 @@
-export interface LoaderUtils {
-    decodeText(array: BufferSource): string;
-    extractUrlBase(url: string): string;
-    resolveURL(url: string, path: string): string;
-}
+export class LoaderUtils {
+    /**
+     * @deprecated decodeText() has been deprecated with r165 and will be removed with r175. Use TextDecoder instead.
+     */
+    static decodeText(array: BufferSource): string;
+
+    static extractUrlBase(url: string): string;
 
-export const LoaderUtils: LoaderUtils;
+    static resolveURL(url: string, path: string): string;
+}

three/src/math/Color.d.ts

@@ -255,7 +255,7 @@ export class Color {
      * Copies given color.
      * @param color Color to copy.
      */
-    copy(color: this): this;
+    copy(color: Color): this;
 
     /**
      * Copies given color making conversion from sRGB to linear space.

three/src/math/Matrix3.d.ts

@@ -52,6 +52,8 @@ export interface Matrix {
  * ( class Matrix3 implements Matrix<Matrix3> )
  */
 export class Matrix3 implements Matrix {
+    readonly isMatrix3: true;
+
     /**
      * Creates an identity matrix.
      */

three/src/math/Matrix4.d.ts

@@ -42,6 +42,8 @@ export type Matrix4Tuple = [
  * m.multiply( m3 );
  */
 export class Matrix4 implements Matrix {
+    readonly isMatrix4: true;
+
     /**
      * Creates an identity matrix.
      */

three/src/objects/BatchedMesh.d.ts

@@ -2,6 +2,7 @@ import { Camera } from "../cameras/Camera.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { Material } from "../materials/Material.js";
 import { Box3 } from "../math/Box3.js";
+import { Color } from "../math/Color.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Sphere } from "../math/Sphere.js";
 import { Mesh } from "./Mesh.js";
@@ -108,6 +109,13 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
         func: ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void) | null,
     ): this;
 
+    /**
+     * Get the color of the defined geometry.
+     * @param index The index of a geometry. Values have to be in the range [0, count].
+     * @param color This color object will be set to the color of the defined geometry.
+     */
+    getColorAt(index: number, color: Color): void;
+
     /**
      * Get the local transformation matrix of the defined instance.
      * @param index The index of an instance. Values have to be in the range [0, count].
@@ -121,6 +129,13 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     getVisibleAt(index: number): boolean;
 
+    /**
+     * Sets the given color to the defined geometry.
+     * @param index The index of a geometry. Values have to be in the range [0, count].
+     * @param color The color of a single geometry.
+     */
+    setColorAt(index: number, color: Color): void;
+
     /**
      * Sets the given local transformation matrix to the defined instance. Make sure you set {@link .instanceMatrix}
      * {@link BufferAttribute.needsUpdate} to true after updating all the matrices.

three/src/objects/InstancedMesh.d.ts

@@ -16,7 +16,7 @@ export interface InstancedMeshEventMap extends Object3DEventMap {
 /**
  * A special version of {@link THREE.Mesh | Mesh} with instanced rendering support
  * @remarks
- * Use {@link InstancedMesh} if you have to render a large number of objects with the same geometry and material but with different world transformations
+ * Use {@link InstancedMesh} if you have to render a large number of objects with the same geometry and material(s) but with different world transformations
  * @remarks
  * The usage of {@link InstancedMesh} will help you to reduce the number of draw calls and thus improve the overall rendering performance in your application.
  * @see Example: {@link https://threejs.org/examples/#webgl_instancing_dynamic | WebGL / instancing / dynamic}
@@ -33,8 +33,8 @@ export class InstancedMesh<
 > extends Mesh<TGeometry, TMaterial, TEventMap> {
     /**
      * Create a new instance of {@link InstancedMesh}
-     * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}.
-     * @param material A single or an array of {@link THREE.Material | Material}. Default {@link THREE.MeshBasicMaterial | `new THREE.MeshBasicMaterial()`}.
+     * @param geometry An instance of {@link BufferGeometry}.
+     * @param material A single or an array of {@link Material}. Default is a new {@link MeshBasicMaterial}.
      * @param count The **maximum** number of instances of this Mesh. Expects a `Integer`
      */
     constructor(geometry: TGeometry | undefined, material: TMaterial | undefined, count: number);

three/src/renderers/WebGLRenderer.d.ts

@@ -1,8 +1,10 @@
 import { Camera } from "../cameras/Camera.js";
 import { ColorSpace, CullFace, ShadowMapType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
+import { TypedArray } from "../core/BufferAttribute.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { Object3D } from "../core/Object3D.js";
 import { Material } from "../materials/Material.js";
+import { Box2 } from "../math/Box2.js";
 import { Box3 } from "../math/Box3.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
 import { Plane } from "../math/Plane.js";
@@ -125,7 +127,7 @@ export interface WebGLDebug {
  */
 export class WebGLRenderer implements Renderer {
     /**
-     * parameters is an optional object with properties defining the renderer's behaviour.
+     * parameters is an optional object with properties defining the renderer's behavior.
      * The constructor also accepts no parameters at all.
      * In all cases, it will assume sane defaults when parameters are missing.
      */
@@ -196,13 +198,6 @@ export class WebGLRenderer implements Renderer {
 
     get coordinateSystem(): typeof WebGLCoordinateSystem;
 
-    /**
-     * @deprecated Migrate your lighting according to the following guide:
-     * https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733.
-     * @default true
-     */
-    useLegacyLights: boolean;
-
     /**
      * @default THREE.NoToneMapping
      */
@@ -421,46 +416,73 @@ export class WebGLRenderer implements Renderer {
         y: number,
         width: number,
         height: number,
-        buffer: any,
+        buffer: TypedArray,
         activeCubeFaceIndex?: number,
     ): void;
 
+    readRenderTargetPixelsAsync(
+        renderTarget: WebGLRenderTarget | WebGLRenderTarget<Texture[]>,
+        x: number,
+        y: number,
+        width: number,
+        height: number,
+        buffer: TypedArray,
+        activeCubeFaceIndex?: number,
+    ): Promise<TypedArray>;
+
     /**
      * Copies a region of the currently bound framebuffer into the selected mipmap level of the selected texture.
      * This region is defined by the size of the destination texture's mip level, offset by the input position.
      *
-     * @param position Specifies the pixel offset from which to copy out of the framebuffer.
      * @param texture Specifies the destination texture.
+     * @param position Specifies the pixel offset from which to copy out of the framebuffer.
      * @param level Specifies the destination mipmap level of the texture.
      */
-    copyFramebufferToTexture(position: Vector2, texture: Texture, level?: number): void;
+    copyFramebufferToTexture(texture: Texture, position?: Vector2 | null, level?: number): void;
 
     /**
-     * Copies srcTexture to the specified level of dstTexture, offset by the input position.
+     * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
+     * position.
      *
-     * @param position Specifies the pixel offset into the dstTexture where the copy will occur.
      * @param srcTexture Specifies the source texture.
      * @param dstTexture Specifies the destination texture.
+     * @param srcRegion Specifies the bounds
+     * @param dstPosition Specifies the pixel offset into the dstTexture where the copy will occur.
      * @param level Specifies the destination mipmap level of the texture.
      */
-    copyTextureToTexture(position: Vector2, srcTexture: Texture, dstTexture: Texture, level?: number): void;
+    copyTextureToTexture(
+        srcTexture: Texture,
+        dstTexture: Texture,
+        srcRegion?: Box2 | null,
+        dstPosition?: Vector2 | null,
+        level?: number,
+    ): void;
 
     /**
-     * Copies the pixels of a texture in the bounds sourceBox in the desination texture starting from the given position.
-     * @param sourceBox Specifies the bounds
-     * @param position Specifies the pixel offset into the dstTexture where the copy will occur.
+     * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
+     * position.
+     *
      * @param srcTexture Specifies the source texture.
      * @param dstTexture Specifies the destination texture.
+     * @param srcRegion Specifies the bounds
+     * @param dstPosition Specifies the pixel offset into the dstTexture where the copy will occur.
      * @param level Specifies the destination mipmap level of the texture.
      */
     copyTextureToTexture3D(
-        sourceBox: Box3,
-        position: Vector3,
         srcTexture: Texture,
         dstTexture: Data3DTexture | DataArrayTexture,
+        srcRegion?: Box3 | null,
+        dstPosition?: Vector3 | null,
         level?: number,
     ): void;
 
+    /**
+     * Initializes the given WebGLRenderTarget memory. Useful for initializing a render target so data can be copied
+     * into it using {@link WebGLRenderer.copyTextureToTexture} before it has been rendered to.
+     * @param target
+     */
+    initRenderTarget(target: WebGLRenderTarget): void;
+
     /**
      * Initializes the given texture. Can be used to preload a texture rather than waiting until first render (which can cause noticeable lags due to decode and GPU upload overhead).
      *

three/src/renderers/webgl/WebGLPrograms.d.ts

@@ -39,6 +39,7 @@ export interface WebGLProgramParameters {
     precision: "lowp" | "mediump" | "highp";
 
     batching: boolean;
+    batchingColor: boolean;
     instancing: boolean;
     instancingColor: boolean;
     instancingMorph: boolean;
@@ -186,7 +187,6 @@ export interface WebGLProgramParameters {
     shadowMapType: ShadowMapType;
 
     toneMapping: ToneMapping;
-    useLegacyLights: boolean;
 
     decodeVideoTexture: boolean;
 

three/src/renderers/webxr/WebXRDepthSensing.d.ts

@@ -21,7 +21,7 @@ export class WebXRDepthSensing {
 
     init(renderer: WebGLRenderer, depthData: XRWebGLDepthInformation, renderState: XRRenderState): void;
 
-    render(renderer: WebGLRenderer, cameraXR: WebXRArrayCamera): void;
+    getMesh(cameraXR: WebXRArrayCamera): Mesh | null;
 
     reset(): void;
 }

three/src/textures/CompressedArrayTexture.d.ts

@@ -9,6 +9,32 @@ import { CompressedTexture } from "./CompressedTexture.js";
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/CompressedArrayTexture.js | Source}
  */
 export class CompressedArrayTexture extends CompressedTexture {
+    /**
+     * Read-only flag to check if a given object is of type {@link CompressedArrayTexture}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isCompressedArrayTexture: true;
+
+    /**
+     * Overridden with a object containing width and height.
+     * @override
+     */
+    get image(): { width: number; height: number; depth: number };
+    set image(value: { width: number; height: number; depth: number });
+
+    /**
+     * This defines how the texture is wrapped in the depth direction.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @defaultValue {@link THREE.ClampToEdgeWrapping}
+     */
+    wrapR: Wrapping;
+
+    /**
+     * A set of all layers which need to be updated in the texture. See {@link CompressedArrayTexture.addLayerUpdate}.
+     */
+    layerUpdates: Set<number>;
+
     /**
      * Create a new instance of {@link CompressedArrayTexture}
      * @param mipmaps The mipmaps array should contain objects with data, width and height.
@@ -29,23 +55,14 @@ export class CompressedArrayTexture extends CompressedTexture {
     );
 
     /**
-     * Read-only flag to check if a given object is of type {@link CompressedArrayTexture}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
+     * Describes that a specific layer of the texture needs to be updated. Normally when {@link Texture.needsUpdate} is
+     * set to true, the entire compressed texture array is sent to the GPU. Marking specific layers will only transmit
+     * subsets of all mipmaps associated with a specific depth in the array which is often much more performant.
      */
-    readonly isCompressedArrayTexture: true;
+    addLayerUpdate(layerIndex: number): void;
 
     /**
-     * Overridden with a object containing width and height.
-     * @override
+     * Resets the layer updates registry. See {@link CompressedArrayTexture.addLayerUpdate}.
      */
-    get image(): { width: number; height: number; depth: number };
-    set image(value: { width: number; height: number; depth: number });
-
-    /**
-     * This defines how the texture is wrapped in the depth direction.
-     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
-     * @defaultValue {@link THREE.ClampToEdgeWrapping}
-     */
-    wrapR: Wrapping;
+    clearLayoutUpdates(): void;
 }