@types/three 0.180.0 → 0.181.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Wed, 03 Sep 2025 18:38:35 GMT
+ * Last updated: Fri, 31 Oct 2025 16:38:34 GMT
  * Dependencies: [@dimforge/rapier3d-compat](https://npmjs.com/package/@dimforge/rapier3d-compat), [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/geometries/TextGeometry.d.ts

@@ -59,6 +59,8 @@ export interface TextGeometryParameters extends ExtrudeGeometryOptions {
      * @defaultValue `3`
      */
     bevelSegments?: number | undefined;
+
+    direction?: "ltr" | "rtl" | "tb" | undefined;
 }
 
 /**

three/examples/jsm/gpgpu/BitonicSort.d.ts

@@ -0,0 +1,21 @@
+import { Node, Renderer, StorageBufferNode } from "three/webgpu";
+
+export const getBitonicFlipIndices: (index: Node, blockHeight: Node) => Node;
+
+export const getBitonicDisperseIndices: (index: Node, swapSpan: Node) => Node;
+
+export interface BitonicSortOptions {
+    workgroupSize?: number | undefined;
+}
+
+export class BitonicSort {
+    infoStorage: StorageBufferNode;
+
+    swapOpCount: number;
+    stepCount: number;
+
+    constructor(renderer: Renderer, dataBuffer: StorageBufferNode, options?: BitonicSortOptions);
+
+    computeStep(renderer: Renderer): Promise<void>;
+    compute(renderer: Renderer): Promise<void>;
+}

three/examples/jsm/inspector/Inspector.d.ts

@@ -0,0 +1,10 @@
+import { RendererInspector } from "./RendererInspector.js";
+import { ParametersGroup } from "./tabs/Parameters.js";
+
+declare class Inspector extends RendererInspector {
+    createParameters(name: string): ParametersGroup;
+
+    get domElement(): HTMLDivElement;
+}
+
+export { Inspector };

three/examples/jsm/inspector/RendererInspector.d.ts

@@ -0,0 +1,4 @@
+import { InspectorBase } from "three/webgpu";
+
+export class RendererInspector extends InspectorBase {
+}

three/examples/jsm/inspector/tabs/Parameters.d.ts

@@ -0,0 +1,95 @@
+import { Tab } from "../ui/Tab.js";
+import { ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider } from "../ui/Values.js";
+
+type KeyToValueOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+
+interface ValueSelectWithParameters<T = Record<string, unknown>, K extends keyof T = keyof T>
+    extends ValueSelect<T, K>
+{
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueNumberWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends ValueNumber<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueSliderWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends ValueSlider<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueCheckboxWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, boolean> = KeyToValueOfType<T, boolean>,
+> extends ValueCheckbox<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueButtonWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, (this: T) => void> = KeyToValueOfType<T, (this: T) => void>,
+> extends ValueButton<T, K> {
+    name: (name: string) => this;
+}
+
+interface ValueColorWithParameters<
+    T = Record<string, unknown>,
+    K extends keyof T = keyof T,
+> extends ValueColor<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+declare class ParametersGroup {
+    name: string;
+
+    constructor(parameters: never, name: string);
+
+    add<T, K extends keyof T>(
+        object: T,
+        property: K,
+        options: ReadonlyArray<T[K]> | Record<string, T[K]>,
+    ): ValueSelectWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, number>>(
+        object: T,
+        property: K,
+        min: number,
+        max: number,
+        step?: number,
+    ): ValueSliderWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, number>>(
+        object: T,
+        property: K,
+        min?: number,
+    ): ValueNumberWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, boolean>>(
+        object: T,
+        property: K,
+        options?: never,
+    ): ValueCheckboxWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, (this: T) => void>>(
+        object: T,
+        property: K,
+        options?: never,
+    ): ValueButtonWithParameters<T, K>;
+
+    addFolder(name: string): ParametersGroup;
+
+    addColor<T, K extends keyof T>(object: T, property: K, rgbScale?: number): ValueColorWithParameters<T, K>;
+}
+
+declare class Parameters extends Tab {
+    createGroup(name: string): ParametersGroup;
+}
+
+export { Parameters };
+export type { ParametersGroup };

three/examples/jsm/inspector/ui/Tab.d.ts

@@ -0,0 +1,3 @@
+export class Tab {
+    constructor(title: string);
+}

three/examples/jsm/inspector/ui/Values.d.ts

@@ -0,0 +1,80 @@
+import { ColorRepresentation, EventDispatcher } from "three";
+
+type KeyToValueOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+
+declare class Value<T = Record<string, unknown>, K extends keyof T = keyof T> extends EventDispatcher {
+    onChange(callback: (value: T[K]) => void): this;
+}
+
+export interface ValueNumberParams {
+    value?: number;
+    step?: number;
+    min?: number;
+    max?: number;
+}
+
+declare class ValueNumber<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends Value<T, K> {
+    constructor(params: ValueNumberParams);
+}
+
+export interface ValueCheckboxParams {
+    value?: boolean;
+}
+
+declare class ValueCheckbox<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, boolean> = KeyToValueOfType<T, boolean>,
+> extends Value<T, K> {
+    constructor(params: ValueCheckboxParams);
+}
+
+export interface ValueSliderParams {
+    value?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+
+declare class ValueSlider<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends Value<T, K> {
+    constructor(params: ValueSliderParams);
+
+    setValue(val: number): this;
+    step(value: number): this;
+}
+
+export interface ValueSelectParams<T, K extends keyof T> {
+    options?: ReadonlyArray<T[K]> | Record<string, T[K]>;
+    value?: number;
+}
+
+declare class ValueSelect<T = Record<string, unknown>, K extends keyof T = keyof T> extends Value<T, K> {
+    constructor(params: ValueSelectParams<T, K>);
+}
+
+export interface ValueColorParams {
+    value?: ColorRepresentation;
+}
+
+declare class ValueColor<T = Record<string, unknown>, K extends keyof T = keyof T> extends Value<T, K> {
+    constructor(params: ValueColorParams);
+}
+
+export interface ValueButtonParams {
+    text?: string;
+    value?: () => void;
+}
+
+declare class ValueButton<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, (this: T) => void> = KeyToValueOfType<T, (this: T) => void>,
+> extends Value<T, K> {
+    constructor(params: ValueColorParams);
+}
+
+export { Value, ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider };

three/examples/jsm/interactive/SelectionBox.d.ts

@@ -1,16 +1,16 @@
-import { Camera, Frustum, Mesh, Object3D, Scene, Vector3 } from "three";
+import { Camera, Object3D, Scene, Vector3 } from "three";
 
-export class SelectionBox {
-    constructor(camera: Camera, scene: Scene, deep?: number);
+declare class SelectionBox {
     camera: Camera;
-    collection: Mesh[];
-    deep: number;
-    endPoint: Vector3;
     scene: Scene;
     startPoint: Vector3;
+    endPoint: Vector3;
+    collection: Object3D[];
     instances: Record<string, number[]>;
+    batches: Record<string, number[]>;
+    deep: number;
+
+    constructor(camera: Camera, scene: Scene, deep?: number);
 
-    select(startPoint?: Vector3, endPoint?: Vector3): Mesh[];
-    updateFrustum(startPoint: Vector3, endPoint: Vector3): void;
-    searchChildInFrustum(frustum: Frustum, object: Object3D): void;
+    select(startPoint?: Vector3, endPoint?: Vector3): Object3D[];
 }

three/examples/jsm/lighting/TiledLighting.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Lighting } from "three/webgpu";
 import { Light } from "../../../src/lights/Light.js";
 import TiledLightsNode from "../tsl/lighting/TiledLightsNode.js";
@@ -6,5 +5,5 @@ import TiledLightsNode from "../tsl/lighting/TiledLightsNode.js";
 export class TiledLighting extends Lighting {
     constructor();
 
-    createNode(lights?: Light[]): ShaderNodeObject<TiledLightsNode>;
+    createNode(lights?: Light[]): TiledLightsNode;
 }

three/examples/jsm/loaders/FontLoader.d.ts

@@ -37,5 +37,5 @@ export class Font {
 
     constructor(data: FontData);
 
-    generateShapes(text: string, size?: number): Shape[];
+    generateShapes(text: string, size?: number, direction?: "ltr" | "rtl" | "tb"): Shape[];
 }

three/examples/jsm/loaders/KTX2Loader.d.ts

@@ -35,6 +35,9 @@ export class KTX2Loader extends Loader<CompressedTexture> {
      */
     setWorkerLimit(limit: number): this;
 
+    /**
+     * "detectSupportAsync()" has been deprecated. Use "detectSupport()" and "await renderer.init();" when creating the renderer.
+     */
     detectSupportAsync(renderer: Renderer): Promise<this>;
 
     /**

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

@@ -1,13 +1,12 @@
-import { ShaderNodeObject } from "three/tsl";
 import { BoxGeometry, Mesh, NodeMaterial, UniformNode, Vector3 } from "three/webgpu";
 
 declare class SkyMesh extends Mesh<BoxGeometry, NodeMaterial> {
-    turbidity: ShaderNodeObject<UniformNode<number>>;
-    rayleigh: ShaderNodeObject<UniformNode<number>>;
-    mieCoefficient: ShaderNodeObject<UniformNode<number>>;
-    mieDirectionalG: ShaderNodeObject<UniformNode<number>>;
-    sunPosition: ShaderNodeObject<UniformNode<Vector3>>;
-    upUniform: ShaderNodeObject<UniformNode<Vector3>>;
+    turbidity: UniformNode<number>;
+    rayleigh: UniformNode<number>;
+    mieCoefficient: UniformNode<number>;
+    mieDirectionalG: UniformNode<number>;
+    sunPosition: UniformNode<Vector3>;
+    upUniform: UniformNode<Vector3>;
 
     readonly isSky: true;
 

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

@@ -11,7 +11,7 @@ import {
 } from "three/webgpu";
 
 export interface WaterMeshOptions {
-    resolution?: number | undefined;
+    resolutionScale?: number | undefined;
     waterNormals: Texture;
     alpha?: number | undefined;
     size?: number | undefined;
@@ -24,7 +24,7 @@ export interface WaterMeshOptions {
 declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
     readonly isWater: true;
 
-    resolution: number;
+    resolutionScale: number;
 
     waterNormals: TextureNode;
     alpha: UniformNode<number>;

three/examples/jsm/renderers/CSS2DRenderer.d.ts

@@ -1,23 +1,28 @@
 import { Camera, Object3D, Scene, Vector2 } from "three";
 
-export class CSS2DObject extends Object3D {
-    constructor(element: HTMLElement);
+declare class CSS2DObject extends Object3D {
     element: HTMLElement;
     center: Vector2;
 
+    constructor(element: HTMLElement);
+
     onBeforeRender: (renderer: unknown, scene: Scene, camera: Camera) => void;
     onAfterRender: (renderer: unknown, scene: Scene, camera: Camera) => void;
 }
 
-export type CSS2DParameters = {
-    element?: HTMLElement;
-};
+export interface CSS2DParameters {
+    element?: HTMLElement | undefined;
+}
+
+declare class CSS2DRenderer {
+    domElement: HTMLElement;
+    sortObjects: boolean;
 
-export class CSS2DRenderer {
     constructor(parameters?: CSS2DParameters);
-    domElement: HTMLElement;
 
-    getSize(): { width: number; height: number };
-    setSize(width: number, height: number): void;
-    render(scene: Scene, camera: Camera): void;
+    getSize: () => { width: number; height: number };
+    render: (scene: Scene, camera: Camera) => void;
+    setSize: (width: number, height: number) => void;
 }
+
+export { CSS2DObject, CSS2DRenderer };

three/examples/jsm/tsl/display/AfterImageNode.d.ts

@@ -1,16 +1,15 @@
-import { ShaderNodeObject } from "three/tsl";
-import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
+import { Node, TempNode, TextureNode } from "three/webgpu";
 
 export default class AfterImageNode extends TempNode {
     textureNode: TextureNode;
     textureNodeOld: Node;
-    damp: UniformNode<number>;
+    damp: Node;
 
-    constructor(textureNode: Node, damp?: number);
+    constructor(textureNode: Node, damp?: Node);
 
     getTextureNode(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
 
-export const afterImage: (node: Node, damp?: number) => ShaderNodeObject<AfterImageNode>;
+export const afterImage: (node: Node, damp?: Node | number) => AfterImageNode;

three/examples/jsm/tsl/display/AnaglyphPassNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Scene } from "three/webgpu";
 import StereoCompositePassNode from "./StereoCompositePassNode.js";
 
@@ -10,4 +9,4 @@ declare class AnaglyphPassNode extends StereoCompositePassNode {
 
 export default AnaglyphPassNode;
 
-export const anaglyphPass: (scene: Scene, camera: Camera) => ShaderNodeObject<AnaglyphPassNode>;
+export const anaglyphPass: (scene: Scene, camera: Camera) => AnaglyphPassNode;

three/examples/jsm/tsl/display/AnamorphicNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, Vector2 } from "three/webgpu";
 
 export default class AnamorphicNode extends TempNode {
@@ -29,4 +28,4 @@ export const anamorphic: (
     threshold?: Node,
     scale?: Node,
     samples?: Node | number,
-) => ShaderNodeObject<AnamorphicNode>;
+) => AnamorphicNode;

three/examples/jsm/tsl/display/BleachBypass.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
-export const bleach: (color: Node, opacity?: number) => ShaderNodeObject<Node>;
+export const bleach: (color: Node, opacity?: number) => Node;

three/examples/jsm/tsl/display/BloomNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class BloomNode extends TempNode {
@@ -11,7 +10,7 @@ declare class BloomNode extends TempNode {
 
     constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
 
-    getTexture(): ShaderNodeObject<TextureNode>;
+    getTexture(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
@@ -21,6 +20,6 @@ export const bloom: (
     strength?: number,
     radius?: number,
     threshold?: number,
-) => ShaderNodeObject<BloomNode>;
+) => BloomNode;
 
 export default BloomNode;

three/examples/jsm/tsl/display/ChromaticAberrationNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, Vector2 } from "three/webgpu";
 
 declare class ChromaticAberrationNode extends TempNode {
@@ -17,4 +16,4 @@ export const chromaticAberration: (
     strength?: Node,
     center?: Node | Vector2 | null,
     scale?: Node,
-) => ShaderNodeObject<ChromaticAberrationNode>;
+) => ChromaticAberrationNode;

three/examples/jsm/tsl/display/DenoiseNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, TempNode, UniformNode } from "three/webgpu";
 
 declare class DenoiseNode extends TempNode {
@@ -24,4 +23,4 @@ export const denoise: (
     depthNode: Node,
     normalNode: Node,
     camera: Camera,
-) => ShaderNodeObject<DenoiseNode>;
+) => DenoiseNode;

three/examples/jsm/tsl/display/DepthOfFieldNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class DepthOfFieldNode extends TempNode {
@@ -26,4 +25,4 @@ export const dof: (
     focusDistance?: Node | number,
     focalLength?: Node | number,
     bokehScale?: Node | number,
-) => ShaderNodeObject<DepthOfFieldNode>;
+) => DepthOfFieldNode;

three/examples/jsm/tsl/display/DotScreenNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, UniformNode, Vector2 } from "three/webgpu";
 
 declare class DotScreenNode extends TempNode {
@@ -17,4 +16,4 @@ export const dotScreen: (
     center?: Vector2,
     angle?: number,
     scale?: number,
-) => ShaderNodeObject<DotScreenNode>;
+) => DotScreenNode;

three/examples/jsm/tsl/display/FXAANode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class FXAANode extends TempNode {
@@ -9,4 +8,4 @@ declare class FXAANode extends TempNode {
 
 export default FXAANode;
 
-export const fxaa: (node: Node) => ShaderNodeObject<FXAANode>;
+export const fxaa: (node: Node) => FXAANode;

three/examples/jsm/tsl/display/FilmNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode } from "three/webgpu";
 
 declare class FilmNode extends TempNode {
@@ -15,4 +14,4 @@ export const film: (
     inputNode: Node,
     intensityNode?: Node | null,
     uvNode?: Node | null,
-) => ShaderNodeObject<FilmNode>;
+) => FilmNode;

three/examples/jsm/tsl/display/GTAONode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, TempNode, TextureNode, UniformNode, Vector2 } from "three/webgpu";
 
 declare class GTAONode extends TempNode {
@@ -7,17 +6,19 @@ declare class GTAONode extends TempNode {
 
     resolutionScale: number;
 
-    radius: ShaderNodeObject<UniformNode<number>>;
-    resolution: ShaderNodeObject<UniformNode<Vector2>>;
-    thickness: ShaderNodeObject<UniformNode<number>>;
-    distanceExponent: ShaderNodeObject<UniformNode<number>>;
-    distanceFallOff: ShaderNodeObject<UniformNode<number>>;
-    scale: ShaderNodeObject<UniformNode<number>>;
-    samples: ShaderNodeObject<UniformNode<number>>;
+    radius: UniformNode<number>;
+    resolution: UniformNode<Vector2>;
+    thickness: UniformNode<number>;
+    distanceExponent: UniformNode<number>;
+    distanceFallOff: UniformNode<number>;
+    scale: UniformNode<number>;
+    samples: UniformNode<number>;
+
+    useTemporalFiltering: boolean;
 
     constructor(depthNode: Node, normalNode: Node, camera: Camera);
 
-    getTextureNode(): ShaderNodeObject<TextureNode>;
+    getTextureNode(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
@@ -28,4 +29,4 @@ export const ao: (
     depthNode: Node,
     normalNode: Node,
     camera: Camera,
-) => ShaderNodeObject<GTAONode>;
+) => GTAONode;

three/examples/jsm/tsl/display/GaussianBlurNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, Vector2 } from "three/webgpu";
 
 export interface GaussianBlurNodeOptions {
@@ -43,7 +42,7 @@ export const gaussianBlur: (
     directionNode?: Node | number | null,
     sigma?: number,
     options?: GaussianBlurNodeOptions,
-) => ShaderNodeObject<GaussianBlurNode>;
+) => GaussianBlurNode;
 
 /**
  * @deprecated "premultipliedGaussianBlur()" is deprecated. Use "gaussianBlur()" with "premultipliedAlpha: true" option instead.
@@ -52,4 +51,4 @@ export const premultipliedGaussianBlur: (
     node: Node,
     directionNode?: Node | number | null,
     sigma?: number,
-) => ShaderNodeObject<GaussianBlurNode>;
+) => GaussianBlurNode;

three/examples/jsm/tsl/display/LensflareNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, UniformNode, Vector3 } from "three/webgpu";
 
 interface LensflareNodeParams {
@@ -13,11 +12,11 @@ interface LensflareNodeParams {
 declare class LensflareNode extends TempNode {
     textureNode: TextureNode;
 
-    ghostTintNode: ShaderNodeObject<UniformNode<Vector3>>;
-    thresholdNode: ShaderNodeObject<UniformNode<number>>;
-    ghostSamplesNode: ShaderNodeObject<UniformNode<number>>;
-    ghostSpacingNode: ShaderNodeObject<UniformNode<number>>;
-    ghostAttenuationFactorNode: ShaderNodeObject<UniformNode<number>>;
+    ghostTintNode: UniformNode<Vector3>;
+    thresholdNode: UniformNode<number>;
+    ghostSamplesNode: UniformNode<number>;
+    ghostSpacingNode: UniformNode<number>;
+    ghostAttenuationFactorNode: UniformNode<number>;
     downSampleRatio: number;
 
     constructor(textureNode: TextureNode, params?: LensflareNodeParams);
@@ -32,4 +31,4 @@ export default LensflareNode;
 export const lensflare: (
     inputNode: Node,
     params?: LensflareNodeParams,
-) => ShaderNodeObject<LensflareNode>;
+) => LensflareNode;

three/examples/jsm/tsl/display/Lut3DNode.d.ts

@@ -1,10 +1,9 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Data3DTexture, Node, TempNode, Texture3DNode, UniformNode } from "three/webgpu";
 
 declare class Lut3DNode extends TempNode {
     inputNode: Node;
     lutNode: Texture3DNode;
-    size: ShaderNodeObject<UniformNode<number>>;
+    size: UniformNode<number>;
     intensityNode: UniformNode<number>;
 
     constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
@@ -17,4 +16,4 @@ export const lut3D: (
     lut: Node,
     size: number,
     intensity: Node,
-) => ShaderNodeObject<Lut3DNode>;
+) => Lut3DNode;

three/examples/jsm/tsl/display/MotionBlur.d.ts

@@ -1,8 +1,7 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
 export const motionBlur: (
     inputNode: Node,
     velocity: Node,
     numSamples?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;