@types/three 0.168.0 → 0.170.0

three/src/nodes/core/VarNode.d.ts

@@ -10,11 +10,22 @@ export default class VarNode extends Node {
     constructor(node: Node, name?: string | null);
 }
 
+declare module "../tsl/TSLCore.js" {
+    interface NodeElements {
+        toVar: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+    }
+}
+
+/**
+ * @deprecated Use ".toVar()" instead.
+ */
 export const temp: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
+        /**
+         * @deprecated Use ".toVar()" instead.
+         */
         temp: typeof temp;
-        toVar: typeof temp;
     }
 }

three/src/nodes/display/ColorAdjustment.d.ts

@@ -25,3 +25,32 @@ export const luminance: (
 ) => ShaderNodeObject<MathNode>;
 
 export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+/**
+ * Color Decision List (CDL) v1.2
+ *
+ * Compact representation of color grading information, defined by slope, offset, power, and saturation. The CDL should
+ * be typically be given input in a log space (such as LogC, ACEScc, or AgX Log), and will return output in the same
+ * space. Output may require clamping >=0.
+ *
+ * References:
+ * - ASC CDL v1.2
+ * - https://blender.stackexchange.com/a/55239/43930
+ * - https://docs.acescentral.com/specifications/acescc/
+ *
+ * @param color Input (-Infinity < input < +Infinity)
+ * @param slope Slope (0 ≤ slope < +Infinity)
+ * @param offset Offset (-Infinity < offset < +Infinity; typically -1 < offset < 1)
+ * @param power Power (0 < power < +Infinity)
+ * @param saturation Saturation (0 ≤ saturation < +Infinity; typically 0 ≤ saturation < 4)
+ * @param luminanceCoefficients Luminance coefficients for saturation term, typically Rec. 709
+ * @return Output, -Infinity < output < +Infinity
+ */
+export const cdl: (
+    color: NodeRepresentation,
+    slope?: NodeRepresentation,
+    offset?: NodeRepresentation,
+    power?: NodeRepresentation,
+    saturation?: NodeRepresentation,
+    luminanceCoefficients?: NodeRepresentation,
+) => ShaderNodeObject<Node>;

three/src/nodes/display/ColorSpaceFunctions.d.ts

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const sRGBToLinear: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const sRGBTransferEOTF: (color: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const LinearTosRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const sRGBTransferOETF: (color: NodeRepresentation) => ShaderNodeObject<Node>;

three/src/nodes/display/ColorSpaceNode.d.ts

@@ -1,35 +1,60 @@
-import { ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from "../../constants.js";
+import { LinearSRGBColorSpace, SRGBColorSpace } from "../../constants.js";
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
+export type WorkingOrOutputColorSpace = "WorkingColorSpace" | "OutputColorSpace";
+
 export type ColorSpaceMethod = "LinearTosRGB" | "sRGBToLinear" | "LinearToLinear" | "sRGBTosRGB";
 
-export const getColorSpaceMethod: (
+export function getColorSpaceMethod(
     source: typeof LinearSRGBColorSpace | typeof SRGBColorSpace,
     target: typeof LinearSRGBColorSpace | typeof SRGBColorSpace,
-) => ColorSpaceMethod;
+): ColorSpaceMethod;
 
 export default class ColorSpaceNode extends TempNode {
     colorNode: Node;
-    target: ColorSpace | null;
-    source: ColorSpace | null;
+    source: string;
+    target: string;
+
+    constructor(
+        colorNode: Node,
+        source: string,
+        target: string,
+    );
 
-    constructor(colorNode: Node, target?: ColorSpace | null, source?: ColorSpace | null);
+    resolveColorSpace(nodeBuilder: NodeBuilder, colorSpace: WorkingOrOutputColorSpace): string;
 }
 
 export const toOutputColorSpace: (
     node: NodeRepresentation,
-    colorSpace?: ColorSpace | null,
 ) => ShaderNodeObject<ColorSpaceNode>;
 export const toWorkingColorSpace: (
     node: NodeRepresentation,
-    colorSpace?: ColorSpace | null,
+) => ShaderNodeObject<ColorSpaceNode>;
+
+export const workingToColorSpace: (
+    node: NodeRepresentation,
+    colorSpace: string,
+) => ShaderNodeObject<ColorSpaceNode>;
+export const colorSpaceToWorking: (
+    node: NodeRepresentation,
+    colorSpace: string,
+) => ShaderNodeObject<ColorSpaceNode>;
+
+export const convertColorSpace: (
+    node: NodeRepresentation,
+    sourceColorSpace: string,
+    targetColorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         toOutputColorSpace: typeof toOutputColorSpace;
         toWorkingColorSpace: typeof toWorkingColorSpace;
+
+        workingToColorSpace: typeof workingToColorSpace;
+        colorSpaceToWorking: typeof colorSpaceToWorking;
     }
 }

three/src/nodes/display/RenderOutputNode.d.ts

@@ -1,4 +1,4 @@
-import { ColorSpace, ToneMapping } from "../../constants.js";
+import { ToneMapping } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
@@ -6,11 +6,11 @@ import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 declare class RenderOutputNode extends TempNode {
     colorNode: Node;
     toneMapping: ToneMapping | null;
-    outputColorSpace: ColorSpace | null;
+    outputColorSpace: string | null;
 
     readonly isRenderOutput: true;
 
-    constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null);
+    constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: string | null);
 }
 
 export default RenderOutputNode;
