@types/three 0.159.0 → 0.161.0

three/examples/jsm/nodes/materialx/MaterialXNodes.d.ts

@@ -1,94 +1,103 @@
 import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv.js';
-import { Swizzable } from '../shadernode/ShaderNodeElements.js';
-import { UVNode, MathNode } from '../Nodes.js';
-import { NodeRepresentation } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): Swizzable<MathNode>;
+export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): ShaderNodeObject<MathNode>;
 
 export function mx_ramplr(
     valuel?: NodeRepresentation,
     valuer?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 export function mx_ramptb(
     valuet?: NodeRepresentation,
     valueb?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 
 export function mx_splitlr(
     valuel?: NodeRepresentation,
     valuer?: NodeRepresentation,
     center?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 export function mx_splittb(
     valuet?: NodeRepresentation,
     valueb?: NodeRepresentation,
     center?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 
 export function mx_transform_uv(
     uv_scale?: NodeRepresentation,
     uv_offset?: NodeRepresentation,
-    uv_geo?: Swizzable<UVNode>,
-): Swizzable;
+    uv_geo?: ShaderNodeObject<Node>,
+): ShaderNodeObject<Node>;
 
 export function mx_noise_float(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_noise_vec2(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_noise_vec3(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_noise_vec4(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 
-export function mx_worley_noise_float(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
-export function mx_worley_noise_vec2(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
-export function mx_worley_noise_vec3(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+export function mx_worley_noise_float(
+    texcoord?: ShaderNodeObject<Node>,
+    jitter?: NodeRepresentation,
+): ShaderNodeObject<Node>;
+export function mx_worley_noise_vec2(
+    texcoord?: ShaderNodeObject<Node>,
+    jitter?: NodeRepresentation,
+): ShaderNodeObject<Node>;
+export function mx_worley_noise_vec3(
+    texcoord?: ShaderNodeObject<Node>,
+    jitter?: NodeRepresentation,
+): ShaderNodeObject<Node>;
 
-export function mx_cell_noise_float(texcoord?: Swizzable<UVNode>): Swizzable;
+export function mx_cell_noise_float(texcoord?: ShaderNodeObject<Node>): ShaderNodeObject<Node>;
 
 export function mx_fractal_noise_float(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec2(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec3(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec4(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 
 export { mx_hsvtorgb, mx_rgbtohsv };

three/examples/jsm/nodes/materialx/lib/mx_hsv.d.ts

@@ -1,4 +1,6 @@
-import { Fn, Node, Swizzable } from '../../Nodes.js';
+import Node from '../../core/Node.js';
+import { Fn } from '../../code/FunctionNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
-export function mx_hsvtorgb(...params: Fn<[Node]>): Swizzable;
-export function mx_rgbtohsv(...params: Fn<[Node]>): Swizzable;
+export function mx_hsvtorgb(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_rgbtohsv(...params: Fn<[Node]>): ShaderNodeObject<Node>;

three/examples/jsm/nodes/materialx/lib/mx_noise.d.ts

@@ -1,6 +1,8 @@
-import { Fn, Node, Swizzable } from '../../Nodes.js';
+import Node from '../../core/Node.js';
+import { Fn } from '../../code/FunctionNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
-export function mx_perlin_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_cell_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_worley_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): Swizzable;
+export function mx_perlin_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_cell_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_worley_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): ShaderNodeObject<Node>;

three/examples/jsm/nodes/math/CondNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class CondNode extends Node {
     condNode: Node;
@@ -7,3 +8,15 @@ export default class CondNode extends Node {
 
     constructor(condNode: Node, ifNode: Node, elseNode: Node);
 }
+
+export function cond(
+    condNode: NodeRepresentation,
+    ifNode: NodeRepresentation,
+    elseNode: NodeRepresentation,
+): ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        cond: typeof cond;
+    }
+}

three/examples/jsm/nodes/math/HashNode.d.ts

@@ -0,0 +1,16 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class HashNode extends Node {
+    seedNode: Node;
+
+    constructor(seedNode: Node);
+}
+
+export const hash: (seedNode: NodeRepresentation) => ShaderNodeObject<HashNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        hash: typeof hash;
+    }
+}

three/examples/jsm/nodes/math/MathNode.d.ts

@@ -1,5 +1,6 @@
 import Node from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type MathNodeMethod1 =
     | typeof MathNode.RADIANS
@@ -27,7 +28,11 @@ export type MathNodeMethod1 =
     | typeof MathNode.ONE_MINUS
     | typeof MathNode.DFDX
     | typeof MathNode.DFDY
-    | typeof MathNode.ROUND;
+    | typeof MathNode.ROUND
+    | typeof MathNode.RECIPROCAL
+    | typeof MathNode.TRUNC
+    | typeof MathNode.FWIDTH
+    | typeof MathNode.BITCAST;
 
 export type MathNodeMethod2 =
     | typeof MathNode.ATAN2
@@ -81,6 +86,9 @@ export default class MathNode extends TempNode {
     static DFDY: 'dFdy';
     static ROUND: 'round';
     static RECIPROCAL: 'reciprocal';
+    static TRUNC: 'trunc';
+    static FWIDTH: 'fwidth';
+    static BITCAST: 'bitcast';
 
     // 2 inputs
 
@@ -113,3 +121,134 @@ export default class MathNode extends TempNode {
     constructor(method: MathNodeMethod2, aNode: Node, bNode: Node);
     constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);
 }
+
+export const EPSILON: ShaderNodeObject<Node>;
+export const INFINITY: ShaderNodeObject<Node>;
+export const PI: ShaderNodeObject<Node>;
+export const PI2: ShaderNodeObject<Node>;
+
+type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const radians: Unary;
+export const degrees: Unary;
+export const exp: Unary;
+export const exp2: Unary;
+export const log: Unary;
+export const log2: Unary;
+export const sqrt: Unary;
+export const inverseSqrt: Unary;
+export const floor: Unary;
+export const ceil: Unary;
+export const normalize: Unary;
+export const fract: Unary;
+export const sin: Unary;
+export const cos: Unary;
+export const tan: Unary;
+export const asin: Unary;
+export const acos: Unary;
+export const atan: Unary;
+export const abs: Unary;
+export const sign: Unary;
+export const length: Unary;
+export const negate: Unary;
+export const oneMinus: Unary;
+export const dFdx: Unary;
+export const dFdy: Unary;
+export const round: Unary;
+export const reciprocal: Unary;
+export const trunc: Unary;
+export const fwidth: Unary;
+export const bitcast: 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;
+export const step: Binary;
+export const reflect: Binary;
+export const distance: Binary;
+export const difference: Binary;
+export const dot: Binary;
+export const cross: Binary;
+export const pow: Binary;
+export const pow2: Binary;
+export const pow3: Binary;
+export const pow4: Binary;
+export const transformDirection: Binary;
+
+type Ternary = (a: NodeRepresentation, b: NodeRepresentation, c: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const cbrt: Unary;
+export const lengthSq: Unary;
+export const mix: Ternary;
+export const clamp: (
+    a: NodeRepresentation,
+    b?: NodeRepresentation,
+    c?: NodeRepresentation,
+) => ShaderNodeObject<MathNode>;
+export const saturate: Unary;
+export const refract: Ternary;
+export const smoothstep: Ternary;
+export const faceForward: Ternary;
+
+export const mixElement: Ternary;
+export const smoothstepElement: Ternary;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        radians: typeof radians;
+        degrees: typeof degrees;
+        exp: typeof exp;
+        exp2: typeof exp2;
+        log: typeof log;
+        log2: typeof log2;
+        sqrt: typeof sqrt;
+        inverseSqrt: typeof inverseSqrt;
+        floor: typeof floor;
+        ceil: typeof ceil;
+        normalize: typeof normalize;
+        fract: typeof fract;
+        sin: typeof sin;
+        cos: typeof cos;
+        tan: typeof tan;
+        asin: typeof asin;
+        acos: typeof acos;
+        atan: typeof atan;
+        abs: typeof abs;
+        sign: typeof sign;
+        length: typeof length;
+        lengthSq: typeof lengthSq;
+        negate: typeof negate;
+        oneMinus: typeof oneMinus;
+        dFdx: typeof dFdx;
+        dFdy: typeof dFdy;
+        round: typeof round;
+        reciprocal: typeof reciprocal;
+        trunc: typeof trunc;
+        fwidth: typeof fwidth;
+        atan2: typeof atan2;
+        min: typeof min;
+        max: typeof max;
+        mod: typeof mod;
+        step: typeof step;
+        reflect: typeof reflect;
+        distance: typeof distance;
+        dot: typeof dot;
+        cross: typeof cross;
+        pow: typeof pow;
+        pow2: typeof pow2;
+        pow3: typeof pow3;
+        pow4: typeof pow4;
+        transformDirection: typeof transformDirection;
+        mix: typeof mixElement;
+        clamp: typeof clamp;
+        refract: typeof refract;
+        smoothstep: typeof smoothstepElement;
+        faceForward: typeof faceForward;
+        difference: typeof difference;
+        saturate: typeof saturate;
+        cbrt: typeof cbrt;
+    }
+}

three/examples/jsm/nodes/math/MathUtils.d.ts

@@ -0,0 +1,16 @@
+import { Binary, Ternary } from './MathNode.js';
+
+// remapping functions
+export const parabola: Binary;
+export const gain: Binary;
+export const pcurve: Ternary;
+export const sinc: Binary;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        parabola: typeof parabola;
+        gain: typeof gain;
+        pcurve: typeof pcurve;
+        sinc: typeof sinc;
+    }
+}

three/examples/jsm/nodes/math/OperatorNode.d.ts

@@ -1,8 +1,8 @@
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type OperatorNodeOp =
-    | '='
     | '%'
     | '&'
     | '|'
@@ -29,3 +29,55 @@ export default class OperatorNode extends TempNode {
 
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
+
+type Operator = (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...others: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+
+export const add: Operator;
+export const sub: Operator;
+export const mul: Operator;
+export const div: Operator;
+export const remainder: Operator;
+export const equal: Operator;
+export const lessThan: Operator;
+export const greaterThan: Operator;
+export const lessThanEqual: Operator;
+export const greaterThanEqual: Operator;
+export const and: Operator;
+export const or: Operator;
+export const not: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const xor: Operator;
+export const bitAnd: Operator;
+export const bitNot: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitOr: Operator;
+export const bitXor: Operator;
+export const shiftLeft: Operator;
+export const shiftRight: Operator;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        add: typeof add;
+        sub: typeof sub;
+        mul: typeof mul;
+        div: typeof div;
+        remainder: typeof remainder;
+        equal: typeof equal;
+        lessThan: typeof lessThan;
+        greaterThan: typeof greaterThan;
+        lessThanEqual: typeof lessThanEqual;
+        greaterThanEqual: typeof greaterThanEqual;
+        and: typeof and;
+        or: typeof or;
+        not: typeof not;
+        xor: typeof xor;
+        bitAnd: typeof bitAnd;
+        bitNot: typeof bitNot;
+        bitOr: typeof bitOr;
+        bitXor: typeof bitXor;
+        shiftLeft: typeof shiftLeft;
+        shiftRight: typeof shiftRight;
+    }
+}

three/examples/jsm/nodes/math/TriNoise3D.d.ts

@@ -0,0 +1,12 @@
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+
+export const tri: (x: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const tri3: (p: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const triNoise3D: (
+    p_immutable: NodeRepresentation,
+    spd: NodeRepresentation,
+    time: NodeRepresentation,
+) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/procedural/CheckerNode.d.ts

@@ -1,6 +1,15 @@
 import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class CheckerNode extends TempNode {
     uvNode: Node;
     constructor(uvNode?: Node);
 }
+
+export const checker: (uvNode?: NodeRepresentation) => ShaderNodeObject<CheckerNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        checker: typeof checker;
+    }
+}

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

@@ -1,20 +1,73 @@
-import { ConstNode, Node, NodeBuilder, NodeTypeOption, SwizzleOption } from '../Nodes.js';
-// lot of private typescript magic here
-export {};
+import Node from '../core/Node.js';
+import { AnyObject, NodeTypeOption, SwizzleOption } from '../core/constants.js';
+import ConstNode from '../core/ConstNode.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+
+export interface NodeElements {
+    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;
+
+    element: typeof element;
+    convert: typeof convert;
+}
+
+export function addNodeElement(name: string, nodeElement: unknown): void;
+
 export type Swizzable<T extends Node = Node> = T & {
-    [key in SwizzleOption | number]: Swizzable;
+    [key in SwizzleOption | number]: ShaderNodeObject<Node>;
 };
 
+export type ShaderNodeObject<T extends Node> = T & {
+    [Key in keyof NodeElements]: NodeElements[Key] extends (node: T, ...args: infer Args) => infer R
+        ? (...args: Args) => R
+        : never;
+} & Swizzable<T>;
+
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | Swizzable<T>;
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<T>;
 
 /** anything that can be passed to {@link nodeObject} */
 export type NodeObjectOption = NodeRepresentation | string;
 
-// same logic as in ShaderNodeObject: number,boolean,node->swizzable, otherwise do nothing
-export type NodeObject<T> = T extends Node ? Swizzable<T> : T extends number | boolean ? Swizzable<ConstNode> : T;
+// same logic as in ShaderNodeObject: number,boolean,node->ShaderNodeObject, otherwise do nothing
+export type NodeObject<T> = T extends Node
+    ? ShaderNodeObject<T>
+    : T extends number | boolean
+    ? ShaderNodeObject<ConstNode<number | boolean>>
+    : T;
 
-// opposite of NodeObject: node -> node|swizzable|boolean|number, otherwise do nothing
+// opposite of NodeObject: node -> node|ShaderNodeObject|boolean|number, otherwise do nothing
 type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
 // https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
 export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
@@ -102,11 +155,7 @@ type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<O
 type GetConstructors<T> = ConstructorUnion<OverloadedConstructorsOf<T>>;
 type GetPossibleScopes<T> = ExtractScopes<OverloadedConstructorsOf<T>>;
 
-export type ConvertType = (...params: unknown[]) => Swizzable;
-
-export const ConvertType: {
-    new (type: NodeTypeOption, cacheMap?: Map<unknown, ConstNode>): ConvertType;
-};
+export type ConvertType = (...params: unknown[]) => ShaderNodeObject<Node>;
 
 type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<T[index]> };
 type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
@@ -114,7 +163,16 @@ type ConstructedNode<T> = T extends new (...args: any[]) => infer R ? (R extends
 
 export type NodeOrType = Node | NodeTypeOption;
 
-export function getConstNodeType(value: NodeOrType): NodeTypeOption | null;
+export const getConstNodeType: (value: NodeOrType) => NodeTypeOption | null;
+
+export class ShaderNode<T = {}, R extends Node = Node> {
+    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
+    call: (
+        inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? ShaderNodeObject<Node> | Node : T[key] },
+        builder?: NodeBuilder,
+    ) => ShaderNodeObject<R>;
+}
+
 export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
 export function nodeObjects<T>(obj: T): NodeObjects<T>;
 
@@ -122,35 +180,70 @@ export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): N
 
 export function nodeProxy<T>(
     nodeClass: T,
-): (...params: ProxiedTuple<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
-): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
     factor: NodeObjectOption,
-): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
 
 export function nodeImmutable<T>(
     nodeClass: T,
     ...params: ProxiedTuple<GetConstructors<T>>
-): Swizzable<ConstructedNode<T>>;
+): ShaderNodeObject<ConstructedNode<T>>;
 
-export class ShaderNode<T = {}, R extends Node = Node> {
-    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
-    call: (
-        inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? Swizzable | Node : T[key] },
-        builder?: NodeBuilder,
-    ) => Swizzable<R>;
-}
+export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
+export function tslFn<T extends AnyObject, R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (args: T) => R;
 
-export const cacheMaps: {
-    bool: Map<boolean, ConstNode>;
-    uint: Map<number, ConstNode>;
-    int: Map<number, ConstNode>;
-    float: Map<number, ConstNode>;
-};
+export function append(node: Node): Node;
+
+export const color: ConvertType;
+
+export const float: ConvertType;
+export const int: ConvertType;
+export const uint: ConvertType;
+export const bool: ConvertType;
+
+export const vec2: ConvertType;
+export const ivec2: ConvertType;
+export const uvec2: ConvertType;
+export const bvec2: ConvertType;
+
+export const vec3: ConvertType;
+export const ivec3: ConvertType;
+export const uvec3: ConvertType;
+export const bvec3: ConvertType;
+
+export const vec4: ConvertType;
+export const ivec4: ConvertType;
+export const uvec4: ConvertType;
+export const bvec4: ConvertType;
+
+export const mat2: ConvertType;
+export const imat2: ConvertType;
+export const umat2: ConvertType;
+export const bmat2: ConvertType;
+
+export const mat3: ConvertType;
+export const imat3: ConvertType;
+export const umat3: ConvertType;
+export const bmat3: ConvertType;
+
+export const mat4: ConvertType;
+export const imat4: ConvertType;
+export const umat4: ConvertType;
+export const bmat4: ConvertType;
+
+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>;