@types/three 0.179.0 → 0.181.0

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class OutputStructNode extends Node {
@@ -9,4 +8,4 @@ export default class OutputStructNode extends Node {
     constructor(...members: Node[]);
 }
 
-export const outputStruct: (...members: Node[]) => ShaderNodeObject<OutputStructNode>;
+export const outputStruct: (...members: Node[]) => OutputStructNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import PropertyNode from "./PropertyNode.js";
 
 declare class ParameterNode extends PropertyNode {
@@ -9,4 +8,4 @@ declare class ParameterNode extends PropertyNode {
 
 export default ParameterNode;
 
-export const parameter: (type: string, name?: string | null) => ShaderNodeObject<ParameterNode>;
+export const parameter: (type: string, name?: string | null) => ParameterNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class PropertyNode extends Node {
@@ -10,34 +9,34 @@ export default class PropertyNode extends Node {
     constructor(nodeType?: string | null, name?: string | null, varying?: boolean);
 }
 
-export const property: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
-export const varyingProperty: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+export const property: (type?: string | null, name?: string | null) => PropertyNode;
+export const varyingProperty: (type?: string | null, name?: string | null) => PropertyNode;
 
-export const diffuseColor: ShaderNodeObject<PropertyNode>;
-export const emissive: ShaderNodeObject<PropertyNode>;
-export const roughness: ShaderNodeObject<PropertyNode>;
-export const metalness: ShaderNodeObject<PropertyNode>;
-export const clearcoat: ShaderNodeObject<PropertyNode>;
-export const clearcoatRoughness: ShaderNodeObject<PropertyNode>;
-export const sheen: ShaderNodeObject<PropertyNode>;
-export const sheenRoughness: ShaderNodeObject<PropertyNode>;
-export const iridescence: ShaderNodeObject<PropertyNode>;
-export const iridescenceIOR: ShaderNodeObject<PropertyNode>;
-export const iridescenceThickness: ShaderNodeObject<PropertyNode>;
-export const alphaT: ShaderNodeObject<PropertyNode>;
-export const anisotropy: ShaderNodeObject<PropertyNode>;
-export const anisotropyT: ShaderNodeObject<PropertyNode>;
-export const anisotropyB: ShaderNodeObject<PropertyNode>;
-export const specularColor: ShaderNodeObject<PropertyNode>;
-export const specularF90: ShaderNodeObject<PropertyNode>;
-export const shininess: ShaderNodeObject<PropertyNode>;
-export const output: ShaderNodeObject<PropertyNode>;
-export const dashSize: ShaderNodeObject<PropertyNode>;
-export const gapSize: ShaderNodeObject<PropertyNode>;
-export const pointWidth: ShaderNodeObject<PropertyNode>;
-export const ior: ShaderNodeObject<PropertyNode>;
-export const transmission: ShaderNodeObject<PropertyNode>;
-export const thickness: ShaderNodeObject<PropertyNode>;
-export const attenuationDistance: ShaderNodeObject<PropertyNode>;
-export const attenuationColor: ShaderNodeObject<PropertyNode>;
-export const dispersion: ShaderNodeObject<PropertyNode>;
+export const diffuseColor: PropertyNode;
+export const emissive: PropertyNode;
+export const roughness: PropertyNode;
+export const metalness: PropertyNode;
+export const clearcoat: PropertyNode;
+export const clearcoatRoughness: PropertyNode;
+export const sheen: PropertyNode;
+export const sheenRoughness: PropertyNode;
+export const iridescence: PropertyNode;
+export const iridescenceIOR: PropertyNode;
+export const iridescenceThickness: PropertyNode;
+export const alphaT: PropertyNode;
+export const anisotropy: PropertyNode;
+export const anisotropyT: PropertyNode;
+export const anisotropyB: PropertyNode;
+export const specularColor: PropertyNode;
+export const specularF90: PropertyNode;
+export const shininess: PropertyNode;
+export const output: PropertyNode;
+export const dashSize: PropertyNode;
+export const gapSize: PropertyNode;
+export const pointWidth: PropertyNode;
+export const ior: PropertyNode;
+export const transmission: PropertyNode;
+export const thickness: PropertyNode;
+export const attenuationDistance: PropertyNode;
+export const attenuationColor: PropertyNode;
+export const dispersion: PropertyNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 declare class StackNode extends Node {
@@ -8,8 +7,6 @@ declare class StackNode extends Node {
 
     constructor();
 
-    add(node: Node): this;
-
     If(boolNode: Node, method: () => void): this;
 
     ElseIf(boolNode: Node, method: () => void): this;
@@ -25,4 +22,4 @@ declare class StackNode extends Node {
 
 export default StackNode;
 
-export const stack: () => ShaderNodeObject<StackNode>;
+export const stack: () => StackNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import StructTypeNode, { MembersLayout } from "./StructTypeNode.js";
 
@@ -11,9 +10,9 @@ declare class StructNode extends Node {
 export default StructNode;
 
 export interface Struct {
-    (): ShaderNodeObject<StructNode>;
-    (values: Node[]): ShaderNodeObject<StructNode>;
-    (...values: Node[]): ShaderNodeObject<StructNode>;
+    (): StructNode;
+    (values: Node[]): StructNode;
+    (...values: Node[]): StructNode;
     layout: StructTypeNode;
     isStruct: true;
 }

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 declare class SubBuildNode extends Node {
@@ -12,4 +11,4 @@ declare class SubBuildNode extends Node {
 
 export default SubBuildNode;
 
-export const subBuild: (node: Node, name: string, type?: string | null) => ShaderNodeObject<SubBuildNode>;
+export const subBuild: (node: Node, name: string, type?: string | null) => SubBuildNode;

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

@@ -27,7 +27,7 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
      * @param {string} name - The name of the uniform.
      * @return {UniformNode} A reference to this node.
      */
-    setName(name: string): this;
+    setName: (name: string) => this;
     /**
      * Sets the {@link UniformNode#name} property.
      *
@@ -35,7 +35,7 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
      * @param {string} name - The name of the uniform.
      * @return {UniformNode} A reference to this node.
      */
-    label(name: string): this;
+    label: (name: string) => this;
     /**
      * Sets the {@link UniformNode#groupNode} property.
      *
@@ -67,11 +67,8 @@ export default UniformNode;
  *
  * @tsl
  * @function
- * @param {any} arg1 - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
- * @param {string} [arg2] - The node type. If no explicit type is defined, the node tries to derive the type from its value.
+ * @param {any|string} value - The value of this uniform or your type. Usually a JS primitive or three.js object (vector, matrix, color, texture).
+ * @param {string} [type] - The node type. If no explicit type is defined, the node tries to derive the type from its value.
  * @returns {UniformNode}
  */
-export declare const uniform: <TValue>(
-    arg1: InputNode<TValue> | TValue,
-    arg2?: Node | string,
-) => import("../tsl/TSLCore.js").ShaderNodeObject<UniformNode<TValue>>;
+export declare const uniform: <TValue>(value: InputNode<TValue> | TValue, type?: Node | string) => UniformNode<TValue>;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 declare class VarNode extends Node {
@@ -19,30 +18,21 @@ declare class VarNode extends Node {
 
 export default VarNode;
 
-export const Var: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
+export const Var: (node: Node, name?: string | null) => VarNode;
 
-export const Const: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
+export const Const: (node: Node, name?: string | null) => VarNode;
 
 export const VarIntent: (node: Node) => Node;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        toVar: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
-        toConst: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
-        toVarIntent: (node: Node) => Node;
-    }
-}
+declare module "../Nodes.js" {
+    interface Node {
+        toVar: (name?: string | null) => VarNode;
+        toVarAssign: (name?: string | null) => this;
+
+        toConst: (name?: string | null) => VarNode;
+        toConstAssign: (name?: string | null) => this;
 
-/**
- * @deprecated Use ".toVar()" instead.
- */
-export const temp: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        /**
-         * @deprecated Use ".toVar()" instead.
-         */
-        temp: typeof temp;
+        toVarIntent: () => Node;
+        toVarIntentAssign: () => this;
     }
 }

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

@@ -1,5 +1,4 @@
 import { InterpolationSamplingMode, InterpolationSamplingType } from "../../constants.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeVarying from "./NodeVarying.js";
@@ -18,22 +17,25 @@ export default class VaryingNode extends Node {
     setupVarying(builder: NodeBuilder): NodeVarying;
 }
 
-export const varying: (node: Node, name?: string) => ShaderNodeObject<VaryingNode>;
+export const varying: (node: Node, name?: string) => VaryingNode;
 
-export const vertexStage: (node: Node) => ShaderNodeObject<VaryingNode>;
+export const vertexStage: (node: Node) => VaryingNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        toVarying: typeof varying;
-        toVertexStage: typeof vertexStage;
+declare module "../Nodes.js" {
+    interface Node {
+        toVarying: (name?: string) => VaryingNode;
+        toVaryingAssign: (name?: string) => this;
+
+        toVertexStage: () => VaryingNode;
+        toVertexStageAssign: () => this;
 
         /**
-         * @deprecated .varying() has been renamed to .toVarying().
+         * @deprecated .vertexStage() has been renamed to .toVertexStage().
          */
-        varying: typeof varying;
+        vertexStage: () => VaryingNode;
         /**
          * @deprecated .vertexStage() has been renamed to .toVertexStage().
          */
-        vertexStage: typeof vertexStage;
+        vertexStageAssign: () => this;
     }
 }

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

@@ -1,36 +1,35 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const blendBurn: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendBurn: (base: Node, blend: Node) => Node;
 
-export const blendDodge: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendDodge: (base: Node, blend: Node) => Node;
 
-export const blendScreen: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendScreen: (base: Node, blend: Node) => Node;
 
-export const blendOverlay: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendOverlay: (base: Node, blend: Node) => Node;
 
-export const blendColor: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendColor: (base: Node, blend: Node) => Node;
 
-export const premultiplyAlpha: (color: Node) => ShaderNodeObject<Node>;
+export const premultiplyAlpha: (color: Node) => Node;
 
-export const unpremultiplyAlpha: (color: Node) => ShaderNodeObject<Node>;
+export const unpremultiplyAlpha: (color: Node) => Node;
 
 /**
  * @deprecated
  */
-export const burn: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const burn: (base: Node, blend: Node) => Node;
 
 /**
  * @deprecated
  */
-export const dodge: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const dodge: (base: Node, blend: Node) => Node;
 
 /**
  * @deprecated
  */
-export const screen: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const screen: (base: Node, blend: Node) => Node;
 
 /**
  * @deprecated
  */
-export const overlay: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const overlay: (base: Node, blend: Node) => Node;

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

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class BumpMapNode extends TempNode {
     textureNode: Node;
@@ -14,4 +13,4 @@ export default BumpMapNode;
 export const bumpMap: (
     textureNode: Node,
     scaleNode?: Node | null,
-) => ShaderNodeObject<BumpMapNode>;
+) => BumpMapNode;

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

@@ -1,30 +1,29 @@
 import Node from "../core/Node.js";
 import MathNode from "../math/MathNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const grayscale: (color: Node) => ShaderNodeObject<Node>;
+export const grayscale: (color: Node) => Node;
 
 export const saturation: (
     color: Node,
     adjustment?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const vibrance: (
     color: Node,
     adjustment?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const hue: (
     color: Node,
     adjustment?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const luminance: (
     color: Node,
     luminanceCoefficients?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 
-export const threshold: (color: Node, thershold: Node) => ShaderNodeObject<MathNode>;
+export const threshold: (color: Node, thershold: Node) => MathNode;
 
 /**
  * Color Decision List (CDL) v1.2
@@ -53,4 +52,4 @@ export const cdl: (
     power?: Node,
     saturation?: Node,
     luminanceCoefficients?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;

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

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const sRGBTransferEOTF: (color: Node) => ShaderNodeObject<Node>;
+export const sRGBTransferEOTF: (color: Node) => Node;
 
-export const sRGBTransferOETF: (color: Node) => ShaderNodeObject<Node>;
+export const sRGBTransferOETF: (color: Node) => Node;

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

@@ -2,7 +2,6 @@ import { LinearSRGBColorSpace, SRGBColorSpace } from "../../constants.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type WorkingOrOutputColorSpace = "WorkingColorSpace" | "OutputColorSpace";
 
@@ -30,21 +29,32 @@ export default class ColorSpaceNode extends TempNode {
 export const workingToColorSpace: (
     node: Node,
     targetColorSpace: string,
-) => ShaderNodeObject<ColorSpaceNode>;
+) => ColorSpaceNode;
 export const colorSpaceToWorking: (
     node: Node,
     sourceColorSpace: string,
-) => ShaderNodeObject<ColorSpaceNode>;
+) => ColorSpaceNode;
 
 export const convertColorSpace: (
     node: Node,
     sourceColorSpace: string,
     targetColorSpace: string,
-) => ShaderNodeObject<ColorSpaceNode>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        workingToColorSpace: typeof workingToColorSpace;
-        colorSpaceToWorking: typeof colorSpaceToWorking;
+) => ColorSpaceNode;
+
+declare module "../Nodes.js" {
+    interface Node {
+        workingToColorSpace: (
+            targetColorSpace: string,
+        ) => ColorSpaceNode;
+        workingToColorSpaceAssign: (
+            targetColorSpace: string,
+        ) => this;
+
+        colorSpaceToWorking: (
+            sourceColorSpace: string,
+        ) => ColorSpaceNode;
+        colorSpaceToWorkingAssign: (
+            sourceColorSpace: string,
+        ) => this;
     }
 }

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class FrontFacingNode extends Node {
     isFrontFacingNode: true;
@@ -8,6 +7,6 @@ declare class FrontFacingNode extends Node {
 
 export default FrontFacingNode;
 
-export const frontFacing: ShaderNodeObject<FrontFacingNode>;
-export const faceDirection: ShaderNodeObject<Node>;
-export const directionToFaceDirection: (direction: Node) => ShaderNodeObject<Node>;
+export const frontFacing: FrontFacingNode;
+export const faceDirection: Node;
+export const directionToFaceDirection: (direction: Node) => Node;

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

@@ -1,7 +1,6 @@
 import { NormalMapTypes } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class NormalMapNode extends TempNode {
     node: Node;
@@ -14,4 +13,4 @@ declare class NormalMapNode extends TempNode {
 
 export default NormalMapNode;
 
-export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
+export const normalMap: (node: Node, scaleNode?: Node) => NormalMapNode;

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

@@ -1,15 +1,14 @@
 import { Camera } from "../../cameras/Camera.js";
 import { Layers } from "../../core/Layers.js";
+import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
 import { Vector4 } from "../../math/Vector4.js";
 import Renderer from "../../renderers/common/Renderer.js";
-import { Scene } from "../../scenes/Scene.js";
 import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
 import MRTNode from "../core/MRTNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class PassTextureNode extends TextureNode {
     passNode: PassNode;
@@ -28,17 +27,27 @@ declare class PassMultipleTextureNode extends PassTextureNode {
 
 declare class PassNode extends TempNode {
     scope: PassNodeScope;
-    scene: Scene;
+    scene: Object3D;
     camera: Camera;
 
     renderTarget: RenderTarget;
 
     readonly isPassNode: true;
 
-    constructor(scope: PassNodeScope, scene: Scene, camera: Camera, options?: RenderTargetOptions);
+    constructor(scope: PassNodeScope, scene: Object3D, camera: Camera, options?: RenderTargetOptions);
 
+    setResolutionScale(resolution: number): this;
+
+    getResolutionScale(): number;
+
+    /**
+     * @deprecated Use {@link PassNode#setResolutionScale `setResolutionScale()`} instead.
+     */
     setResolution(resolution: number): this;
 
+    /**
+     * @deprecated Use {@link PassNode#getResolutionScale `getResolutionScale()`} instead.
+     */
     getResolution(): number;
 
     setLayers(layers: Layers): this;
@@ -55,13 +64,13 @@ declare class PassNode extends TempNode {
 
     toggleTexture(name: string): void;
 
-    getTextureNode(name?: string): ShaderNodeObject<TextureNode>;
+    getTextureNode(name?: string): TextureNode;
 
-    getPreviousTextureNode(name?: string): ShaderNodeObject<Node>;
+    getPreviousTextureNode(name?: string): Node;
 
-    getViewZNode(name?: string): ShaderNodeObject<Node>;
+    getViewZNode(name?: string): Node;
 
-    getLinearDepthNode(name?: string): ShaderNodeObject<Node>;
+    getLinearDepthNode(name?: string): Node;
 
     compileAsync(renderer: Renderer): Promise<void>;
 
@@ -85,6 +94,6 @@ export type PassNodeScope = typeof PassNode.COLOR | typeof PassNode.DEPTH;
 
 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, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;
+export const pass: (scene: Object3D, camera: Camera, options?: RenderTargetOptions) => PassNode;
+export const passTexture: (pass: PassNode, texture: Texture) => PassTextureNode;
+export const depthPass: (scene: Object3D, camera: Camera, options?: RenderTargetOptions) => PassNode;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class PosterizeNode extends Node {
     sourceNode: Node;
@@ -11,4 +10,4 @@ export default class PosterizeNode extends Node {
 export const posterize: (
     sourceNode: Node,
     stepsNode: Node | number,
-) => ShaderNodeObject<PosterizeNode>;
+) => PosterizeNode;

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

@@ -1,11 +1,9 @@
 import { ToneMapping } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class RenderOutputNode extends TempNode {
     colorNode: Node;
-    toneMapping: ToneMapping | null;
     outputColorSpace: string | null;
 
     readonly isRenderOutput: true;
@@ -19,10 +17,17 @@ export const renderOutput: (
     color: Node,
     toneMapping?: ToneMapping | null,
     outputColorSpace?: string | null,
-) => ShaderNodeObject<RenderOutputNode>;
+) => RenderOutputNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        renderOutput: typeof renderOutput;
+declare module "../Nodes.js" {
+    interface Node {
+        renderOutput: (
+            toneMapping?: ToneMapping | null,
+            outputColorSpace?: string | null,
+        ) => RenderOutputNode;
+        renderOutputAssign: (
+            toneMapping?: ToneMapping | null,
+            outputColorSpace?: string | null,
+        ) => this;
     }
 }

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

@@ -1,11 +1,11 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type ScreenNodeScope =
     | typeof ScreenNode.COORDINATE
     | typeof ScreenNode.VIEWPORT
     | typeof ScreenNode.SIZE
-    | typeof ScreenNode.UV;
+    | typeof ScreenNode.UV
+    | typeof ScreenNode.DPR;
 
 declare class ScreenNode extends Node {
     scope: ScreenNodeScope;
@@ -18,26 +18,28 @@ declare class ScreenNode extends Node {
     static VIEWPORT: "viewport";
     static SIZE: "size";
     static UV: "uv";
+    static DPR: "dpr";
 }
 
 export default ScreenNode;
 
 // Screen
 
-export const screenUV: ShaderNodeObject<ScreenNode>;
-export const screenSize: ShaderNodeObject<ScreenNode>;
-export const screenCoordinate: ShaderNodeObject<ScreenNode>;
+export const screenDPR: ScreenNode;
+export const screenUV: ScreenNode;
+export const screenSize: ScreenNode;
+export const screenCoordinate: ScreenNode;
 
 // Viewport
 
-export const viewport: ShaderNodeObject<ScreenNode>;
-export const viewportSize: ShaderNodeObject<Node>;
-export const viewportCoordinate: ShaderNodeObject<Node>;
-export const viewportUV: ShaderNodeObject<Node>;
+export const viewport: ScreenNode;
+export const viewportSize: Node;
+export const viewportCoordinate: Node;
+export const viewportUV: Node;
 
 // Deprecated
 
 /**
  * @deprecated "viewportResolution" is deprecated. Use "screenSize" instead.
  */
-export const viewportResolution: ShaderNodeObject<ScreenNode>;
+export const viewportResolution: ScreenNode;