@@ -18,7 +18,7 @@ export default RenderOutputNode;
 export const renderOutput: (
     color: NodeRepresentation,
     toneMapping?: ToneMapping | null,
-    outputColorSpace?: ColorSpace | null,
+    outputColorSpace?: string | null,
 ) => ShaderNodeObject<RenderOutputNode>;
 
 declare module "../tsl/TSLCore.js" {

three/src/nodes/display/ScreenNode.d.ts

@@ -0,0 +1,48 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type ScreenNodeScope =
+    | typeof ScreenNode.COORDINATE
+    | typeof ScreenNode.VIEWPORT
+    | typeof ScreenNode.SIZE
+    | typeof ScreenNode.UV;
+
+declare class ScreenNode extends Node {
+    scope: ScreenNodeScope;
+
+    readonly isViewportNode: true;
+
+    constructor(scope: ScreenNodeScope);
+
+    static COORDINATE: "coordinate";
+    static VIEWPORT: "viewport";
+    static SIZE: "size";
+    static UV: "uv";
+}
+
+export default ScreenNode;
+
+// Screen
+
+export const screenUV: ShaderNodeObject<ScreenNode>;
+export const screenSize: ShaderNodeObject<ScreenNode>;
+export const screenCoordinate: ShaderNodeObject<ScreenNode>;
+
+// Viewport
+
+export const viewport: ShaderNodeObject<ScreenNode>;
+export const viewportSize: ShaderNodeObject<Node>;
+export const viewportCoordinate: ShaderNodeObject<Node>;
+export const viewportUV: ShaderNodeObject<Node>;
+
+// Deprecated
+
+/**
+ * @deprecated "viewportTopLeft" is deprecated. Use "viewportUV" instead.
+ */
+export const viewportTopLeft: ShaderNodeObject<ScreenNode>;
+
+/**
+ * @deprecated "viewportBottomLeft" is deprecated. Use "viewportUV.flipY()" instead.
+ */
+export const viewportBottomLeft: ShaderNodeObject<ScreenNode>;

three/src/nodes/display/ToneMappingFunctions.d.ts

@@ -1,14 +1,14 @@
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const LinearToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const linearToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const ReinhardToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const reinhardToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const CineonToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const cineonToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const ACESFilmicToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const acesFilmicToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const AgXToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const agxToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const NeutralToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const neutralToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;

three/src/nodes/display/ToonOutlinePassNode.d.ts

@@ -0,0 +1,24 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Color } from "../../math/Color.js";
+import { Scene } from "../../scenes/Scene.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import PassNode from "./PassNode.js";
+
+declare class ToonOutlinePassNode extends PassNode {
+    colorNode: Node;
+    thicknessNode: Node;
+    alphaNode: Node;
+
+    constructor(scene: Scene, camera: Camera, colorNode: Node, thicknessNode: Node, alphaNode: Node);
+}
+
+export default ToonOutlinePassNode;
+
+export const toonOutlinePass: (
+    scene: Scene,
+    camera: Camera,
+    color?: Color,
+    thickness?: number,
+    alpha?: number,
+) => ShaderNodeObject<ToonOutlinePassNode>;

three/src/nodes/display/ViewportDepthNode.d.ts

@@ -29,6 +29,8 @@ export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => No
 
 export const perspectiveDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
 
