@types/three 0.171.0 → 0.173.0

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

@@ -1,13 +1,41 @@
+/** @module NodeConstants **/
+/**
+ * Possible shader stages.
+ *
+ * @property {string} VERTEX The vertex shader stage.
+ * @property {string} FRAGMENT The fragment shader stage.
+ */
 export declare const NodeShaderStage: {
     readonly VERTEX: "vertex";
     readonly FRAGMENT: "fragment";
 };
+/**
+ * Update types of a node.
+ *
+ * @property {string} NONE The update method is not executed.
+ * @property {string} FRAME The update method is executed per frame.
+ * @property {string} RENDER The update method is executed per render. A frame might be produced by multiple render calls so this value allows more detailed updates than FRAME.
+ * @property {string} OBJECT The update method is executed per {@link Object3D} that uses the node for rendering.
+ */
 export declare const NodeUpdateType: {
     readonly NONE: "none";
     readonly FRAME: "frame";
     readonly RENDER: "render";
     readonly OBJECT: "object";
 };
+/**
+ * Data types of a node.
+ *
+ * @property {string} BOOLEAN Boolean type.
+ * @property {string} INTEGER Integer type.
+ * @property {string} FLOAT Float type.
+ * @property {string} VECTOR2 Two-dimensional vector type.
+ * @property {string} VECTOR3 Three-dimensional vector type.
+ * @property {string} VECTOR4 Four-dimensional vector type.
+ * @property {string} MATRIX2 2x2 matrix type.
+ * @property {string} MATRIX3 3x3 matrix type.
+ * @property {string} MATRIX4 4x4 matrix type.
+ */
 export declare const NodeType: {
     readonly BOOLEAN: "bool";
     readonly INTEGER: "int";
@@ -19,6 +47,13 @@ export declare const NodeType: {
     readonly MATRIX3: "mat3";
     readonly MATRIX4: "mat4";
 };
+/**
+ * Access types of a node. These are relevant for compute and storage usage.
+ *
+ * @property {string} READ_ONLY Read-only access
+ * @property {string} WRITE_ONLY Write-only access.
+ * @property {string} READ_WRITE Read and write access.
+ */
 export declare const NodeAccess: {
     readonly READ_ONLY: "readOnly";
     readonly WRITE_ONLY: "writeOnly";

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

@@ -68,4 +68,4 @@ export default PassNode;
 
 export const pass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;
 export const passTexture: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
-export const depthPass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;
+export const depthPass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;

three/src/nodes/fog/Fog.d.ts

@@ -0,0 +1,26 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const rangeFogFactor: (near: NodeRepresentation, far: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const densityFogFactor: (density: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const fog: (color: NodeRepresentation, factor: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export function rangeFog(
+    color: NodeRepresentation,
+    near: NodeRepresentation,
+    far: NodeRepresentation,
+): ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export function densityFog(
+    color: NodeRepresentation,
+    near: NodeRepresentation,
+    far: NodeRepresentation,
+): ShaderNodeObject<Node>;

three/src/nodes/geometry/RangeNode.d.ts

@@ -1,19 +1,14 @@
-import { Color } from "../../math/Color.js";
-import { Vector2 } from "../../math/Vector2.js";
-import { Vector3 } from "../../math/Vector3.js";
-import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RangeNode extends Node {
-    min: RangeModeBound;
-    max: RangeModeBound;
+    minNode: Node;
+    maxNode: Node;
+
+    constructor(minNode: Node, maxNode: Node);
 
-    constructor(min: RangeModeBound, max: RangeModeBound);
     getVectorLength(builder: NodeBuilder): number;
 }
 
-export const range: (min: RangeModeBound, max: RangeModeBound) => ShaderNodeObject<RangeNode>;
+export const range: (minNode: NodeRepresentation, maxNode: NodeRepresentation) => ShaderNodeObject<RangeNode>;

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

@@ -39,6 +39,11 @@ export const atomicFunc: (
     storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
+export const atomicLoad: (
+    pointerNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
 export const atomicStore: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,

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

@@ -9,5 +9,6 @@ export default ComputeBuiltinNode;
 
 export const numWorkgroups: ShaderNodeObject<ComputeBuiltinNode>;
 export const workgroupId: ShaderNodeObject<ComputeBuiltinNode>;
+export const globalId: ShaderNodeObject<ComputeBuiltinNode>;
 export const localId: ShaderNodeObject<ComputeBuiltinNode>;
 export const subgroupSize: ShaderNodeObject<ComputeBuiltinNode>;

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

@@ -8,18 +8,23 @@ export default class ComputeNode extends Node {
     count: number;
     workgroupSize: number[];
     dispatchCount: number;
+    name: string;
 
     onInitFunction: ((args: { renderer: Renderer }) => void) | null;
 
     constructor(computeNode: Node, count: number, workgroupSize?: number[]);
 
+    label(name: string): void;
+
+    updateDispatchCount(): void;
+
     onInit(callback: ((args: { renderer: Renderer }) => void) | null): void;
 }
 
 export const compute: (
     node: NodeRepresentation,
     count: number,
-    workgroupSize: number[],
+    workgroupSize?: number[],
 ) => ShaderNodeObject<ComputeNode>;
 
 declare module "../tsl/TSLCore.js" {

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

@@ -7,6 +7,8 @@ declare class WorkgroupInfoNode extends Node {
 
     readonly isWorkgroupInfoNode: true;
 
+    elementType: string;
+
     scope: string;
 
     constructor(scope: string, bufferType: string, bufferCount?: number);

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

@@ -0,0 +1,15 @@
+import { Light } from "../../lights/Light.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class ShadowBaseNode extends Node {
+    light: Light;
+
+    readonly isShadowBasedNode: true;
+
+    constructor(light: Light);
+}
+
+export const shadowPositionWorld: ShaderNodeObject<Node>;
+
+export default ShadowBaseNode;

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

@@ -2,6 +2,7 @@ import { Light } from "../../lights/Light.js";
 import { LightShadow } from "../../lights/LightShadow.js";
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import ShadowBaseNode from "./ShadowBaseNode.js";
 
 export const BasicShadowFilter: (
     depthTexture: NodeRepresentation,
@@ -25,7 +26,7 @@ export const VSMShadowFilter: (
     shadowCoord: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
 
-declare class ShadowNode extends Node {
+declare class ShadowNode extends ShadowBaseNode {
     constructor(light: Light, shadow: LightShadow | null);
 }
 

three/src/nodes/math/MathNode.d.ts

@@ -37,7 +37,6 @@ export type MathNodeMethod1 =
     | typeof MathNode.TRANSPOSE;
 
 export type MathNodeMethod2 =
-    | typeof MathNode.ATAN2
     | typeof MathNode.MIN
     | typeof MathNode.MAX
     | typeof MathNode.MOD
@@ -99,7 +98,6 @@ export default class MathNode extends TempNode {
 
     // 2 inputs
 
-    static ATAN2: "atan2";
     static MIN: "min";
     static MAX: "max";
     static MOD: "mod";
@@ -124,6 +122,8 @@ export default class MathNode extends TempNode {
     bNode: Node | null;
     cNode: Node | null;
 
+    readonly isMathNode: true;
+
     constructor(method: MathNodeMethod1, aNode: Node);
     constructor(method: MathNodeMethod2, aNode: Node, bNode: Node);
     constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);
@@ -157,7 +157,7 @@ export const cos: Unary;
 export const tan: Unary;
 export const asin: Unary;
 export const acos: Unary;
-export const atan: Unary;
+export const atan: (a: NodeRepresentation, b?: NodeRepresentation) => ShaderNodeObject<MathNode>;
 export const abs: Unary;
 export const sign: Unary;
 export const length: Unary;
@@ -174,7 +174,6 @@ export const transpose: Unary;
 
 type Binary = (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
-export const atan2: Binary;
 export const min: Binary;
 export const max: Binary;
 export const mod: Binary;
@@ -210,6 +209,18 @@ export const rand: (uv: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 export const mixElement: Ternary;
 export const smoothstepElement: Ternary;
 
+/**
+ * @deprecated
+ */
+export const atan2: Binary;
+
+// GLSL alias function
+
+export const faceforward: typeof faceForward;
+export const inversesqrt: typeof inverseSqrt;
+
+// Method chaining
+
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         all: typeof all;

three/src/nodes/math/OperatorNode.d.ts

@@ -28,6 +28,8 @@ export default class OperatorNode extends TempNode {
     bNode: Node;
     op: OperatorNodeOp;
 
+    readonly isOperatorNode: true;
+
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
 

three/src/nodes/shapes/Shapes.d.ts

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

three/src/nodes/tsl/TSLBase.d.ts

@@ -1,6 +1,7 @@
 export * from "../accessors/BufferAttributeNode.js";
 export * from "../code/ExpressionNode.js";
 export * from "../code/FunctionCallNode.js";
+export * from "../core/ArrayNode.js";
 export * from "../core/AssignNode.js";
 export * from "../core/BypassNode.js";
 export * from "../core/CacheNode.js";

three/src/nodes/tsl/TSLCore.d.ts

@@ -1,7 +1,10 @@
+import { Color, ColorRepresentation } from "../../math/Color.js";
+import { Vector3 } from "../../math/Vector3.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";
+import ConvertNode from "../utils/ConvertNode.js";
 
 export interface NodeElements {
     toGlobal: (node: Node) => Node;
@@ -35,15 +38,29 @@ export interface NodeElements {
 
 export function addMethodChaining(name: string, nodeElement: unknown): void;
 
-export type SwizzleCharacter = "x" | "y" | "z" | "w" | "r" | "g" | "b" | "a" | "s" | "t" | "p" | "q";
+type XYZWCharacter = "x" | "y" | "z" | "w";
+type RGBACharacter = "r" | "g" | "b" | "a";
+type STPQCharacter = "s" | "t" | "p" | "q";
 
-export type SwizzleOption = Exclude<
-    | `${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
-    "abs" | "sqrt"
->;
+type XYZWSwizzle =
+    | `${XYZWCharacter}`
+    | `${XYZWCharacter}${XYZWCharacter}`
+    | `${XYZWCharacter}${XYZWCharacter}${XYZWCharacter}`
+    | `${XYZWCharacter}${XYZWCharacter}${XYZWCharacter}${XYZWCharacter}`;
+
+type RGBASwizzle =
+    | `${RGBACharacter}`
+    | `${RGBACharacter}${RGBACharacter}`
+    | `${RGBACharacter}${RGBACharacter}${RGBACharacter}`
+    | `${RGBACharacter}${RGBACharacter}${RGBACharacter}${RGBACharacter}`;
+
+type STPQSwizzle =
+    | `${STPQCharacter}`
+    | `${STPQCharacter}${STPQCharacter}`
+    | `${STPQCharacter}${STPQCharacter}${STPQCharacter}`
+    | `${STPQCharacter}${STPQCharacter}${STPQCharacter}${STPQCharacter}`;
+
+export type SwizzleOption = XYZWSwizzle | RGBASwizzle | STPQSwizzle;
 
 export type Swizzable<T extends Node = Node> =
     & T
@@ -70,7 +87,7 @@ export type ShaderNodeObject<T extends Node> =
     & Swizzable<T>;
 
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<T>;
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Vector3 | Node | ShaderNodeObject<T>;
 
 /** anything that can be passed to {@link nodeObject} */
 export type NodeObjectOption = NodeRepresentation | string;
@@ -172,6 +189,11 @@ type ConstructedNode<T> = T extends new(...args: any[]) => infer R ? (R extends
 
 export type NodeOrType = Node | string;
 
+declare class ShaderCallNodeInternal extends Node {
+}
+
+declare class ShaderNodeInternal extends Node {}
+
 export const defined: (v: unknown) => unknown;
 
 export const getConstNodeType: (value: NodeOrType) => string | null;
@@ -209,13 +231,30 @@ export function nodeImmutable<T>(
     ...params: ProxiedTuple<GetConstructors<T>>
 ): ShaderNodeObject<ConstructedNode<T>>;
 
-export function Fn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
-export function Fn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (...args: ProxiedTuple<T>) => R;
-export function Fn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (args: ProxiedObject<T>) => R;
+interface Layout {
+    name: string;
+    type: string;
+    inputs: {
+        name: string;
+        type: string;
+        qualifier?: "in" | "out" | "inout";
+    }[];
+}
+
+interface ShaderNodeFn<Args extends readonly unknown[]> {
+    (...args: Args): ShaderNodeObject<ShaderCallNodeInternal>;
+    shaderNode: ShaderNodeObject<ShaderNodeInternal>;
+    setLayout: (layout: Layout) => this;
+    once: () => this;
+}
+
+export function Fn(jsFunc: () => void): ShaderNodeFn<[]>;
+export function Fn<T extends readonly unknown[]>(
+    jsFunc: (args: T) => void,
+): ShaderNodeFn<ProxiedTuple<T>>;
+export function Fn<T extends { readonly [key: string]: unknown }>(
+    jsFunc: (args: T) => void,
+): ShaderNodeFn<[ProxiedObject<T>]>;
 
 /**
  * @deprecated tslFn() has been renamed to Fn()
@@ -242,7 +281,13 @@ export const If: (boolNode: Node, method: () => void) => StackNode;
 
 export function append(node: Node): Node;
 
-export const color: ConvertType;
+interface ColorFunction {
+    (color?: ColorRepresentation): ShaderNodeObject<ConstNode<Color>>;
+    (r: number, g: number, b: number): ShaderNodeObject<ConstNode<Color>>;
+    (node: Node): ShaderNodeObject<ConvertNode>;
+}
+
+export const color: ColorFunction;
 
 export const float: ConvertType;
 export const int: ConvertType;

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

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

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

@@ -1,6 +1,18 @@
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+interface LoopNodeObjectParameter {
+    // TODO Expand to other types and update loop function types appropriately
+    type?: "int" | "uint";
+    // TODO The variable name should affect the type of the loop function
+    // name?: string;
+    start: number | Node;
+    end: number | Node;
+    condition: string;
+}
+
+type LoopNodeParameter = Node | number | LoopNodeObjectParameter;
 
 declare class LoopNode extends Node {
     params: unknown[];
@@ -12,7 +24,16 @@ declare class LoopNode extends Node {
 
 export default LoopNode;
 
-export const Loop: (...params: unknown[]) => ShaderNodeObject<Node>;
+interface Loop {
+    (i: LoopNodeParameter, func: (inputs: { readonly i: number }) => void): ShaderNodeObject<Node>;
+    (
+        i: LoopNodeParameter,
+        j: LoopNodeParameter,
+        func: (inputs: { readonly i: number; readonly j: number }) => void,
+    ): ShaderNodeObject<Node>;
+}
+
+export const Loop: Loop;
 export const Continue: () => ShaderNodeObject<Node>;
 export const Break: () => ShaderNodeObject<Node>;
 

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

@@ -0,0 +1,11 @@
+import Node from "../core/Node.js";
+
+declare class MemberNode extends Node {
+    node: Node;
+    property: string;
+    readonly isMemberNode: true;
+
+    constructor(node: Node, property: string);
+}
+
+export default MemberNode;

three/src/objects/BatchedMesh.d.ts

@@ -186,6 +186,7 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
 
     /**
      * Sets the given local transformation matrix to the defined instance.
+     * Negatively scaled matrices are not supported.
      * @param instanceId The id of an instance to set the matrix of.
      * @param matrix A 4x4 matrix representing the local transformation of a single instance.
      */

three/src/objects/ClippingGroup.d.ts

@@ -2,7 +2,7 @@ import { Plane } from "../math/Plane.js";
 import { Group } from "./Group.js";
 
 /**
- * A special version of the Group object that defines clipping planes for decendant objects. ClippingGroups can be
+ * A special version of the Group object that defines clipping planes for descendant objects. ClippingGroups can be
  * nested, with clipping planes accumulating by type: intersection or union.
  */
 declare class ClippingGroup extends Group {

three/src/objects/InstancedMesh.d.ts

@@ -145,9 +145,10 @@ export class InstancedMesh<
     getMorphAt(index: number, mesh: Mesh): void;
 
     /**
-     * Sets the given local transformation matrix to the defined instance.
-     * @remarks
-     * Make sure you set {@link InstancedBufferAttribute.needsUpdate | .instanceMatrix.needsUpdate()} flag to `true` after updating all the matrices.
+     * Sets the given local transformation matrix to the defined instance. Make sure you set
+     * {@link InstancedBufferAttribute.needsUpdate | .instanceMatrix.needsUpdate()} flag to `true` after updating all
+     * the matrices.
+     * Negatively scaled matrices are not supported.
      * @param index The index of an instance. Values have to be in the range `[0, count]`. Expects a `Integer`
      * @param matrix A 4x4 matrix representing the local transformation of a single instance.
      */

three/src/renderers/WebGLRenderer.d.ts

@@ -26,13 +26,6 @@ import { WebGLState } from "./webgl/WebGLState.js";
 import { WebGLRenderTarget } from "./WebGLRenderTarget.js";
 import { WebXRManager } from "./webxr/WebXRManager.js";
 
-export interface Renderer {
-    domElement: HTMLCanvasElement;
-
-    render(scene: Object3D, camera: Camera): void;
-    setSize(width: number, height: number, updateStyle?: boolean): void;
-}
-
 export interface WebGLRendererParameters extends WebGLCapabilitiesParameters {
     /**
      * A Canvas where the renderer draws its output.
@@ -115,7 +108,7 @@ export interface WebGLDebug {
  *
  * see {@link https://github.com/mrdoob/three.js/blob/master/src/renderers/WebGLRenderer.js|src/renderers/WebGLRenderer.js}
  */
-export class WebGLRenderer implements Renderer {
+export class WebGLRenderer {
     /**
      * parameters is an optional object with properties defining the renderer's behavior.
      * The constructor also accepts no parameters at all.
@@ -198,6 +191,13 @@ export class WebGLRenderer implements Renderer {
      */
     toneMappingExposure: number;
 
+    /**
+     * The normalized resolution scale for the transmission render target, measured in percentage of viewport
+     * dimensions. Lowering this value can result in significant improvements to {@link MeshPhysicalMaterial}
+     * transmission performance. Default is `1`.
+     */
+    transmissionResolutionScale: number;
+
     info: WebGLInfo;
 
     shadowMap: WebGLShadowMap;
@@ -278,12 +278,12 @@ export class WebGLRenderer implements Renderer {
     /**
      * Sets the custom opaque sort function for the WebGLRenderLists. Pass null to use the default painterSortStable function.
      */
-    setOpaqueSort(method: (a: any, b: any) => number): void;
+    setOpaqueSort(method: ((a: any, b: any) => number) | null): void;
 
     /**
      * Sets the custom transparent sort function for the WebGLRenderLists. Pass null to use the default reversePainterSortStable function.
      */
-    setTransparentSort(method: (a: any, b: any) => number): void;
+    setTransparentSort(method: ((a: any, b: any) => number) | null): void;
 
     /**
      * Returns a THREE.Color instance with the current clear color.

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

@@ -1,20 +1,62 @@
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
-interface AnimationContext {
+export interface AnimationContext {
     requestAnimationFrame(callback: FrameRequestCallback, frame?: XRFrame): number;
     cancelAnimationFrame(handle: number): void;
 }
+/**
+ * This module manages the internal animation loop of the renderer.
+ *
+ * @private
+ */
 declare class Animation {
     nodes: Nodes;
     info: Info;
     _context: AnimationContext;
     _animationLoop: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
     _requestId: number | null;
+    /**
+     * Constructs a new animation loop management component.
+     *
+     * @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);
+    /**
+     * Starts the internal animation loop.
+     */
     start(): void;
+    /**
+     * Stops the internal animation loop.
+     */
     stop(): void;
+    /**
+     * Returns the user-level animation loop.
+     *
+     * @return {Function} The animation loop.
+     */
+    getAnimationLoop(): ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
+    /**
+     * Defines the user-level animation loop.
+     *
+     * @param {Function} callback - The animation loop.
+     */
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): void;
+    /**
+     * Returns the animation context.
+     *
+     * @return {Window|XRSession} The animation context.
+     */
+    getContext(): AnimationContext;
+    /**
+     * Defines the context in which `requestAnimationFrame()` is executed.
+     *
+     * @param {Window|XRSession} context - The context to set.
+     */
     setContext(context: AnimationContext): void;
+    /**
+     * Frees all internal resources and stops the animation loop.
+     */
     dispose(): void;
 }
 export default Animation;