@types/three 0.161.2 → 0.163.0

three/examples/jsm/nodes/materials/MeshPhongNodeMaterial.d.ts

@@ -1,12 +1,48 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import { Color, Combine, MeshPhongMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
-import NodeMaterial from "./NodeMaterial.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters, MeshPhongMaterialParameters {
+}
 
 export default class MeshPhongNodeMaterial extends NodeMaterial {
     readonly isMeshPhongNodeMaterial: true;
 
-    shininessNode: Node | null;
-    specularNode: Node | null;
+    shininessNode: ShaderNodeObject<Node> | null;
+    specularNode: ShaderNodeObject<Node> | null;
+
+    // Properties from MeshPhongMaterial
+    readonly isMeshPhongMaterial: true;
+    color: Color;
+    specular: Color;
+    shininess: number;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    emissive: Color;
+    emissiveIntensity: number;
+    emissiveMap: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    specularMap: Texture | null;
+    alphaMap: Texture | null;
+    envMap: Texture | null;
+    combine: Combine;
+    reflectivity: number;
+    refractionRatio: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    flatShading: boolean;
+    metal: boolean;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    constructor(parameters?: MeshPhongNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -1,31 +1,71 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import { Color, MeshPhysicalMaterialParameters, Texture, Vector2 } from "three";
 
 import Node from "../core/Node.js";
-import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import MeshStandardNodeMaterial, { MeshStandardNodeMaterialParameters } from "./MeshStandardNodeMaterial.js";
+
+export interface MeshPhysicalNodeMaterialParameters
+    extends MeshStandardNodeMaterialParameters, MeshPhysicalMaterialParameters
+{
+}
 
 export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     readonly isMeshPhysicalNodeMaterial: true;
 
-    clearcoatNode: Node | null;
-    clearcoatRoughnessNode: Node | null;
-    clearcoatNormalNode: Node | null;
+    clearcoatNode: ShaderNodeObject<Node> | null;
+    clearcoatRoughnessNode: ShaderNodeObject<Node> | null;
+    clearcoatNormalNode: ShaderNodeObject<Node> | null;
+
+    sheenNode: ShaderNodeObject<Node> | null;
+    sheenRoughnessNode: ShaderNodeObject<Node> | null;
 
-    sheenNode: Node | null;
-    sheenRoughnessNode: Node | null;
+    iridescenceNode: ShaderNodeObject<Node> | null;
+    iridescenceIORNode: ShaderNodeObject<Node> | null;
+    iridescenceThicknessNode: ShaderNodeObject<Node> | null;
 
-    iridescenceNode: Node | null;
-    iridescenceIORNode: Node | null;
-    iridescenceThicknessNode: Node | null;
+    iorNode?: ShaderNodeObject<Node> | null;
 
-    iorNode?: Node | null;
+    specularIntensityNode: ShaderNodeObject<Node> | null;
+    specularColorNode: ShaderNodeObject<Node> | null;
 
-    specularIntensityNode: Node | null;
-    specularColorNode: Node | null;
+    transmissionNode: ShaderNodeObject<Node> | null;
+    thicknessNode: ShaderNodeObject<Node> | null;
+    attenuationDistanceNode: ShaderNodeObject<Node> | null;
+    attenuationColorNode: ShaderNodeObject<Node> | null;
 
-    transmissionNode: Node | null;
-    thicknessNode: Node | null;
-    attenuationDistanceNode: Node | null;
-    attenuationColorNode: Node | null;
+    // Properties from MeshPhysicalMaterial
+    readonly isMeshPhysicalMaterial: true;
+    clearcoat: number;
+    clearcoatMap: Texture | null;
+    clearcoatRoughness: number;
+    clearcoatRoughnessMap: Texture | null;
+    clearcoatNormalScale: Vector2;
+    clearcoatNormalMap: Texture | null;
+    reflectivity: number;
+    ior: number;
+    sheen: number;
+    sheenColor: Color;
+    sheenColorMap: Texture | null;
+    sheenRoughness: number;
+    sheenRoughnessMap: Texture | null;
+    transmission: number;
+    transmissionMap: Texture | null;
+    thickness: number;
+    thicknessMap: Texture | null;
+    attenuationDistance: number;
+    attenuationColor: Color;
+    specularIntensity: number;
+    specularColor: Color;
+    specularIntensityMap: Texture | null;
+    specularColorMap: Texture | null;
+    iridescenceMap: Texture | null;
+    iridescenceIOR: number;
+    iridescence: number;
+    iridescenceThicknessRange: [number, number];
+    iridescenceThicknessMap: Texture | null;
+    anisotropy?: number;
+    anisotropyRotation?: number;
+    anisotropyMap?: Texture | null;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    constructor(parameters?: MeshPhysicalNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/MeshSSSNodeMaterial.d.ts

@@ -1,17 +1,17 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
 import ConstNode from "../core/ConstNode.js";
 import Node from "../core/Node.js";
-import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import MeshPhysicalNodeMaterial, { MeshPhysicalNodeMaterialParameters } from "./MeshPhysicalNodeMaterial.js";
 
 export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
-    thicknessColorNode: Node | null;
-    thicknessDistortionNode: ConstNode<number>;
-    thicknessAmbientNode: ConstNode<number>;
-    thicknessAttenuationNode: ConstNode<number>;
-    thicknessPowerNode: ConstNode<number>;
-    thicknessScaleNode: ConstNode<number>;
+    thicknessColorNode: ShaderNodeObject<Node> | null;
+    thicknessDistortionNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessAmbientNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessAttenuationNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessPowerNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessScaleNode: ShaderNodeObject<ConstNode<number>>;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    constructor(parameters?: MeshPhysicalNodeMaterialParameters);
 
     get useSSS(): boolean;
 }

three/examples/jsm/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -1,14 +1,48 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import { Color, MeshStandardMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
-import NodeMaterial from "./NodeMaterial.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshStandardNodeMaterialParameters extends NodeMaterialParameters, MeshStandardMaterialParameters {
+}
 
 export default class MeshStandardNodeMaterial extends NodeMaterial {
     readonly isMeshStandardNodeMaterial: true;
 
-    emissiveNode: Node | null;
+    emissiveNode: ShaderNodeObject<Node> | null;
+
+    metalnessNode: ShaderNodeObject<Node> | null;
+    roughnessNode: ShaderNodeObject<Node> | null;
 
-    metalnessNode: Node | null;
-    roughnessNode: Node | null;
+    // Properties from MeshStandardMaterial
+    readonly isMeshStandardMaterial: true;
+    color: Color;
+    roughness: number;
+    metalness: number;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    emissive: Color;
+    emissiveIntensity: number;
+    emissiveMap: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    roughnessMap: Texture | null;
+    metalnessMap: Texture | null;
+    alphaMap: Texture | null;
+    envMap: Texture | null;
+    envMapIntensity: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    flatShading: boolean;
 
-    constructor(paramters?: ShaderMaterialParameters);
+    constructor(paramters?: MeshStandardNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -2,25 +2,56 @@ import {
     LineBasicMaterial,
     Material,
     MeshBasicMaterial,
+    MeshNormalMaterial,
     MeshPhongMaterial,
     MeshPhysicalMaterial,
     MeshStandardMaterial,
     PointsMaterial,
     ShaderMaterial,
+    ShaderMaterialParameters,
     SpriteMaterial,
-} from "../../../../src/Three.js";
+} from "three";
+import ClippingNode from "../accessors/ClippingNode.js";
 import LightingModel from "../core/LightingModel.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import LightsNode from "../lighting/LightsNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import LineBasicNodeMaterial from "./LineBasicNodeMaterial.js";
 import MeshBasicNodeMaterial from "./MeshBasicNodeMaterial.js";
+import MeshNormalNodeMaterial from "./MeshNormalNodeMaterial.js";
 import MeshPhongNodeMaterial from "./MeshPhongNodeMaterial.js";
 import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
 import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
 import PointsNodeMaterial from "./PointsNodeMaterial.js";
 import SpriteNodeMaterial from "./SpriteNodeMaterial.js";
 
+export interface NodeMaterialParameters extends ShaderMaterialParameters {
+    normals?: boolean | undefined;
+
+    colorSpaced?: boolean | undefined;
+
+    lightsNode?: ShaderNodeObject<LightsNode> | null | undefined;
+    envNode?: ShaderNodeObject<Node> | null | undefined;
+
+    colorNode?: ShaderNodeObject<Node> | null | undefined;
+    normalNode?: ShaderNodeObject<Node> | null | undefined;
+    opacityNode?: ShaderNodeObject<Node> | null | undefined;
+    backdropNode?: ShaderNodeObject<Node> | null | undefined;
+    backdropAlphaNode?: ShaderNodeObject<Node> | null | undefined;
+    alphaTestNode?: ShaderNodeObject<Node> | null | undefined;
+
+    positionNode?: ShaderNodeObject<Node> | null | undefined;
+
+    depthNode?: ShaderNodeObject<Node> | null | undefined;
+    shadowNode?: ShaderNodeObject<Node> | null | undefined;
+
+    outputNode?: ShaderNodeObject<Node> | null | undefined;
+
+    fragmentNode?: ShaderNodeObject<Node> | null | undefined;
+    vertexNode?: ShaderNodeObject<Node> | null | undefined;
+}
+
 export default class NodeMaterial extends ShaderMaterial {
     readonly isNodeMaterial: true;
 
@@ -28,30 +59,31 @@ export default class NodeMaterial extends ShaderMaterial {
 
     colorSpaced: boolean;
 
-    lightsNode: LightsNode | null;
-    envNode: Node | null;
+    lightsNode: ShaderNodeObject<LightsNode> | null;
+    envNode: ShaderNodeObject<Node> | null;
 
-    colorNode: Node | null;
-    normalNode: Node | null;
-    opacityNode: Node | null;
-    backdropNode: Node | null;
-    backdropAlphaNode: Node | null;
-    alphaTestNode: Node | null;
+    colorNode: ShaderNodeObject<Node> | null;
+    normalNode: ShaderNodeObject<Node> | null;
+    opacityNode: ShaderNodeObject<Node> | null;
+    backdropNode: ShaderNodeObject<Node> | null;
+    backdropAlphaNode: ShaderNodeObject<Node> | null;
+    alphaTestNode: ShaderNodeObject<Node> | null;
 
-    positionNode: Node | null;
+    positionNode: ShaderNodeObject<Node> | null;
 
-    depthNode: Node | null;
-    shadowNode: Node | null;
+    depthNode: ShaderNodeObject<Node> | null;
+    shadowNode: ShaderNodeObject<Node> | null;
 
-    outputNode: Node | null;
+    outputNode: ShaderNodeObject<Node> | null;
 
-    fragmentNode: Node | null;
-    vertexNode: Node | null;
+    fragmentNode: ShaderNodeObject<Node> | null;
+    vertexNode: ShaderNodeObject<Node> | null;
 
     constructor();
 
     build(builder: NodeBuilder): void;
     setup(builder: NodeBuilder): void;
+    setupClipping(builder: NodeBuilder): ShaderNodeObject<ClippingNode> | null;
     setupDepth(builder: NodeBuilder): void;
     setupPosition(builder: NodeBuilder): Node;
     setupDiffuseColor(builder: NodeBuilder): void;
@@ -67,6 +99,7 @@ export default class NodeMaterial extends ShaderMaterial {
 
     static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
     static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshNormalMaterial): MeshNormalNodeMaterial;
     static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
     static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
     static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;

three/examples/jsm/nodes/materials/PointsNodeMaterial.d.ts

@@ -1,9 +1,19 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
-import { Node } from "../Nodes.js";
-import NodeMaterial from "./NodeMaterial.js";
+import { Color, PointsMaterialParameters, Texture } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface PointsNodeMaterialParameters extends NodeMaterialParameters, PointsMaterialParameters {
+}
 
 export default class PointsNodeMaterial extends NodeMaterial {
     readonly isPointsNodeMaterial: true;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    // Properties from PointsMaterial
+    readonly isPointsMaterial: true;
+    color: Color;
+    map: Texture | null;
+    alphaMap: Texture | null;
+    size: number;
+    sizeAttenuation: boolean;
+
+    constructor(parameters?: PointsNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/SpriteNodeMaterial.d.ts

@@ -1,13 +1,24 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import { Color, SpriteMaterialParameters, Texture } from "three";
 import Node from "../core/Node.js";
-import { NodeBuilder } from "../Nodes.js";
-import NodeMaterial from "./NodeMaterial.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface SpriteNodeMaterialParameters extends NodeMaterialParameters, SpriteMaterialParameters {
+}
 
 export default class SpriteNodeMaterial extends NodeMaterial {
     isSpriteNodeMaterial: true;
 
-    rotationNode: Node | null;
-    scaleNode: Node | null;
+    rotationNode: ShaderNodeObject<Node> | null;
+    scaleNode: ShaderNodeObject<Node> | null;
+
+    // Properties from SpriteMaterial
+    readonly isSpriteMaterial: true;
+    color: Color;
+    map: Texture | null;
+    alphaMap: Texture | null;
+    rotation: number;
+    sizeAttenuation: boolean;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    constructor(parameters?: SpriteNodeMaterialParameters);
 }

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

@@ -59,6 +59,10 @@ export type MathNodeMethod = MathNodeMethod1 | MathNodeMethod2 | MathNodeMethod3
 export default class MathNode extends TempNode {
     // 1 input
 
+    static ALL: "all";
+    static ANY: "any";
+    static EQUALS: "equals";
+
     static RADIANS: "radians";
     static DEGREES: "degrees";
     static EXP: "exp";
@@ -129,6 +133,10 @@ export const PI2: ShaderNodeObject<Node>;
 
 type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
+export const all: Unary;
+export const any: Unary;
+export const equals: Unary;
+
 export const radians: Unary;
 export const degrees: Unary;
 export const exp: Unary;
@@ -198,6 +206,9 @@ export const smoothstepElement: Ternary;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {
+        all: typeof all;
+        any: typeof any;
+        equals: typeof equals;
         radians: typeof radians;
         degrees: typeof degrees;
         exp: typeof exp;

three/examples/jsm/nodes/pmrem/PMREMNode.d.ts

@@ -0,0 +1,20 @@
+import { Texture } from "three";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class PMREMNode extends TempNode {
+    uvNode: Node | null;
+    levelNode: Node | null;
+
+    constructor(value: Texture, uvNode?: Node | null, levelNode?: Node | null);
+
+    set value(value: Texture);
+    get value(): Texture;
+}
+
+export const pmremTexture: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+) => ShaderNodeObject<PMREMNode>;

three/examples/jsm/nodes/utils/MaxMipLevelNode.d.ts

@@ -1,4 +1,4 @@
-import { Texture } from "../../../../src/Three.js";
+import { Texture } from "three";
 import TextureNode from "../accessors/TextureNode.js";
 import UniformNode from "../core/UniformNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";

three/examples/jsm/nodes/utils/ReflectorNode.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Object3D, RenderTarget } from "../../../../src/Three.js";
+import { Camera, Object3D, RenderTarget } from "three";
 import TextureNode from "../accessors/TextureNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 

three/examples/jsm/nodes/utils/StoargeArrayElementNode.d.ts

@@ -0,0 +1,25 @@
+import StorageBufferNode from "../accessors/StorageBufferNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import ArrayElementNode from "./ArrayElementNode.js";
+
+export default class StorageArrayElementNode extends ArrayElementNode {
+    node: StorageBufferNode;
+
+    readonly isStorageArrayElementNode: true;
+
+    constructor(storageBufferNode: StorageBufferNode, indexNode: Node);
+
+    get storageBufferNode(): StorageBufferNode;
+    set storageBufferNode(value: StorageBufferNode);
+}
+
+export const storageElement: (
+    storageBufferNode: NodeRepresentation,
+    indexNode: NodeRepresentation,
+) => ShaderNodeObject<StorageArrayElementNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        storageElement: typeof storageElement;
+    }
+}

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

@@ -1,4 +1,4 @@
-import { Mesh, MeshBasicMaterial, SphereGeometry, Texture } from "../../../src/Three.js";
+import { Mesh, MeshBasicMaterial, SphereGeometry, Texture } from "three";
 
 export class GroundedSkybox extends Mesh<SphereGeometry, MeshBasicMaterial> {
     constructor(map: Texture, height: number, radius: number, resolution?: number);

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

@@ -1,4 +1,4 @@
-import { Color, Mesh, Texture } from "../../../src/Three.js";
+import { Color, Mesh, Texture } from "three";
 
 export class LensflareElement {
     constructor(texture: Texture, size?: number, distance?: number, color?: Color);

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

@@ -1,4 +1,4 @@
-import { BufferGeometry, Color, Material, Mesh } from "../../../src/Three.js";
+import { BufferGeometry, Color, Material, Mesh } from "three";
 
 export class MarchingCubes extends Mesh {
     constructor(

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

@@ -1,15 +1,12 @@
-import { Material } from "../../../src/Three.js";
+import { Material, Mesh, OrthographicCamera } from "three";
 import Renderer from "../renderers/common/Renderer.js";
 
-export default class QuadMesh {
-    constructor(material?: Material | null);
+export default class QuadMesh extends Mesh {
+    camera: OrthographicCamera;
 
-    dispose(): void;
+    constructor(material?: Material | null);
 
     renderAsync(renderer: Renderer): Promise<void>;
 
-    get material(): Material;
-    set material(value: Material);
-
-    get render(): (renderer: Renderer) => Promise<void>;
+    render(renderer: Renderer): void;
 }

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

@@ -1,20 +1,12 @@
-import {
-    BufferGeometry,
-    ColorRepresentation,
-    Mesh,
-    PerspectiveCamera,
-    TextureEncoding,
-    WebGLRenderTarget,
-} from "../../../src/Three.js";
+import { BufferGeometry, ColorRepresentation, Mesh, PerspectiveCamera, WebGLRenderTarget } from "three";
 
 export interface ReflectorOptions {
-    color?: ColorRepresentation;
-    textureWidth?: number;
-    textureHeight?: number;
-    clipBias?: number;
-    shader?: object;
-    encoding?: TextureEncoding;
-    multisample?: number;
+    color?: ColorRepresentation | undefined;
+    textureWidth?: number | undefined;
+    textureHeight?: number | undefined;
+    clipBias?: number | undefined;
+    shader?: object | undefined;
+    multisample?: number | undefined;
 }
 
 export class Reflector extends Mesh {

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

@@ -9,7 +9,7 @@ import {
     Vector2,
     WebGLRenderer,
     WebGLRenderTarget,
-} from "../../../src/Three.js";
+} from "three";
 
 export interface ReflectorShader {
     name: string;

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

@@ -1,21 +1,12 @@
-import {
-    BufferGeometry,
-    ColorRepresentation,
-    Mesh,
-    PerspectiveCamera,
-    ShaderMaterial,
-    TextureEncoding,
-    WebGLRenderTarget,
-} from "../../../src/Three.js";
+import { BufferGeometry, ColorRepresentation, Mesh, PerspectiveCamera, ShaderMaterial, WebGLRenderTarget } from "three";
 
 export interface RefractorOptions {
-    color?: ColorRepresentation;
-    textureWidth?: number;
-    textureHeight?: number;
-    clipBias?: number;
-    shader?: object;
-    encoding?: TextureEncoding;
-    multisample?: number;
+    color?: ColorRepresentation | undefined;
+    textureWidth?: number | undefined;
+    textureHeight?: number | undefined;
+    clipBias?: number | undefined;
+    shader?: object | undefined;
+    multisample?: number | undefined;
 }
 
 export class Refractor extends Mesh<BufferGeometry, ShaderMaterial> {

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

@@ -1,4 +1,4 @@
-import { BufferGeometry, Matrix4, Mesh, MeshBasicMaterial, Plane, Vector4 } from "../../../src/Three.js";
+import { BufferGeometry, Matrix4, Mesh, MeshBasicMaterial, Plane, Vector4 } from "three";
 
 export class ShadowMesh extends Mesh<BufferGeometry, MeshBasicMaterial> {
     readonly isShadowMesh: true;

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

@@ -1,4 +1,4 @@
-import { BoxGeometry, Mesh, ShaderMaterial } from "../../../src/Three.js";
+import { BoxGeometry, Mesh, ShaderMaterial } from "three";
 
 export class Sky extends Mesh {
     constructor();

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

@@ -1,12 +1,4 @@
-import {
-    BufferGeometry,
-    ColorRepresentation,
-    Mesh,
-    ShaderMaterial,
-    Side,
-    Texture,
-    Vector3,
-} from "../../../src/Three.js";
+import { BufferGeometry, ColorRepresentation, Mesh, ShaderMaterial, Side, Texture, Vector3 } from "three";
 
 export interface WaterOptions {
     textureWidth?: number;