@types/three 0.181.0 → 0.183.0

three/examples/jsm/postprocessing/RenderPass.d.ts

@@ -2,15 +2,7 @@ import { Camera, Color, Material, Scene } from "three";
 
 import { Pass } from "./Pass.js";
 
-export class RenderPass extends Pass {
-    constructor(
-        scene: Scene,
-        camera: Camera,
-        overrideMaterial?: Material | null,
-        clearColor?: Color | null,
-        clearAlpha?: number | null,
-    );
-
+declare class RenderPass extends Pass {
     scene: Scene;
     camera: Camera;
 
@@ -18,6 +10,19 @@ export class RenderPass extends Pass {
 
     clearColor: Color | null;
     clearAlpha: number | null;
-
+    clear: boolean;
     clearDepth: boolean;
+    needsSwap: boolean;
+
+    readonly isRenderPass: true;
+
+    constructor(
+        scene: Scene,
+        camera: Camera,
+        overrideMaterial?: Material | null,
+        clearColor?: Color | null,
+        clearAlpha?: number | null,
+    );
 }
+
+export { RenderPass };

three/examples/jsm/postprocessing/UnrealBloomPass.d.ts

@@ -3,12 +3,13 @@ import { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRender
 import { FullScreenQuad, Pass } from "./Pass.js";
 
 export class UnrealBloomPass extends Pass {
-    constructor(resolution: Vector2, strength: number, radius: number, threshold: number);
-    resolution: Vector2;
     strength: number;
     radius: number;
     threshold: number;
+    resolution: Vector2;
     clearColor: Color;
+    needsUpdate: boolean;
+
     renderTargetsHorizontal: WebGLRenderTarget[];
     renderTargetsVertical: WebGLRenderTarget[];
     nMips: number;
@@ -20,12 +21,6 @@ export class UnrealBloomPass extends Pass {
     bloomTintColors: Vector3[];
     copyUniforms: object;
     blendMaterial: ShaderMaterial;
-    oldClearColor: Color;
-    oldClearAlpha: number;
-    basic: MeshBasicMaterial;
-    fsQuad: FullScreenQuad;
 
-    dispose(): void;
-    getSeparableBlurMaterial(): ShaderMaterial;
-    getCompositeMaterial(): ShaderMaterial;
+    constructor(resolution: Vector2, strength: number, radius: number, threshold: number);
 }

three/examples/jsm/transpiler/AST.d.ts

@@ -41,6 +41,7 @@ export type Statement =
     | While
     | Switch
     | SwitchCase
+    | StructMember
     | null;
 
 export class VariableDeclaration {
@@ -273,3 +274,19 @@ export class SwitchCase {
     isDefault: boolean;
     readonly isSwitchCase: true;
 }
+
+export class StructMember {
+    type: string;
+    name: string;
+    readonly isStructMember: true;
+
+    constructor(type: string, name: string);
+}
+
+export class StructDefinition {
+    name: string;
+    members: StructMember[];
+    readonly isStructDefinition: true;
+
+    constructor(name: string, members?: StructMember[]);
+}

three/examples/jsm/transpiler/TSLEncoder.d.ts

@@ -6,6 +6,7 @@ import {
     FunctionDeclaration,
     Program,
     Statement,
+    StructDefinition,
     Switch,
     Ternary,
     Uniform,
@@ -38,6 +39,7 @@ export default class TSLEncoder {
     emitWhile(node: While): string;
     emitVariables(node: VariableDeclaration, isRoot?: boolean): string;
     emitVarying(node: Varying): string;
+    emitStructDefinition(node: StructDefinition): string;
     emitOverloadingFunction(nodes: FunctionDeclaration[]): string;
     emitFunction(node: FunctionDeclaration): string;
     setLastStatement(statement: Statement | null): void;

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

@@ -1,12 +1,42 @@
 import { Camera, Scene } from "three/webgpu";
 import StereoCompositePassNode from "./StereoCompositePassNode.js";
 
+declare const AnaglyphAlgorithm: {
+    TRUE: "true";
+    GREY: "grey";
+    COLOUR: "colour";
+    HALF_COLOUR: "halfColour";
+    DUBOIS: "dubois";
+    OPTIMISED: "optimised";
+    COMPROMISE: "compromise";
+};
+type AnaglyphAlgorithm = (typeof AnaglyphAlgorithm)[keyof typeof AnaglyphAlgorithm];
+
+declare const AnaglyphColorMode: {
+    RED_CYAN: "redCyan";
+    MAGENTA_CYAN: "magentaCyan";
+    MAGENTA_GREEN: "magentaGreen";
+};
+type AnaglyphColorMode = (typeof AnaglyphColorMode)[keyof typeof AnaglyphColorMode];
+
 declare class AnaglyphPassNode extends StereoCompositePassNode {
     readonly isAnaglyphPassNode: true;
 
+    eyeSep: number;
+
+    planeDistance: number;
+
     constructor(scene: Scene, camera: Camera);
+
+    get algorithm(): AnaglyphAlgorithm;
+    set algorithm(algorithm: AnaglyphAlgorithm);
+
+    get colorMode(): AnaglyphColorMode;
+    set colorMode(color: AnaglyphColorMode);
 }
 
 export default AnaglyphPassNode;
 
+export { AnaglyphAlgorithm, AnaglyphColorMode };
+
 export const anaglyphPass: (scene: Scene, camera: Camera) => AnaglyphPassNode;

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

@@ -1,6 +1,6 @@
 import { Node, TempNode, Vector2 } from "three/webgpu";
 
-export default class AnamorphicNode extends TempNode {
+export default class AnamorphicNode extends TempNode<"vec4"> {
     textureNode: Node;
     thresholdNode: Node;
     scaleNode: Node;

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

@@ -0,0 +1,27 @@
+import { Node, TempNode, TextureNode } from "three/webgpu";
+
+declare class BilateralBlurNode extends TempNode<"vec4"> {
+    textureNode: TextureNode;
+    directionNode: Node<"vec2"> | Node<"float"> | null;
+    sigma: number;
+    sigmaColor: number;
+
+    constructor(
+        textureNode: TextureNode,
+        directionNode?: Node<"vec2"> | Node<"float"> | null,
+        sigma?: number,
+        sigmaColor?: number,
+    );
+
+    setSize(width: number, height: number): void;
+    getTextureNode(): TextureNode;
+}
+
+export default BilateralBlurNode;
+
+export const bilateralBlur: (
+    node: Node<"vec4">,
+    directionNode?: Node<"vec2"> | Node<"float">,
+    sigma?: number,
+    sigmaColor?: number,
+) => BilateralBlurNode;

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

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

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

@@ -1,12 +1,12 @@
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
-declare class BloomNode extends TempNode {
+declare class BloomNode extends TempNode<"vec4"> {
     inputNode: Node;
-    strength: UniformNode<number>;
-    radius: UniformNode<number>;
-    threshold: UniformNode<number>;
+    strength: UniformNode<"float", number>;
+    radius: UniformNode<"float", number>;
+    threshold: UniformNode<"float", number>;
 
-    smoothWidth: UniformNode<number>;
+    smoothWidth: UniformNode<"float", number>;
 
     constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
 

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

@@ -0,0 +1,22 @@
+import { Node } from "three/webgpu";
+
+export const barrelUV: (curvature?: Node<"float">, coord?: Node<"vec2">) => Node<"vec2">;
+
+export const barrelMast: (coord: Node<"vec2">) => Node<"float">;
+
+export const colorBleeding: (color: Node, amount?: Node<"float">) => Node<"vec3">;
+
+export const scanlines: (
+    color: Node<"vec3">,
+    intensity?: Node<"float">,
+    count?: Node<"float">,
+    speed?: Node<"float">,
+    coord?: Node<"vec2">,
+) => Node<"vec3">;
+
+export const vignette: (
+    color: Node<"vec3">,
+    intensity?: Node<"float">,
+    smoothness?: Node<"float"> | number,
+    coord?: Node<"vec2">,
+) => Node<"vec3">;

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

@@ -7,11 +7,11 @@ declare class DenoiseNode extends TempNode {
 
     noiseNode: Node;
 
-    lumaPhi: UniformNode<number>;
-    depthPhi: UniformNode<number>;
-    normalPhi: UniformNode<number>;
-    radius: UniformNode<number>;
-    index: UniformNode<number>;
+    lumaPhi: UniformNode<"float", number>;
+    depthPhi: UniformNode<"float", number>;
+    normalPhi: UniformNode<"float", number>;
+    radius: UniformNode<"float", number>;
+    index: UniformNode<"float", number>;
 
     constructor(textureNode: Node, depthNode: Node, normalNode: Node, noiseNode: Node, camera: Camera);
 }

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

@@ -1,19 +1,17 @@
-import { Node, TempNode, UniformNode, Vector2 } from "three/webgpu";
+import { Node, TempNode, UniformNode } from "three/webgpu";
 
 declare class DotScreenNode extends TempNode {
     inputNode: Node;
-    center: UniformNode<Vector2>;
-    angle: UniformNode<number>;
-    scale: UniformNode<number>;
+    angle: UniformNode<"float", number>;
+    scale: UniformNode<"float", number>;
 
-    constructor(inputNode: Node, center?: Vector2, angle?: number, scale?: number);
+    constructor(inputNode: Node, angle?: number, scale?: number);
 }
 
 export default DotScreenNode;
 
 export const dotScreen: (
     node: Node,
-    center?: Vector2,
     angle?: number,
     scale?: number,
 ) => DotScreenNode;

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

@@ -1,18 +1,18 @@
 import { Camera, Node, TempNode, TextureNode, UniformNode, Vector2 } from "three/webgpu";
 
-declare class GTAONode extends TempNode {
+declare class GTAONode extends TempNode<"float"> {
     depthNode: Node;
     normalNode: Node;
 
     resolutionScale: number;
 
-    radius: UniformNode<number>;
-    resolution: UniformNode<Vector2>;
-    thickness: UniformNode<number>;
-    distanceExponent: UniformNode<number>;
-    distanceFallOff: UniformNode<number>;
-    scale: UniformNode<number>;
-    samples: UniformNode<number>;
+    radius: UniformNode<"float", number>;
+    resolution: UniformNode<"vec2", Vector2>;
+    thickness: UniformNode<"float", number>;
+    distanceExponent: UniformNode<"float", number>;
+    distanceFallOff: UniformNode<"float", number>;
+    scale: UniformNode<"float", number>;
+    samples: UniformNode<"float", number>;
 
     useTemporalFiltering: boolean;
 

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

@@ -2,10 +2,10 @@ import { Node, TempNode, TextureNode, Vector2 } from "three/webgpu";
 
 export interface GaussianBlurNodeOptions {
     premultipliedAlpha?: boolean | undefined;
-    resolution?: Vector2 | undefined;
+    resolutionScale?: number | undefined;
 }
 
-declare class GaussianBlurNode extends TempNode {
+declare class GaussianBlurNode extends TempNode<"vec4"> {
     textureNode: TextureNode;
     directionNode: Node | null;
     sigma: number;
@@ -14,6 +14,8 @@ declare class GaussianBlurNode extends TempNode {
 
     premultipliedAlpha: boolean;
 
+    readonly isGaussianBlurNode: boolean;
+
     constructor(
         textureNode: TextureNode,
         directionNode?: Node | null,

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

@@ -0,0 +1,20 @@
+import { Camera, DirectionalLight, PointLight, TempNode, TextureNode, UniformNode } from "three/webgpu";
+
+declare class GodraysNode extends TempNode<"vec4"> {
+    depthNode: TextureNode;
+
+    raymarchSteps: UniformNode<"uint", number>;
+    density: UniformNode<"float", number>;
+    maxDensity: UniformNode<"float", number>;
+    distanceAttenuation: UniformNode<"float", number>;
+    resolutionScale: number;
+
+    constructor(depthNode: TextureNode, camera: Camera, light: DirectionalLight | PointLight);
+
+    getTextureNode(): TextureNode;
+    setSize(width: number, height: number): void;
+}
+
+export default GodraysNode;
+
+export const godrays: (depthNode: TextureNode, camera: Camera, light: DirectionalLight | PointLight) => GodraysNode;

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

@@ -1,4 +1,4 @@
-import { Node, TempNode, TextureNode, UniformNode, Vector3 } from "three/webgpu";
+import { Node, TempNode, TextureNode } from "three/webgpu";
 
 interface LensflareNodeParams {
     ghostTint?: Node | undefined;
@@ -12,11 +12,11 @@ interface LensflareNodeParams {
 declare class LensflareNode extends TempNode {
     textureNode: TextureNode;
 
-    ghostTintNode: UniformNode<Vector3>;
-    thresholdNode: UniformNode<number>;
-    ghostSamplesNode: UniformNode<number>;
-    ghostSpacingNode: UniformNode<number>;
-    ghostAttenuationFactorNode: UniformNode<number>;
+    ghostTintNode: Node<"vec3">;
+    thresholdNode: Node<"float">;
+    ghostSamplesNode: Node<"float">;
+    ghostSpacingNode: Node<"float">;
+    ghostAttenuationFactorNode: Node<"float">;
     downSampleRatio: number;
 
     constructor(textureNode: TextureNode, params?: LensflareNodeParams);

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

@@ -1,12 +1,12 @@
-import { Data3DTexture, Node, TempNode, Texture3DNode, UniformNode } from "three/webgpu";
+import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class Lut3DNode extends TempNode {
     inputNode: Node;
-    lutNode: Texture3DNode;
-    size: UniformNode<number>;
-    intensityNode: UniformNode<number>;
+    lutNode: TextureNode;
+    size: UniformNode<"float", number>;
+    intensityNode: Node<"float">;
 
-    constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
+    constructor(inputNode: Node, lutNode: TextureNode, size: number, intensityNode: Node);
 }
 
 export default Lut3DNode;

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

@@ -4,4 +4,4 @@ export const motionBlur: (
     inputNode: Node,
     velocity: Node,
     numSamples?: Node,
-) => Node;
+) => Node<"vec4">;

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

@@ -1,4 +1,4 @@
-import { Camera, Node, Object3D, Scene, TempNode, TextureNode, UniformNode } from "three/webgpu";
+import { Camera, Node, Object3D, Scene, TempNode, TextureNode } from "three/webgpu";
 
 export interface OutlineNodeParams {
     selectedObjects?: Object3D[] | undefined;
@@ -7,19 +7,19 @@ export interface OutlineNodeParams {
     downSampleRatio?: number | undefined;
 }
 
-declare class OutlineNode extends TempNode {
+declare class OutlineNode extends TempNode<"vec4"> {
     scene: Scene;
     camera: Camera;
     selectedObjects: Object3D[];
-    edgeThicknessNode: UniformNode<number>;
-    edgeGlowNode: UniformNode<number>;
+    edgeThicknessNode: Node<"float">;
+    edgeGlowNode: Node<"float">;
     downSampleRatio: number;
 
     constructor(scene: Scene, camera: Camera, params?: OutlineNodeParams);
 
-    get visibleEdge(): Node;
+    get visibleEdge(): Node<"float">;
 
-    get hiddenEdge(): Node;
+    get hiddenEdge(): Node<"float">;
 
     getTextureNode(): TextureNode;
 

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

@@ -1,27 +1,27 @@
-import { Camera, PassNode, Scene, UniformNode } from "three/webgpu";
+import { Camera, Node, PassNode, Scene } from "three/webgpu";
 
 declare class PixelationPassNode extends PassNode {
-    pixelSize: UniformNode<number>;
-    normalEdgeStrength: UniformNode<number>;
-    depthEdgeStrength: UniformNode<number>;
+    pixelSize: Node<"float">;
+    normalEdgeStrength: Node<"float">;
+    depthEdgeStrength: Node<"float">;
 
     readonly isPixelationPassNode: true;
 
     constructor(
         scene: Scene,
         camera: Camera,
-        pixelSize: number,
-        normalEdgeStrength: number,
-        depthEdgeStrength: number,
+        pixelSize: Node,
+        normalEdgeStrength: Node,
+        depthEdgeStrength: Node,
     );
 }
 
 export const pixelationPass: (
     scene: Scene,
     camera: Camera,
-    pixelSize: UniformNode<number>,
-    normalEdgeStrength: UniformNode<number>,
-    depthEdgeStrength: UniformNode<number>,
+    pixelSize: Node | number,
+    normalEdgeStrength: Node | number,
+    depthEdgeStrength: Node | number,
 ) => PixelationPassNode;
 
 export default PixelationPassNode;

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

@@ -2,8 +2,8 @@ import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 export default class RGBShiftNode extends TempNode {
     textureNode: TextureNode;
-    amount: UniformNode<number>;
-    angle: UniformNode<number>;
+    amount: UniformNode<"float", number>;
+    angle: UniformNode<"float", number>;
 
     constructor(textureNode: TextureNode, amount?: number, angle?: number);
 

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

@@ -0,0 +1,17 @@
+import { Camera, Node, PassNode, Scene } from "three/webgpu";
+
+export interface RetroPassNodeOptions {
+    affineDistortion?: Node | null | undefined;
+    filterTextures?: boolean | undefined;
+}
+
+declare class RetroPassNode extends PassNode {
+    affineDistortionNode: Node | null;
+    filterTextures: boolean;
+
+    constructor(scene: Scene, camera: Camera, options?: RetroPassNodeOptions);
+}
+
+export default RetroPassNode;
+
+export const retroPass: (scene: Scene, camera: Camera, options?: RetroPassNodeOptions) => RetroPassNode;

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

@@ -8,7 +8,7 @@ declare class SSAAPassNode extends PassNode {
     clearColor: Color;
     clearAlpha: number;
 
-    sampleWeight: UniformNode<number>;
+    sampleWeight: UniformNode<"float", number>;
 
     sampleRenderTarget: RenderTarget | null;
 

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

@@ -1,20 +1,20 @@
 import { Node, PerspectiveCamera, TempNode, UniformNode } from "three/webgpu";
 
-declare class SSGINode extends TempNode {
+declare class SSGINode extends TempNode<"vec4"> {
     beautyNode: Node;
     depthNode: Node;
     normalNode: Node;
 
-    sliceCount: UniformNode<number>;
-    stepCount: UniformNode<number>;
-    aoIntensity: UniformNode<number>;
-    giIntensity: UniformNode<number>;
-    radius: UniformNode<number>;
-    useScreenSpaceSampling: UniformNode<boolean>;
-    expFactor: UniformNode<number>;
-    thickness: UniformNode<number>;
-    useLinearThickness: UniformNode<boolean>;
-    backfaceLighting: UniformNode<number>;
+    sliceCount: UniformNode<"uint", number>;
+    stepCount: UniformNode<"uint", number>;
+    aoIntensity: UniformNode<"float", number>;
+    giIntensity: UniformNode<"float", number>;
+    radius: UniformNode<"float", number>;
+    useScreenSpaceSampling: UniformNode<"bool", boolean>;
+    expFactor: UniformNode<"float", number>;
+    thickness: UniformNode<"float", number>;
+    useLinearThickness: UniformNode<"bool", boolean>;
+    backfaceLighting: UniformNode<"float", number>;
     useTemporalFiltering: boolean;
 
     constructor(beautyNode: Node, depthNode: Node, normalNode: Node, camera: PerspectiveCamera);

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

@@ -1,6 +1,6 @@
 import { Camera, Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
-declare class SSRNode extends TempNode {
+declare class SSRNode extends TempNode<"vec4"> {
     colorNode: Node;
     depthNode: Node;
     normalNode: Node;
@@ -10,11 +10,11 @@ declare class SSRNode extends TempNode {
 
     resolutionScale: number;
 
-    maxDistance: UniformNode<number>;
-    thickness: UniformNode<number>;
-    opacity: UniformNode<number>;
-    quality: UniformNode<number>;
-    blurQuality: UniformNode<number>;
+    maxDistance: UniformNode<"float", number>;
+    thickness: UniformNode<"float", number>;
+    opacity: UniformNode<"float", number>;
+    quality: UniformNode<"float", number>;
+    blurQuality: UniformNode<"float", number>;
 
     constructor(
         colorNode: Node,

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

@@ -1,16 +1,18 @@
 import { Camera, DirectionalLight, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
-declare class SSSNode extends TempNode {
+declare class SSSNode extends TempNode<"float"> {
     depthNode: TextureNode;
 
-    maxDistance: UniformNode<number>;
-    thickness: UniformNode<number>;
-    shadowIntensity: UniformNode<number>;
-    quality: UniformNode<number>;
+    maxDistance: UniformNode<"float", number>;
+    thickness: UniformNode<"float", number>;
+    shadowIntensity: UniformNode<"float", number>;
+    quality: UniformNode<"float", number>;
     resolutionScale: number;
     useTemporalFiltering: boolean;
 
     constructor(depthNode: TextureNode, camera: Camera, mainLight: DirectionalLight);
+
+    getTextureNode(): TextureNode;
 }
 
 export default SSSNode;

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

@@ -0,0 +1,3 @@
+import { Node } from "three/webgpu";
+
+export const circle: (scale?: Node<"float">, softness?: Node<"float"> | number, coord?: Node<"vec2">) => Node<"float">;

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

@@ -8,6 +8,11 @@ declare class TRAANode extends TempNode {
     velocityNode: TextureNode;
     camera: Camera;
 
+    depthThreshold: number;
+    edgeDepthDiff: number;
+    maxVelocityLength: number;
+    useSubpixelCorrection: boolean;
+
     constructor(beautyNode: TextureNode, depthNode: TextureNode, velocityNode: TextureNode, camera: Camera);
 }
 

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

@@ -25,7 +25,7 @@ export const transition: (
     node: Node,
     nodeB: Node,
     mixTexture: Node,
-    mixRatio: UniformNode<number>,
-    threshold: UniformNode<number>,
-    useTexture: UniformNode<number>,
+    mixRatio: Node | number,
+    threshold: Node | number,
+    useTexture: Node | number,
 ) => TransitionNode;

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

@@ -7,4 +7,4 @@ export interface BoxBlurOptions {
     premultipliedAlpha?: boolean | undefined;
 }
 
-export const boxBlur: (textureNode: Node, options?: BoxBlurOptions) => Node;
+export const boxBlur: (textureNode: Node, options?: BoxBlurOptions) => Node<"vec4">;

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

@@ -0,0 +1,15 @@
+import { Camera, Color, Node } from "three/webgpu";
+
+export interface DepthAwareBlendOptions {
+    blendColor?: Node | Color;
+    edgeRadius?: Node<"int"> | number;
+    edgeStrength?: Node<"float"> | number;
+}
+
+export const depthAwareBlend: (
+    baseNode: Node,
+    blendNode: Node,
+    depthNode: Node,
+    camera: Camera,
+    options?: DepthAwareBlendOptions,
+) => Node<"vec4">;