@types/three 0.169.0 → 0.170.0

three/src/nodes/TSL.d.ts

@@ -28,15 +28,16 @@ export * from "./utils/FunctionOverloadingNode.js";
 export * from "./utils/LoopNode.js";
 export * from "./utils/MatcapUVNode.js";
 export * from "./utils/MaxMipLevelNode.js";
-export * from "./utils/OscNode.js";
+export * from "./utils/Oscillators.js";
 export * from "./utils/Packing.js";
+export * from "./utils/PostProcessingUtils.js";
 export * from "./utils/ReflectorNode.js";
 export * from "./utils/RemapNode.js";
 export * from "./utils/RotateNode.js";
 export * from "./utils/RTTNode.js";
 export * from "./utils/SpriteSheetUVNode.js";
 export * from "./utils/SpriteUtils.js";
-export * from "./utils/TimerNode.js";
+export * from "./utils/Timer.js";
 export * from "./utils/TriplanarTexturesNode.js";
 export * from "./utils/UVUtils.js";
 export * from "./utils/ViewportUtils.js";
@@ -82,39 +83,17 @@ export * from "./accessors/VelocityNode.js";
 export * from "./accessors/VertexColorNode.js";
 
 // display
-export * from "./display/AfterImageNode.js";
-export * from "./display/AnaglyphPassNode.js";
-export * from "./display/AnamorphicNode.js";
-export * from "./display/BleachBypass.js";
 export * from "./display/BlendMode.js";
-export * from "./display/BloomNode.js";
 export * from "./display/BumpMapNode.js";
 export * from "./display/ColorAdjustment.js";
 export * from "./display/ColorSpaceNode.js";
-export * from "./display/DenoiseNode.js";
-export * from "./display/DepthOfFieldNode.js";
-export * from "./display/DotScreenNode.js";
-export * from "./display/FilmNode.js";
 export * from "./display/FrontFacingNode.js";
-export * from "./display/FXAANode.js";
-export * from "./display/GaussianBlurNode.js";
-export * from "./display/GTAONode.js";
-export * from "./display/Lut3DNode.js";
-export * from "./display/MotionBlur.js";
 export * from "./display/NormalMapNode.js";
-export * from "./display/ParallaxBarrierPassNode.js";
-export * from "./display/PixelationPassNode.js";
 export * from "./display/PosterizeNode.js";
 export * from "./display/RenderOutputNode.js";
-export * from "./display/RGBShiftNode.js";
 export * from "./display/ScreenNode.js";
-export * from "./display/Sepia.js";
-export * from "./display/SobelOperatorNode.js";
-export * from "./display/SSAAPassNode.js";
-export * from "./display/StereoPassNode.js";
 export * from "./display/ToneMappingNode.js";
 export * from "./display/ToonOutlinePassNode.js";
-export * from "./display/TransitionNode.js";
 export * from "./display/ViewportDepthNode.js";
 export * from "./display/ViewportDepthTextureNode.js";
 export * from "./display/ViewportSharedTextureNode.js";
@@ -148,6 +127,8 @@ export * from "./gpgpu/ComputeNode.js";
 export * from "./lighting/LightingContextNode.js";
 export * from "./lighting/LightNode.js";
 export * from "./lighting/LightsNode.js";
+export * from "./lighting/PointLightNode.js";
+export * from "./lighting/ShadowNode.js";
 
 // pmrem
 export * from "./pmrem/PMREMNode.js";
@@ -171,5 +152,6 @@ export { default as V_GGX_SmithCorrelated } from "./functions/BSDF/V_GGX_SmithCo
 export * from "./lighting/LightUtils.js";
 
 export { default as getGeometryRoughness } from "./functions/material/getGeometryRoughness.js";
+export { default as getParallaxCorrectNormal } from "./functions/material/getParallaxCorrectNormal.js";
 export { default as getRoughness } from "./functions/material/getRoughness.js";
 export { default as getShIrradianceAt } from "./functions/material/getShIrradianceAt.js";

three/src/nodes/accessors/Camera.d.ts

@@ -6,7 +6,6 @@ import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const cameraNear: ShaderNodeObject<UniformNode<number>>;
 export const cameraFar: ShaderNodeObject<UniformNode<number>>;
-export const cameraLogDepth: ShaderNodeObject<UniformNode<number>>;
 export const cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
 export const cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
 export const cameraViewMatrix: ShaderNodeObject<UniformNode<Matrix4>>;

three/src/nodes/accessors/SceneNode.d.ts

