@types/three 0.180.0 → 0.182.0

three/src/nodes/utils/CubeMapNode.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class CubeMapNode extends TempNode {
     envNode: Node;
@@ -10,4 +9,4 @@ declare class CubeMapNode extends TempNode {
 
 export default CubeMapNode;
 
-export const cubeMapNode: (envNode: Node) => ShaderNodeObject<CubeMapNode>;
+export const cubeMapNode: (envNode: Node) => CubeMapNode;

three/src/nodes/utils/DebugNode.d.ts

@@ -1,7 +1,6 @@
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class DebugNode extends TempNode {
     constructor(node: Node, callback?: ((code: string) => void) | null);
@@ -12,10 +11,15 @@ export default DebugNode;
 export const debug: (
     node: Node,
     callback?: ((node: NodeBuilder, code: string) => void) | null,
-) => ShaderNodeObject<DebugNode>;
+) => DebugNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        debug: typeof debug;
+declare module "../Nodes.js" {
+    interface Node {
+        debug: (
+            callback?: ((node: NodeBuilder, code: string) => void) | null,
+        ) => DebugNode;
+        debugAssign: (
+            callback?: ((node: NodeBuilder, code: string) => void) | null,
+        ) => this;
     }
 }

three/src/nodes/utils/Discard.d.ts

@@ -1,11 +1,11 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const Discard: (conditional?: Node) => ShaderNodeObject<Node>;
-export const Return: () => ShaderNodeObject<Node>;
+export const Discard: (conditional?: Node) => Node;
+export const Return: () => Node;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        discard: typeof Discard;
+declare module "../Nodes.js" {
+    interface Node {
+        discard: () => Node;
+        discardAssign: () => this;
     }
 }

three/src/nodes/utils/EquirectUV.d.ts

@@ -1,4 +1,3 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const equirectUV: (dirNode?: Node) => ShaderNodeObject<Node>;
+export const equirectUV: (dirNode?: Node) => Node;

three/src/nodes/utils/EventNode.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import NodeFrame from "../core/NodeFrame.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type EventNodeType = typeof EventNode.OBJECT | typeof EventNode.MATERIAL;
 
@@ -12,10 +11,16 @@ declare class EventNode extends Node {
 
     static OBJECT: "object";
     static MATERIAL: "material";
+    static BEFORE_OBJECT: "beforeObject";
+    static BEFORE_MATERIAL: "beforeMaterial";
 }
 
 export default EventNode;
 
-export const OnObjectUpdate: (callback: (frame: NodeFrame) => void) => ShaderNodeObject<Node>;
+export const OnObjectUpdate: (callback: (frame: NodeFrame) => void) => Node;
 
-export const OnMaterialUpdate: (callback: (frame: NodeFrame) => void) => ShaderNodeObject<Node>;
+export const OnMaterialUpdate: (callback: (frame: NodeFrame) => void) => Node;
+
+export const OnBeforeObjectUpdate: (callback: (frame: NodeFrame) => void) => Node;
+
+export const OnBeforeMaterialUpdate: (callback: (frame: NodeFrame) => void) => Node;

three/src/nodes/utils/FunctionOverloadingNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class FunctionOverloadingNode extends Node {
     functionNodes: Node[];
@@ -10,4 +9,4 @@ declare class FunctionOverloadingNode extends Node {
 
 export default FunctionOverloadingNode;
 
-export const overloadingFn: (functionNodes: Node[]) => (...params: Node[]) => ShaderNodeObject<FunctionOverloadingNode>;
+export const overloadingFn: (functionNodes: Node[]) => (...params: Node[]) => FunctionOverloadingNode;

three/src/nodes/utils/LoopNode.d.ts

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import { VarNode } from "../Nodes.js";
 
 interface LoopNodeObjectParameter {
     // TODO Expand to other types and update loop function types appropriately
@@ -10,6 +10,7 @@ interface LoopNodeObjectParameter {
     start: number | Node;
     end: number | Node;
     condition?: string;
+    update?: VarNode | number | string;
 }
 
 type LoopNodeParameter = Node | number | LoopNodeObjectParameter;
@@ -25,14 +26,14 @@ declare class LoopNode extends Node {
 export default LoopNode;
 
 interface Loop {
-    (i: LoopNodeParameter, func: (inputs: { readonly i: number }) => void): ShaderNodeObject<Node>;
+    (i: LoopNodeParameter, func: (inputs: { readonly i: Node }) => void): Node;
     (
         i: LoopNodeParameter,
         j: LoopNodeParameter,
-        func: (inputs: { readonly i: number; readonly j: number }) => void,
-    ): ShaderNodeObject<Node>;
+        func: (inputs: { readonly i: Node; readonly j: Node }) => void,
+    ): Node;
 }
 
 export const Loop: Loop;
-export const Continue: () => ShaderNodeObject<Node>;
-export const Break: () => ShaderNodeObject<Node>;
+export const Continue: () => Node;
+export const Break: () => Node;

three/src/nodes/utils/MatcapUV.d.ts

@@ -1,4 +1,3 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const matcapUV: ShaderNodeObject<Node>;
+export const matcapUV: Node;

three/src/nodes/utils/MaxMipLevelNode.d.ts

@@ -1,7 +1,6 @@
 import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class MaxMipLevelNode extends UniformNode<0> {
     constructor(textureNode: TextureNode);
@@ -11,4 +10,4 @@ export default class MaxMipLevelNode extends UniformNode<0> {
     get texture(): Texture;
 }
 
-export const maxMipLevel: (texture: Texture) => ShaderNodeObject<MaxMipLevelNode>;
+export const maxMipLevel: (texture: Texture) => MaxMipLevelNode;

three/src/nodes/utils/Oscillators.d.ts

@@ -1,7 +1,6 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const oscSine: (timeNode?: Node) => ShaderNodeObject<Node>;
-export const oscSquare: (timeNode?: Node) => ShaderNodeObject<Node>;
-export const oscTriangle: (timeNode?: Node) => ShaderNodeObject<Node>;
-export const oscSawtooth: (timeNode?: Node) => ShaderNodeObject<Node>;
+export const oscSine: (timeNode?: Node) => Node;
+export const oscSquare: (timeNode?: Node) => Node;
+export const oscTriangle: (timeNode?: Node) => Node;
+export const oscSawtooth: (timeNode?: Node) => Node;

three/src/nodes/utils/Packing.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const directionToColor: (node: Node) => ShaderNodeObject<Node>;
-export const colorToDirection: (node: Node) => ShaderNodeObject<Node>;
+export const directionToColor: (node: Node) => Node;
+export const colorToDirection: (node: Node) => Node;
+export const unpackNormal: (xy: Node) => Node;

three/src/nodes/utils/PostProcessingUtils.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 /**
  * Computes a position in view space based on a fragment's screen position expressed as uv coordinates, the fragments
@@ -14,7 +13,7 @@ export const getViewPosition: (
     screenPosition: Node,
     depth: Node,
     projectionMatrixInverse: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 /**
  * Computes a screen position expressed as uv coordinates based on a fragment's position in view space and the camera's
@@ -27,7 +26,7 @@ export const getViewPosition: (
 export const getScreenPosition: (
     viewPosition: Node,
     projectionMatrix: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 /**
  * Computes a normal vector based on depth data. Can be used as a fallback when no normal render target is available or
@@ -42,4 +41,8 @@ export const getNormalFromDepth: (
     uv: Node,
     depthTexture: Node,
     projectionMatrixInverse: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
+
+export const interleavedGradientNoise: (position: Node) => Node;
+
+export const vogelDiskSample: (sampleIndex: Node, samplesCount: Node, phi: Node) => Node;

three/src/nodes/utils/RTTNode.d.ts

@@ -2,7 +2,6 @@ import { TextureDataType } from "../../constants.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface RTTNodeOptions {
     type: TextureDataType;
@@ -38,10 +37,10 @@ export const rtt: (
     width?: number | null,
     height?: number | null,
     options?: RTTNodeOptions,
-) => ShaderNodeObject<RTTNode>;
+) => RTTNode;
 export const convertToTexture: (
     node: Node,
     width?: number | null,
     height?: number | null,
     options?: RTTNodeOptions,
-) => ShaderNodeObject<RTTNode>;
+) => RTTNode;

three/src/nodes/utils/ReflectorNode.d.ts

@@ -3,7 +3,6 @@ import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface ReflectorNodeParameters {
     target?: Object3D | undefined;
@@ -25,7 +24,7 @@ declare class ReflectorNode extends TextureNode {
 
     get target(): Object3D;
 
-    getDepthNode(): ShaderNodeObject<ReflectorNode>;
+    getDepthNode(): ReflectorNode;
 }
 
 declare class ReflectorBaseNode extends Node {
@@ -57,6 +56,6 @@ declare class ReflectorBaseNode extends Node {
     set resolution(value: number);
 }
 
-export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;
+export const reflector: (parameters?: ReflectorNodeParameters) => ReflectorNode;
 
 export default ReflectorNode;

three/src/nodes/utils/RemapNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RemapNode extends Node {
     node: Node;
@@ -19,18 +18,41 @@ export const remap: (
     inHighNode: Node | number,
     outLowNode?: Node | number,
     outHighNode?: Node | number,
-) => ShaderNodeObject<RemapNode>;
+) => RemapNode;
 export const remapClamp: (
     node: Node,
     inLowNode: Node | number,
     inHighNode: Node | number,
     outLowNode?: Node | number,
     outHighNode?: Node | number,
-) => ShaderNodeObject<RemapNode>;
+) => RemapNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        remap: typeof remap;
-        remapClamp: typeof remapClamp;
+declare module "../Nodes.js" {
+    interface Node {
+        remap: (
+            inLowNode: Node | number,
+            inHighNode: Node | number,
+            outLowNode?: Node | number,
+            outHighNode?: Node | number,
+        ) => RemapNode;
+        remapAssign: (
+            inLowNode: Node | number,
+            inHighNode: Node | number,
+            outLowNode?: Node | number,
+            outHighNode?: Node | number,
+        ) => this;
+
+        remapClamp: (
+            inLowNode: Node | number,
+            inHighNode: Node | number,
+            outLowNode?: Node | number,
+            outHighNode?: Node | number,
+        ) => RemapNode;
+        remapClampAssign: (
+            inLowNode: Node | number,
+            inHighNode: Node | number,
+            outLowNode?: Node | number,
+            outHighNode?: Node | number,
+        ) => this;
     }
 }

three/src/nodes/utils/RotateNode.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RotateNode extends TempNode {
     positionNode: Node;
@@ -12,4 +11,4 @@ export default class RotateNode extends TempNode {
 export const rotate: (
     positionNode: Node,
     rotationNode: Node | number,
-) => ShaderNodeObject<RotateNode>;
+) => RotateNode;

three/src/nodes/utils/SampleNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class SampleNode extends Node {
     callback: (uv: Node) => Node;
@@ -14,4 +13,4 @@ declare class SampleNode extends Node {
 
 export default SampleNode;
 
-export const sample: (callback: (uv: Node) => Node, uv?: Node | null) => ShaderNodeObject<SampleNode>;
+export const sample: (callback: (uv: Node) => Node, uv?: Node | null) => SampleNode;

three/src/nodes/utils/SpriteSheetUVNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class SpriteSheetUVNode extends Node {
     countNode: Node;
@@ -13,4 +12,4 @@ export const spritesheetUV: (
     countNode: Node,
     uvNode: Node | null,
     frameNode: Node | null,
-) => ShaderNodeObject<SpriteSheetUVNode>;
+) => SpriteSheetUVNode;

three/src/nodes/utils/SpriteUtils.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const billboarding: (
     args?: { position?: Node | null; horizontal?: boolean; vertical?: boolean },
-) => ShaderNodeObject<Node>;
+) => Node;

three/src/nodes/utils/StorageArrayElementNode.d.ts

@@ -1,6 +1,5 @@
 import StorageBufferNode from "../accessors/StorageBufferNode.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ArrayElementNode from "./ArrayElementNode.js";
 
 export default class StorageArrayElementNode extends ArrayElementNode {
@@ -17,4 +16,4 @@ export default class StorageArrayElementNode extends ArrayElementNode {
 export const storageElement: (
     storageBufferNode: Node,
     indexNode: Node,
-) => ShaderNodeObject<StorageArrayElementNode>;
+) => StorageArrayElementNode;

three/src/nodes/utils/Timer.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const time: ShaderNodeObject<Node>;
-export const deltaTime: ShaderNodeObject<Node>;
-export const frameId: ShaderNodeObject<Node>;
+export const time: Node;
+export const deltaTime: Node;
+export const frameId: Node;

three/src/nodes/utils/TriplanarTextures.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const triplanarTextures: (
     textureXNode: Node,
@@ -8,7 +7,7 @@ export const triplanarTextures: (
     scaleNode?: Node,
     positionNode?: Node,
     normalNode?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const triplanarTexture: (
     textureXNode: Node,
@@ -17,4 +16,4 @@ export const triplanarTexture: (
     scaleNode?: Node,
     positionNode?: Node,
     normalNode?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;

three/src/nodes/utils/UVUtils.d.ts

@@ -1,15 +1,17 @@
+import ContextNode from "../core/ContextNode.js";
 import Node from "../core/Node.js";
 import OperatorNode from "../math/OperatorNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export function replaceDefaultUV(callback: (node: Node) => Node, node?: Node | null): ContextNode;
 
 export const rotateUV: (
     uv: Node,
     rotation: Node,
     center?: Node,
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 
 export const spherizeUV: (
     uv: Node,
     strength: Node | number,
     center?: Node,
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;

three/src/nodes/utils/ViewportUtils.d.ts

@@ -1,4 +1,3 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const viewportSafeUV: (uv?: Node | null) => ShaderNodeObject<Node>;
+export const viewportSafeUV: (uv?: Node | null) => Node;

three/src/objects/LOD.d.ts

@@ -57,7 +57,7 @@ export class LOD<TEventMap extends Object3DEventMap = Object3DEventMap> extends
     /**
      * An array of level objects
      */
-    levels: Array<{
+    readonly levels: Array<{
         /** The Object3D to display at this level. */
         object: Object3D;
         /** The distance at which to display this level of detail. Expects a `Float`. */

three/src/objects/Skeleton.d.ts

@@ -61,12 +61,14 @@ export class Skeleton {
     /**
      * The array buffer holding the bone data when using a vertex texture.
      */
-    boneMatrices: Float32Array;
+    boneMatrices: Float32Array | null;
+
+    previousBoneMatrices: Float32Array | null;
 
     /**
      * The {@link THREE.DataTexture | DataTexture} holding the bone data when using a vertex texture.
      */
-    boneTexture: null | DataTexture;
+    boneTexture: DataTexture | null;
 
     frame: number;
 

three/src/renderers/WebGLRenderer.d.ts

@@ -1,5 +1,5 @@
 import { Camera } from "../cameras/Camera.js";
-import { CullFace, ShadowMapType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
+import { CullFace, ShadowMapType, TextureDataType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
 import { TypedArray } from "../core/BufferAttribute.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { Object3D } from "../core/Object3D.js";
@@ -76,6 +76,11 @@ export interface WebGLRendererParameters extends WebGLCapabilitiesParameters {
      * default is false.
      */
     failIfMajorPerformanceCaveat?: boolean | undefined;
+
+    /**
+     * @default UnsignedByteType
+     */
+    outputBufferType?: TextureDataType | undefined;
 }
 
 export interface WebGLDebug {
@@ -100,6 +105,17 @@ export interface WebGLDebug {
         | null;
 }
 
+export interface Effect {
+    setSize(width: number, height: number): void;
+    render(
+        renderer: WebGLRenderer,
+        writeBuffer: WebGLRenderTarget,
+        readBuffer: WebGLRenderTarget,
+        deltaTime: number,
+        maskActive: boolean,
+    ): void;
+}
+
 /**
  * The WebGL renderer displays your beautifully crafted scenes using WebGL, if your device supports it.
  * This renderer has way better performance than CanvasRenderer.
@@ -228,9 +244,6 @@ export class WebGLRenderer {
     getPixelRatio(): number;
     setPixelRatio(value: number): void;
 
-    getDrawingBufferSize(target: Vector2): Vector2;
-    setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
-
     getSize(target: Vector2): Vector2;
 
     /**
@@ -238,6 +251,11 @@ export class WebGLRenderer {
      */
     setSize(width: number, height: number, updateStyle?: boolean): void;
 
+    getDrawingBufferSize(target: Vector2): Vector2;
+    setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
+
+    setEffects(effects: Effect[] | null): void;
+
     getCurrentViewport(target: Vector4): Vector4;
 
     /**

three/src/renderers/common/Animation.d.ts

@@ -1,5 +1,6 @@
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
+import Renderer from "./Renderer.js";
 export interface AnimationContext {
     requestAnimationFrame(callback: FrameRequestCallback, xrFrame?: XRFrame): number;
     cancelAnimationFrame(handle: number): void;
@@ -10,6 +11,7 @@ export interface AnimationContext {
  * @private
  */
 declare class Animation {
+    renderer: Renderer;
     nodes: Nodes;
     info: Info;
     _context: AnimationContext | null;
@@ -18,10 +20,11 @@ declare class Animation {
     /**
      * Constructs a new animation loop management component.
      *
+     * @param {Renderer} renderer - A reference to the main renderer.
      * @param {Nodes} nodes - Renderer component for managing nodes related logic.
      * @param {Info} info - Renderer component for managing metrics and monitoring data.
      */
-    constructor(nodes: Nodes, info: Info);
+    constructor(renderer: Renderer, nodes: Nodes, info: Info);
     /**
      * Starts the internal animation loop.
      */

three/src/renderers/common/Binding.d.ts

@@ -22,6 +22,12 @@ declare class Binding {
      * @param {number} visibility - The shader stage.
      */
     setVisibility(visibility: number): void;
+    /**
+     * The shader stages in which the binding's resource is visible.
+     *
+     * @return {number} The visibility bitmask.
+     */
+    getVisibility(): number;
     /**
      * Clones the binding.
      *

three/src/renderers/common/Bindings.d.ts

@@ -73,6 +73,18 @@ declare class Bindings extends DataMap<{
      * @param {RenderObject} renderObject - The render object.
      */
     updateForRender(renderObject: RenderObject): void;
+    /**
+     * Deletes the bindings for the given compute node.
+     *
+     * @param {Node} computeNode - The compute node.
+     */
+    deleteForCompute(computeNode: ComputeNode): void;
+    /**
+     * Deletes the bindings for the given renderObject node.
+     *
+     * @param {RenderObject} renderObject - The renderObject.
+     */
+    deleteForRender(renderObject: RenderObject): void;
     /**
      * Updates the given array of bindings.
      *

three/src/renderers/common/Buffer.d.ts

@@ -10,6 +10,10 @@ declare class Buffer extends Binding {
     readonly isBuffer: true;
     bytesPerElement: number;
     _buffer: Float32Array | null;
+    _updateRanges: {
+        start: number;
+        count: number;
+    }[];
     /**
      * Constructs a new buffer.
      *
@@ -17,6 +21,26 @@ declare class Buffer extends Binding {
      * @param {TypedArray} [buffer=null] - The buffer.
      */
     constructor(name?: string, buffer?: Float32Array | null);
+    /**
+     * The array of update ranges.
+     *
+     * @type {Array<{start: number, count: number}>}
+     */
+    get updateRanges(): {
+        start: number;
+        count: number;
+    }[];
+    /**
+     * Adds an update range.
+     *
+     * @param {number} start - The start index.
+     * @param {number} count - The number of elements.
+     */
+    addUpdateRange(start: number, count: number): void;
+    /**
+     * Clears all update ranges.
+     */
+    clearUpdateRanges(): void;
     /**
      * The buffer's byte length.
      *