+export const perspectiveDepthToLogarithmicDepth: (perspectiveW: Node, near: Node, far: Node) => Node;
+
 export const depth: ShaderNodeObject<ViewportDepthNode>;
 export const linearDepth: (valueNode?: Node | null) => ShaderNodeObject<ViewportDepthNode>;
 export const viewportLinearDepth: ShaderNodeObject<ViewportDepthNode>;

three/src/nodes/functions/material/getAlphaHashThreshold.d.ts

@@ -0,0 +1,6 @@
+import Node from "../../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../tsl/TSLCore.js";
+
+declare const getAlphaHashThreshold: (position: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export default getAlphaHashThreshold;

three/src/nodes/functions/material/getParallaxCorrectNormal.d.ts

@@ -0,0 +1,10 @@
+import Node from "../../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../tsl/TSLCore.js";
+
+declare const getParallaxCorrectNormal: (
+    normal: NodeRepresentation,
+    cubeSize: NodeRepresentation,
+    cubePos: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export default getParallaxCorrectNormal;

three/src/nodes/functions/material/getShIrradianceAt.d.ts

@@ -0,0 +1,6 @@
+import Node from "../../core/Node.js";
+import { ShaderNodeObject } from "../../tsl/TSLCore.js";
+
+declare const getShIrradianceAt: (normal: Node, shCoefficients: Node) => ShaderNodeObject<Node>;
+
+export default getShIrradianceAt;

three/src/nodes/gpgpu/ComputeNode.d.ts

@@ -1,3 +1,4 @@
+import Renderer from "../../renderers/common/Renderer.js";
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
@@ -8,7 +9,11 @@ export default class ComputeNode extends Node {
     workgroupSize: number[];
     dispatchCount: number;
 
+    onInitFunction: ((args: { renderer: Renderer }) => void) | null;
+
     constructor(computeNode: Node, count: number, workgroupSize?: number[]);
+
+    onInit(callback: ((args: { renderer: Renderer }) => void) | null): void;
 }
 
 export const compute: (

three/src/nodes/lighting/LightsNode.d.ts

@@ -2,17 +2,22 @@ import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import { NodeBuilder } from "../Nodes.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import LightNode from "./LightNode.js";
 
 declare class LightsNode extends Node {
-    constructor(lights?: Light[]);
+    constructor();
 
     setupLightsNode(builder: NodeBuilder): void;
 
+    setupLights(builder: NodeBuilder, lightNodes: LightNode[]): void;
+
     setLights(lights: Light[]): this;
 
     getLights(): Light[];
+
+    get hasLights(): boolean;
 }
 
 export default LightsNode;
 
-export const lights: (lights: Light[]) => ShaderNodeObject<LightsNode>;
+export const lights: (lights?: Light[]) => ShaderNodeObject<LightsNode>;

three/src/nodes/lighting/PointLightNode.d.ts

@@ -1,10 +1,20 @@
 import { PointLight } from "../../lights/PointLight.js";
 import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 
-export default class PointLightNode extends AnalyticLightNode<PointLight> {
+export const directPointLight: (
+    color: NodeRepresentation,
+    lightViewPosition: NodeRepresentation,
+    cutoffDistance: NodeRepresentation,
+    decayExponent: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+declare class PointLightNode extends AnalyticLightNode<PointLight> {
     cutoffDistanceNode: Node;
     decayExponentNode: Node;
 
     constructor(light?: PointLight | null);
 }
+
+export default PointLightNode;

three/src/nodes/lighting/ShadowNode.d.ts

@@ -0,0 +1,12 @@
+import { Light } from "../../lights/Light.js";
+import { LightShadow } from "../../lights/LightShadow.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class ShadowNode extends Node {
+    constructor(light: Light, shadow: LightShadow);
+}
+
+export default ShadowNode;
+
+export const shadow: (light: Light, shadow: LightShadow) => ShaderNodeObject<ShadowNode>;

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

@@ -1,7 +1,7 @@
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const Discard: (conditional: NodeRepresentation) => ShaderNodeObject<Node>;
+export const Discard: (conditional?: NodeRepresentation) => ShaderNodeObject<Node>;
 export const Return: () => ShaderNodeObject<Node>;
 
 declare module "../tsl/TSLCore.js" {

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

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

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

@@ -0,0 +1,45 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+/**
+ * Computes a position in view space based on a fragment's screen position expressed as uv coordinates, the fragments
+ * depth value and the camera's inverse projection matrix.
+ *
+ * @param {vec2} screenPosition - The fragment's screen position expressed as uv coordinates.
+ * @param {float} depth - The fragment's depth value.
+ * @param {mat4} projectionMatrixInverse - The camera's inverse projection matrix.
+ * @return {vec3} The fragments position in view space.
+ */
+export const getViewPosition: (
+    screenPosition: NodeRepresentation,
+    depth: NodeRepresentation,
+    projectionMatrixInverse: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+/**
+ * Computes a screen position expressed as uv coordinates based on a fragment's position in view space and the camera's
+ * projection matrix
+ *
+ * @param {vec3} viewPosition - The fragments position in view space.
+ * @param {mat4} projectionMatrix - The camera's projection matrix.
+ * @return {vec2} The fragment's screen position expressed as uv coordinates.
+ */
+export const getScreenPosition: (
+    viewPosition: NodeRepresentation,
+    projectionMatrix: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+/**
+ * Computes a normal vector based on depth data. Can be used as a fallback when no normal render target is available or
+ * if flat surface normals are required.
+ *
+ * @param {vec2} uv - The texture coordinate.
+ * @param {DepthTexture} depthTexture - The depth texture.
+ * @param {mat4} projectionMatrixInverse - The camera's inverse projection matrix.
+ * @return {vec3} The computed normal vector.
+ */
+export const getNormalFromDepth: (
+    uv: NodeRepresentation,
+    depthTexture: NodeRepresentation,
+    projectionMatrixInverse: NodeRepresentation,
+) => ShaderNodeObject<Node>;

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

@@ -2,6 +2,7 @@ import { Camera } from "../../cameras/Camera.js";
 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 {
@@ -11,7 +12,19 @@ export interface ReflectorNodeParameters {
     bounces?: boolean | undefined;
 }
 
-export default class ReflectorNode extends TextureNode {
+declare class ReflectorNode extends TextureNode {
+    constructor(parameters?: ReflectorNodeParameters);
+
+    get reflector(): ReflectorBaseNode;
+
+    get target(): Object3D;
+
+    getDepthNode(): ShaderNodeObject<ReflectorNode>;
+}
+
+declare class ReflectorBaseNode extends Node {
+    textureNode: TextureNode;
+
     target: Object3D;
     resolution: number;
     generateMipmaps: boolean;
@@ -20,9 +33,7 @@ export default class ReflectorNode extends TextureNode {
     virtualCameras: WeakMap<Camera, Camera>;
     renderTargets: WeakMap<Camera, RenderTarget>;
 
-    constructor(parameters?: ReflectorNodeParameters);
-
-    getTextureNode(): TextureNode;
+    constructor(textureNode: TextureNode, parameters?: ReflectorNodeParameters);
 
     getVirtualCamera(camera: Camera): Camera;
 
@@ -30,3 +41,5 @@ export default class ReflectorNode extends TextureNode {
 }
 
 export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;
+
+export default ReflectorNode;

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

@@ -0,0 +1,21 @@
+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>;
+
+/**
+ * @deprecated Use "time" instead.
+ */
+export const timerLocal: (timeScale?: number) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated Use "time" instead.
+ */
+export const timerGlobal: (timeScale?: number) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated Use "deltaTime" instead.
+ */
+export const timerDelta: (timeScale?: number) => ShaderNodeObject<Node>;

three/src/objects/BatchedMesh.d.ts

@@ -7,6 +7,17 @@ import { Matrix4 } from "../math/Matrix4.js";
 import { Sphere } from "../math/Sphere.js";
 import { Mesh } from "./Mesh.js";
 
+export interface BatchedMeshGeometryRange {
+    vertexStart: number;
+    vertexCount: number;
+    reservedVertexCount: number;
+    indexStart: number;
+    indexCount: number;
+    reservedIndexCount: number;
+    start: number;
+    count: number;
+}
+
 /**
  * A special version of {@link Mesh} with multi draw batch rendering support. Use {@link BatchedMesh} if you have to
  * render a large number of objects with the same material but with different world transformations. The  usage of
@@ -80,6 +91,12 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     get maxInstanceCount(): number;
 
+    get instanceCount(): number;
+
+    get unusedVertexCount(): number;
+
+    get unusedIndexCount(): number;
+
     /**
      * Read-only flag to check if a given object is of type {@link BatchedMesh}.
      */
@@ -141,6 +158,25 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     getVisibleAt(instanceId: number): boolean;
 
+    /**
+     * Get the range representing the subset of triangles related to the attached geometry, indicating the starting
+     * offset and count, or `null` if invalid.
+     *
+     * Return an object of the form: { start: Integer, count: Integer }
+     * @param geometryId The id of the geometry to get the range of.
+     * @param target Optional target object to copy the range in to.
+     */
+    getGeometryRangeAt(
+        geometryId: number,
+        target?: BatchedMeshGeometryRange,
+    ): BatchedMeshGeometryRange | null;
+
+    /**
+     * Get the geometryIndex of the defined instance.
+     * @param instanceId The id of an instance to get the geometryIndex of.
+     */
+    getGeometryIdAt(instanceId: number): number;
+
     /**
      * Sets the given color to the defined geometry instance.
      * @param instanceId The id of the instance to set the color of.
@@ -162,6 +198,13 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     setVisibleAt(instanceId: number, visible: boolean): this;
 
+    /**
+     * Sets the geometryIndex of the instance at the given index.
+     * @param instanceId The id of the instance to set the geometryIndex of.
+     * @param geometryId The geometryIndex to be use by the instance.
+     */
+    setGeometryIdAt(instanceId: number, geometryId: number): this;
+
     /**
      * Adds the given geometry to the {@link BatchedMesh} and returns the associated index referring to it.
      * @param geometry The geometry to add into the {@link BatchedMesh}.
@@ -182,6 +225,19 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     addInstance(geometryId: number): number;
 
+    /**
+     * @param geometryId The id of a geometry to remove from the [name] that was previously added via "addGeometry". Any
+     * instances referencing this geometry will also be removed as a side effect.
+     */
+    deleteGeometry(geometryId: number): this;
+
+    /**
+     * Removes an existing instance from the BatchedMesh using the given instanceId.
+     * @param instanceId The id of an instance to remove from the BatchedMesh that was previously added via
+     * "addInstance".
+     */
+    deleteInstance(instanceId: number): this;
+
     /**
      * Replaces the geometry at `geometryId` with the provided geometry. Throws an error if there is not enough space
      * reserved for geometry. Calling this will change all instances that are rendering that geometry.
@@ -190,6 +246,28 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     setGeometryAt(geometryId: number, geometry: BufferGeometry): number;
 
+    /**
+     * Repacks the sub geometries in [name] to remove any unused space remaining from previously deleted geometry,
+     * freeing up space to add new geometry.
+     */
+    optimize(): this;
+
+    /**
+     * Resizes the available space in BatchedMesh's vertex and index buffer attributes to the provided sizes. If the
+     * provided arguments shrink the geometry buffers but there is not enough unused space at the end of the geometry
+     * attributes then an error is thrown.
+     * @param maxVertexCount the max number of vertices to be used by all unique geometries to resize to.
+     * @param maxIndexCount the max number of indices to be used by all unique geometries to resize to.
+     */
+    setGeometrySize(maxVertexCount: number, maxIndexCount: number): void;
+
+    /**
+     * Resizes the necessary buffers to support the provided number of instances. If the provided arguments shrink the
+     * number of instances but there are not enough unused ids at the end of the list then an error is thrown.
+     * @param maxInstanceCount the max number of individual instances that can be added and rendered by the BatchedMesh.
+     */
+    setInstanceCount(maxInstanceCount: number): void;
+
     getBoundingBoxAt(geometryId: number, target: Box3): Box3 | null;
     getBoundingSphereAt(geometryId: number, target: Sphere): Sphere | null;
 }

three/src/objects/Group.d.ts

@@ -34,10 +34,4 @@ export class Group<TEventMap extends Object3DEventMap = Object3DEventMap> extend
      * @defaultValue `true`
      */
     readonly isGroup: true;
-
-    /**
-     * @override
-     * @defaultValue `Group`
-     */
-    override readonly type: string | "Group";
 }

three/src/objects/LOD.d.ts

@@ -81,6 +81,13 @@ export class LOD<TEventMap extends Object3DEventMap = Object3DEventMap> extends
      */
     addLevel(object: Object3D, distance?: number, hysteresis?: number): this;
 
+    /**
+     * Removes an existing level, based on the distance from the camera. Returns `true` when the level has been removed.
+     * Otherwise `false`.
+     * @param distance Distance of the level to delete.
+     */
+    removeLabel(distance: number): boolean;
+
     /**
      * Get the currently active {@link LOD} level
      * @remarks