@types/three 0.164.0 → 0.165.0

three/examples/jsm/nodes/shadernode/ShaderNode.d.ts

@@ -1,42 +1,42 @@
-import { AnyObject, NodeTypeOption, SwizzleOption } from "../core/constants.js";
 import ConstNode from "../core/ConstNode.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
+import StackNode from "../core/StackNode.js";
 
 export interface NodeElements {
+    toGlobal: (node: Node) => Node;
+
     append: typeof append;
 
-    color: typeof color;
-    float: typeof float;
-    int: typeof int;
-    uint: typeof uint;
-    bool: typeof bool;
-    vec2: typeof vec2;
-    ivec2: typeof ivec2;
-    uvec2: typeof uvec2;
-    bvec2: typeof bvec2;
-    vec3: typeof vec3;
-    ivec3: typeof ivec3;
-    uvec3: typeof uvec3;
-    bvec3: typeof bvec3;
-    vec4: typeof vec4;
-    ivec4: typeof ivec4;
-    uvec4: typeof uvec4;
-    bvec4: typeof bvec4;
-    mat2: typeof mat2;
-    imat2: typeof imat2;
-    umat2: typeof umat2;
-    bmat2: typeof bmat2;
-    mat3: typeof mat3;
-    imat3: typeof imat3;
-    umat3: typeof umat3;
-    bmat3: typeof bmat3;
-    mat4: typeof mat4;
-    imat4: typeof imat4;
-    umat4: typeof umat4;
-    bmat4: typeof bmat4;
-    string: typeof string;
-    arrayBuffer: typeof arrayBuffer;
+    toColor: typeof color;
+    toFloat: typeof float;
+    toInt: typeof int;
+    toUint: typeof uint;
+    toBool: typeof bool;
+    toVec2: typeof vec2;
+    toIvec2: typeof ivec2;
+    toUvec2: typeof uvec2;
+    toBvec2: typeof bvec2;
+    toVec3: typeof vec3;
+    toIvec3: typeof ivec3;
+    toUvec3: typeof uvec3;
+    toBvec3: typeof bvec3;
+    toVec4: typeof vec4;
+    toIvec4: typeof ivec4;
+    toUvec4: typeof uvec4;
+    toBvec4: typeof bvec4;
+    toMat2: typeof mat2;
+    toImat2: typeof imat2;
+    toUmat2: typeof umat2;
+    toBmat2: typeof bmat2;
+    toMat3: typeof mat3;
+    toImat3: typeof imat3;
+    toUmat3: typeof umat3;
+    toBmat3: typeof bmat3;
+    toMat4: typeof mat4;
+    toImat4: typeof imat4;
+    toUmat4: typeof umat4;
+    toBmat4: typeof bmat4;
 
     element: typeof element;
     convert: typeof convert;
@@ -44,6 +44,16 @@ export interface NodeElements {
 
 export function addNodeElement(name: string, nodeElement: unknown): void;
 
+export type SwizzleCharacter = "x" | "y" | "z" | "w" | "r" | "g" | "b" | "a" | "s" | "t" | "p" | "q";
+
+export type SwizzleOption = Exclude<
+    | `${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
+    "abs" | "sqrt"
+>;
+
 export type Swizzable<T extends Node = Node> =
     & T
     & {
@@ -57,6 +67,12 @@ export type ShaderNodeObject<T extends Node> =
             : NodeElements[Key] extends (node: T, ...args: infer Args) => infer R ? (...args: Args) => R
             : never;
     }
+    & {
+        [Key in keyof NodeElements as `${Key}Assign`]: T extends { [K in Key]: infer M } ? M
+            : NodeElements[Key] extends (node: T, ...args: infer Args) => unknown
+                ? (...args: Args) => ShaderNodeObject<T>
+            : never;
+    }
     & Swizzable<T>;
 
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
@@ -160,9 +176,9 @@ type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<
 type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
 type ConstructedNode<T> = T extends new(...args: any[]) => infer R ? (R extends Node ? R : never) : never;
 
-export type NodeOrType = Node | NodeTypeOption;
+export type NodeOrType = Node | string;
 
-export const getConstNodeType: (value: NodeOrType) => NodeTypeOption | null;
+export const getConstNodeType: (value: NodeOrType) => string | null;
 
 export class ShaderNode<T = {}, R extends Node = Node> {
     constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
@@ -201,10 +217,16 @@ export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R):
 export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
     jsFunc: (args: T) => R,
 ): (...args: ProxiedTuple<T>) => R;
-export function tslFn<T extends AnyObject, R extends Node = ShaderNodeObject<Node>>(
+export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
     jsFunc: (args: T) => R,
 ): (args: ProxiedObject<T>) => R;
 
+export const setCurrentStack: (stack: StackNode | null) => void;
+
+export const getCurrentStack: () => StackNode | null;
+
+export const If: (boolNode: Node, method: () => void) => void;
+
 export function append(node: Node): Node;
 
 export const color: ConvertType;
@@ -248,4 +270,4 @@ export const string: (value?: string) => ShaderNodeObject<ConstNode<string>>;
 export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<ArrayBuffer>>;
 
 export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
-export const convert: (node: NodeRepresentation, types: NodeTypeOption) => ShaderNodeObject<Node>;
+export const convert: (node: NodeRepresentation, types: string) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/utils/ConvertNode.d.ts

@@ -1,8 +1,7 @@
 import Node from "../core/Node.js";
-import { NodeTypeOption } from "../Nodes.js";
 
 export default class ConvertNode extends Node {
     node: Node;
-    convertTo: NodeTypeOption;
-    constructor(node: Node, convertTo: NodeTypeOption);
+    convertTo: string;
+    constructor(node: Node, convertTo: string);
 }

three/examples/jsm/nodes/utils/EquirectUVNode.d.ts

@@ -1,8 +1,8 @@
-import { PositionNode, TempNode } from "../Nodes.js";
+import { Node, TempNode } from "../Nodes.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class EquirectUVNode extends TempNode {
-    constructor(dirNode?: ShaderNodeObject<PositionNode>);
+    constructor(dirNode?: ShaderNodeObject<Node>);
 }
 
 export const equirectUV: ShaderNodeObject<EquirectUVNode>;

three/examples/jsm/nodes/utils/SplitNode.d.ts

@@ -1,5 +1,5 @@
-import { SwizzleOption } from "../core/constants.js";
 import Node from "../core/Node.js";
+import { SwizzleOption } from "../shadernode/ShaderNode.js";
 
 /** swizzle node */
 export default class SplitNode extends Node {

three/examples/jsm/nodes/utils/TriplanarTexturesNode.d.ts

@@ -1,4 +1,3 @@
-import PositionNode from "../accessors/PositionNode.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
@@ -10,16 +9,16 @@ export default class TriplanarTexturesNode extends Node {
 
     scaleNode: ShaderNodeObject<Node>;
 
-    positionNode: ShaderNodeObject<PositionNode>;
-    normalNode: ShaderNodeObject<PositionNode>;
+    positionNode: ShaderNodeObject<Node>;
+    normalNode: ShaderNodeObject<Node>;
 
     constructor(
         textureXNode: Node,
         textureYNode?: TextureNode | null,
         textureZNode?: TextureNode | null,
         scaleNode?: ShaderNodeObject<Node>,
-        positionNode?: ShaderNodeObject<PositionNode>,
-        normalNode?: ShaderNodeObject<PositionNode>,
+        positionNode?: ShaderNodeObject<Node>,
+        normalNode?: ShaderNodeObject<Node>,
     );
 }
 

three/examples/jsm/objects/Sky.d.ts

@@ -1,6 +1,24 @@
 import { BoxGeometry, Mesh, ShaderMaterial } from "three";
 
+/**
+ * {@link Sky} creates a ready to go sky environment for your scenes.
+ *
+ * @example
+ * const sky = new Sky();
+ * sky.scale.setScalar( 450000 );
+ *
+ * const phi = MathUtils.degToRad( 90 );
+ * const theta = MathUtils.degToRad( 180 );
+ * const sunPosition = new Vector3().setFromSphericalCoords( 1, phi, theta );
+ *
+ * sky.material.uniforms.sunPosition.value = sunPosition;
+ *
+ * scene.add( sky );
+ */
 export class Sky extends Mesh {
+    /**
+     * Create a new {@link Sky} instance.
+     */
     constructor();
 
     geometry: BoxGeometry;

three/examples/jsm/renderers/common/Animation.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="webxr" />
+import Info from "./Info.js";
+import Nodes from "./nodes/Nodes.js";
+declare class Animation {
+    nodes: Nodes;
+    info: Info;
+    animationLoop: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
+    requestId: number | null;
+    constructor(nodes: Nodes, info: Info);
+    _init(): void;
+    dispose(): void;
+    setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): void;
+}
+export default Animation;

three/examples/jsm/renderers/common/Attributes.d.ts

@@ -0,0 +1,20 @@
+import { BufferAttribute, InterleavedBuffer, InterleavedBufferAttribute } from "three";
+import Backend from "./Backend.js";
+import { AttributeType } from "./Constants.js";
+import DataMap from "./DataMap.js";
+interface Data {
+    version?: number | undefined;
+}
+declare class Attributes extends DataMap<{
+    attribute: {
+        key: BufferAttribute | InterleavedBufferAttribute;
+        value: Data;
+    };
+}> {
+    backend: Backend;
+    constructor(backend: Backend);
+    delete(attribute: BufferAttribute | InterleavedBufferAttribute): Data;
+    update(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
+    _getBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute): InterleavedBuffer | BufferAttribute;
+}
+export default Attributes;

three/examples/jsm/renderers/common/Background.d.ts

@@ -0,0 +1,22 @@
+import { Mesh, Scene } from "three";
+import DataMap from "./DataMap.js";
+import Nodes from "./nodes/Nodes.js";
+import RenderContext from "./RenderContext.js";
+import Renderer from "./Renderer.js";
+import RenderList from "./RenderList.js";
+interface SceneData {
+    backgroundMesh?: Mesh;
+    backgroundCacheKey: string;
+}
+declare class Background extends DataMap<{
+    scene: {
+        key: Scene;
+        value: SceneData;
+    };
+}> {
+    renderer: Renderer;
+    nodes: Nodes;
+    constructor(renderer: Renderer, nodes: Nodes);
+    update(scene: Scene, renderList: RenderList, renderContext: RenderContext): void;
+}
+export default Background;

three/examples/jsm/renderers/common/Binding.d.ts

@@ -0,0 +1,8 @@
+declare class Binding {
+    name: string;
+    visibility: number;
+    constructor(name?: string);
+    setVisibility(visibility: number): void;
+    clone(): Binding & this;
+}
+export default Binding;

three/examples/jsm/renderers/common/Bindings.d.ts

@@ -0,0 +1,45 @@
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import Attributes from "./Attributes.js";
+import Backend from "./Backend.js";
+import Binding from "./Binding.js";
+import DataMap from "./DataMap.js";
+import Info from "./Info.js";
+import Nodes from "./nodes/Nodes.js";
+import Pipelines from "./Pipelines.js";
+import RenderObject from "./RenderObject.js";
+import Textures from "./Textures.js";
+interface Data {
+    bindings?: Binding[] | undefined;
+}
+declare class Bindings extends DataMap<{
+    renderObject: {
+        key: RenderObject;
+        value: Data;
+    };
+    computeNode: {
+        key: ComputeNode;
+        value: Data;
+    };
+}> {
+    backend: Backend;
+    textures: Textures;
+    pipelines: Pipelines;
+    attributes: Attributes;
+    nodes: Nodes;
+    info: Info;
+    constructor(
+        backend: Backend,
+        nodes: Nodes,
+        textures: Textures,
+        attributes: Attributes,
+        pipelines: Pipelines,
+        info: Info,
+    );
+    getForRender(renderObject: RenderObject): Binding[];
+    getForCompute(computeNode: ComputeNode): Binding[];
+    updateForCompute(computeNode: ComputeNode): void;
+    updateForRender(renderObject: RenderObject): void;
+    _init(bindings: Binding[]): void;
+    _update(object: ComputeNode | RenderObject, bindings: Binding[]): void;
+}
+export default Bindings;

three/examples/jsm/renderers/common/Buffer.d.ts

@@ -0,0 +1,11 @@
+import Binding from "./Binding.js";
+declare class Buffer extends Binding {
+    readonly isBuffer: true;
+    bytesPerElement: number;
+    _buffer: Float32Array | null;
+    constructor(name?: string, buffer?: Float32Array | null);
+    get byteLength(): number;
+    get buffer(): Float32Array | null;
+    update(): boolean;
+}
+export default Buffer;

three/examples/jsm/renderers/common/BufferUtils.d.ts

@@ -0,0 +1,4 @@
+declare function getFloatLength(floatLength: number): number;
+declare function getVectorLength(count: number, vectorLength?: number): number;
+declare function getStrideLength(vectorLength: number): number;
+export { getFloatLength, getStrideLength, getVectorLength };

three/examples/jsm/renderers/common/ChainMap.d.ts

@@ -0,0 +1,9 @@
+type RecursiveWeakMap<K extends readonly object[], V> = WeakMap<K[number], V | RecursiveWeakMap<K, V>>;
+export default class ChainMap<K extends readonly object[], V> {
+    weakMap: RecursiveWeakMap<K, V>;
+    constructor();
+    get(keys: K): V | undefined;
+    set(keys: K, value: V): V;
+    delete(keys: K): boolean;
+}
+export {};

three/examples/jsm/renderers/common/ClippingContext.d.ts

@@ -0,0 +1,18 @@
+import { Camera, Material, Matrix3, Matrix4, Plane, Vector4 } from "three";
+import Renderer from "./Renderer.js";
+declare class ClippingContext {
+    version: number;
+    globalClippingCount: number;
+    localClippingCount: number;
+    localClippingEnabled: boolean | undefined;
+    localClipIntersection: boolean;
+    planes: Vector4[];
+    parentVersion: number;
+    viewNormalMatrix: Matrix3;
+    viewMatrix?: Matrix4 | undefined;
+    constructor();
+    projectPlanes(source: readonly Plane[], offset: number): void;
+    updateGlobal(renderer: Renderer, camera: Camera): void;
+    update(parent: ClippingContext, material: Material): void;
+}
+export default ClippingContext;

three/examples/jsm/renderers/common/Color4.d.ts

@@ -1,9 +1,10 @@
-import { Color, ColorRepresentation } from "../../../../src/math/Color.js";
-
-export default class Color4 extends Color {
+import { Color, ColorRepresentation } from "three";
+declare class Color4 extends Color {
+    a: number;
+    constructor(color?: ColorRepresentation);
     constructor(r: number, g: number, b: number, a?: number);
-
     set(...args: [color: ColorRepresentation] | [r: number, g: number, b: number, a?: number]): this;
-
+    copy(color: Color): this;
     clone(): this;
 }
+export default Color4;

three/examples/jsm/renderers/common/ComputePipeline.d.ts

@@ -0,0 +1,8 @@
+import Pipeline from "./Pipeline.js";
+import ProgrammableStage from "./ProgrammableStage.js";
+declare class ComputePipeline extends Pipeline {
+    computeProgram: ProgrammableStage;
+    readonly isComputePipeline: true;
+    constructor(cacheKey: string, computeProgram: ProgrammableStage);
+}
+export default ComputePipeline;

three/examples/jsm/renderers/common/Constants.d.ts

@@ -0,0 +1,9 @@
+export declare const AttributeType: {
+    readonly VERTEX: 1;
+    readonly INDEX: 2;
+    readonly STORAGE: 4;
+};
+export type AttributeType = (typeof AttributeType)[keyof typeof AttributeType];
+export declare const GPU_CHUNK_BYTES = 16;
+export declare const BlendColorFactor = 211;
+export declare const OneMinusBlendColorFactor = 212;

three/examples/jsm/renderers/common/CubeRenderTarget.d.ts

@@ -0,0 +1,7 @@
+import { RenderTargetOptions, Texture, WebGLCubeRenderTarget, WebGLRenderer } from "three";
+declare class CubeRenderTarget extends WebGLCubeRenderTarget {
+    readonly isCubeRenderTarget: true;
+    constructor(size?: number, options?: RenderTargetOptions);
+    fromEquirectangularTexture(renderer: WebGLRenderer, texture: Texture): this;
+}
+export default CubeRenderTarget;

three/examples/jsm/renderers/common/DataMap.d.ts

@@ -0,0 +1,20 @@
+declare class DataMap<
+    M extends {
+        [key: string]: {
+            key: object;
+            value: unknown;
+        };
+    },
+> {
+    data: WeakMap<M[keyof M]["key"], M[keyof M]["value"]>;
+    constructor();
+    get<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
+        key: K;
+    }>["value"];
+    delete<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
+        key: K;
+    }>["value"];
+    has(object: M[keyof M]["key"]): boolean;
+    dispose(): void;
+}
+export default DataMap;

three/examples/jsm/renderers/common/Geometries.d.ts

@@ -0,0 +1,28 @@
+import { BufferAttribute, BufferGeometry } from "three";
+import Attributes from "./Attributes.js";
+import { AttributeType } from "./Constants.js";
+import DataMap from "./DataMap.js";
+import Info from "./Info.js";
+import RenderObject from "./RenderObject.js";
+interface GeometryData {
+    initialized?: boolean | undefined;
+}
+declare class Geometries extends DataMap<{
+    geometry: {
+        key: BufferGeometry;
+        value: GeometryData;
+    };
+}> {
+    attributes: Attributes;
+    info: Info;
+    wireframes: WeakMap<BufferGeometry, BufferAttribute>;
+    attributeCall: WeakMap<BufferAttribute, number>;
+    constructor(attributes: Attributes, info: Info);
+    has(renderObject: RenderObject | BufferGeometry): boolean;
+    updateForRender(renderObject: RenderObject): void;
+    initGeometry(renderObject: RenderObject): void;
+    updateAttributes(renderObject: RenderObject): void;
+    updateAttribute(attribute: BufferAttribute, type: AttributeType): void;
+    getIndex(renderObject: RenderObject): BufferAttribute | null;
+}
+export default Geometries;

three/examples/jsm/renderers/common/Info.d.ts

@@ -1,22 +1,29 @@
 import { Object3D } from "three";
-
-export default class Info {
+declare class Info {
     autoReset: boolean;
-
     frame: number;
     calls: number;
-
-    render: { calls: number; drawCalls: number; triangles: number; points: number; lines: number; timestamp: number };
-
-    compute: { calls: number; computeCalls: number; timestamp: number };
-
-    memory: { geometries: number; textures: number };
-
+    render: {
+        calls: number;
+        drawCalls: number;
+        triangles: number;
+        points: number;
+        lines: number;
+        timestamp: number;
+    };
+    compute: {
+        calls: number;
+        computeCalls: number;
+        timestamp: number;
+    };
+    memory: {
+        geometries: number;
+        textures: number;
+    };
+    constructor();
     update(object: Object3D, count: number, instanceCount: number): void;
-
     updateTimestamp(type: "render" | "compute", time: number): void;
-
     reset(): void;
-
     dispose(): void;
 }
+export default Info;

three/examples/jsm/renderers/common/Pipeline.d.ts

@@ -0,0 +1,6 @@
+declare class Pipeline {
+    cacheKey: string;
+    usedTimes: number;
+    constructor(cacheKey: string);
+}
+export default Pipeline;

three/examples/jsm/renderers/common/Pipelines.d.ts

@@ -0,0 +1,68 @@
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import Backend from "./Backend.js";
+import Binding from "./Binding.js";
+import Bindings from "./Bindings.js";
+import ComputePipeline from "./ComputePipeline.js";
+import DataMap from "./DataMap.js";
+import Nodes from "./nodes/Nodes.js";
+import Pipeline from "./Pipeline.js";
+import ProgrammableStage from "./ProgrammableStage.js";
+import RenderObject from "./RenderObject.js";
+import RenderPipeline from "./RenderPipeline.js";
+interface ComputeNodeData {
+    version: number;
+    pipeline: ComputePipeline;
+}
+interface RenderObjectData {
+    pipeline: RenderPipeline;
+}
+declare class Pipelines extends DataMap<{
+    computeNode: {
+        key: ComputeNode;
+        value: ComputeNodeData;
+    };
+    renderObject: {
+        key: RenderObject;
+        value: RenderObjectData;
+    };
+}> {
+    backend: Backend;
+    nodes: Nodes;
+    bindings: Bindings | null;
+    caches: Map<string, Pipeline>;
+    programs: {
+        vertex: Map<string, ProgrammableStage>;
+        fragment: Map<string, ProgrammableStage>;
+        compute: Map<string, ProgrammableStage>;
+    };
+    constructor(backend: Backend, nodes: Nodes);
+    getForCompute(computeNode: ComputeNode, bindings: Binding[]): ComputePipeline;
+    getForRender(renderObject: RenderObject, promises?: Promise<void>[] | null): RenderPipeline;
+    delete(object: ComputeNode | RenderObject): never;
+    dispose(): void;
+    updateForRender(renderObject: RenderObject): void;
+    _getComputePipeline(
+        computeNode: ComputeNode,
+        stageCompute: ProgrammableStage,
+        cacheKey: string,
+        bindings: Binding[],
+    ): ComputePipeline;
+    _getRenderPipeline(
+        renderObject: RenderObject,
+        stageVertex: ProgrammableStage,
+        stageFragment: ProgrammableStage,
+        cacheKey: string,
+        promises: Promise<void>[] | null,
+    ): RenderPipeline;
+    _getComputeCacheKey(computeNode: ComputeNode, stageCompute: ProgrammableStage): string;
+    _getRenderCacheKey(
+        renderObject: RenderObject,
+        stageVertex: ProgrammableStage,
+        stageFragment: ProgrammableStage,
+    ): string;
+    _releasePipeline(pipeline: Pipeline): void;
+    _releaseProgram(program: ProgrammableStage): void;
+    _needsComputeUpdate(computeNode: ComputeNode): boolean;
+    _needsRenderUpdate(renderObject: RenderObject): true | void;
+}
+export default Pipelines;

three/examples/jsm/renderers/common/ProgrammableStage.d.ts

@@ -0,0 +1,15 @@
+import NodeAttribute from "../../nodes/core/NodeAttribute.js";
+declare class ProgrammableStage {
+    id: number;
+    code: string;
+    stage: "compute" | "vertex" | "fragment";
+    attributes: NodeAttribute[] | null;
+    usedTimes: number;
+    constructor(
+        code: string,
+        type: "compute" | "vertex" | "fragment",
+        transforms?: null,
+        attributes?: NodeAttribute[] | null,
+    );
+}
+export default ProgrammableStage;

three/examples/jsm/renderers/common/RenderBundle.d.ts

@@ -0,0 +1,8 @@
+import { Camera, Object3D } from "three";
+declare class RenderBundle {
+    scene: Object3D;
+    camera: Camera;
+    constructor(scene: Object3D, camera: Camera);
+    clone(): RenderBundle & this;
+}
+export default RenderBundle;

three/examples/jsm/renderers/common/RenderBundles.d.ts

@@ -0,0 +1,10 @@
+import { Camera, Object3D } from "three";
+import ChainMap from "./ChainMap.js";
+import RenderBundle from "./RenderBundle.js";
+declare class RenderBundles {
+    lists: ChainMap<readonly [Object3D, Camera], RenderBundle>;
+    constructor();
+    get(scene: Object3D, camera: Camera): RenderBundle;
+    dispose(): void;
+}
+export default RenderBundles;