@@ -12,9 +12,11 @@ declare class SceneNode extends Node {
 
     static BACKGROUND_BLURRINESS: "backgroundBlurriness";
     static BACKGROUND_INTENSITY: "backgroundIntensity";
+    static BACKGROUND_ROTATION: "backgroundRotation";
 }
 
 export default SceneNode;
 
 export const backgroundBlurriness: ShaderNodeObject<SceneNode>;
 export const backgroundIntensity: ShaderNodeObject<SceneNode>;
+export const backgroundRotation: ShaderNodeObject<SceneNode>;

three/src/nodes/accessors/UniformArrayNode.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import ArrayElementNode from "../utils/ArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
@@ -17,7 +17,7 @@ declare class UniformArrayNode extends BufferNode {
 
     getElementLength(): number;
 
-    element(indexNode: number): ShaderNodeObject<UniformArrayElementNode>;
+    element(indexNode: NodeRepresentation): ShaderNodeObject<UniformArrayElementNode>;
 }
 
 export default UniformArrayNode;

three/src/nodes/accessors/VelocityNode.d.ts

@@ -4,11 +4,15 @@ import UniformNode from "../core/UniformNode.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class VelocityNode extends TempNode {
+    projectionMatrix: Matrix4 | null;
+
     previousModelWorldMatrix: UniformNode<Matrix4>;
     previousProjectionMatrix: UniformNode<Matrix4>;
     previousCameraViewMatrix: UniformNode<Matrix4>;
 
     constructor();
+
+    setProjectionMatrix(projectionMatrix: Matrix4 | null): void;
 }
 
 export default VelocityNode;

three/src/nodes/code/ScriptableNode.d.ts

@@ -5,7 +5,7 @@ declare class Resources extends Map<string, unknown> {
     get<TArgs extends unknown[]>(key: string, callback?: ((...args: TArgs) => void) | null, ...params: TArgs): unknown;
 }
 
-export const global: Resources;
+export const ScriptableNodeResources: Resources;
 
 declare class ScriptableNode extends Node {
     codeNode: Node | null;

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

@@ -11,17 +11,17 @@ export default class StackNode extends Node {
 
     If(boolNode: Node, method: () => void): this;
 
-    ElseIf(node: Node, method: () => void): this;
+    ElseIf(boolNode: Node, method: () => void): this;
 
-    Else(node: Node, method: () => void): this;
+    Else(method: () => void): this;
 
     /**
      * @deprecated Use {@link StackNode#ElseIf Else()} instead.
      */
-    elseif(node: Node, method: () => void): this;
+    elseif(boolNode: Node, method: () => void): this;
 
     /**
      * @deprecated Use {@link StackNode#Else Else()} instead.
      */
-    else(node: Node, method: () => void): this;
+    else(method: () => void): this;
 }

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 sRGBToLinearSRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const sRGBTransferEOTF: (color: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const linearSRGBTosRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const sRGBTransferOETF: (color: NodeRepresentation) => ShaderNodeObject<Node>;

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

@@ -1,4 +1,4 @@
-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";
@@ -15,16 +15,16 @@ export function getColorSpaceMethod(
 
 export default class ColorSpaceNode extends TempNode {
     colorNode: Node;
-    source: WorkingOrOutputColorSpace | ColorSpace;
-    target: WorkingOrOutputColorSpace | ColorSpace;
+    source: string;
+    target: string;
 
     constructor(
         colorNode: Node,
-        source: WorkingOrOutputColorSpace | ColorSpace,
-        target: WorkingOrOutputColorSpace | ColorSpace,
+        source: string,
+        target: string,
     );
 
-    getColorSpace(nodeBuilder: NodeBuilder, colorSpace: WorkingOrOutputColorSpace): ColorSpace;
+    resolveColorSpace(nodeBuilder: NodeBuilder, colorSpace: WorkingOrOutputColorSpace): string;
 }
 
 export const toOutputColorSpace: (
@@ -36,11 +36,17 @@ export const toWorkingColorSpace: (
 
 export const workingToColorSpace: (
     node: NodeRepresentation,
-    colorSpace: ColorSpace,
+    colorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 export const colorSpaceToWorking: (
     node: NodeRepresentation,
-    colorSpace: ColorSpace,
+    colorSpace: string,
+) => ShaderNodeObject<ColorSpaceNode>;
+
+export const convertColorSpace: (
+    node: NodeRepresentation,
+    sourceColorSpace: string,
+    targetColorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 
 declare module "../tsl/TSLCore.js" {

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/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/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}.
      */
@@ -151,8 +168,8 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     getGeometryRangeAt(
         geometryId: number,
-        target?: { start: number; count: number },
-    ): { start: number; count: number } | null;
+        target?: BatchedMeshGeometryRange,
+    ): BatchedMeshGeometryRange | null;
 
     /**
      * Get the geometryIndex of the defined instance.
@@ -208,6 +225,12 @@ 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
@@ -223,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;
 }