@tresjs/cientos 3.5.1 → 3.7.0

package/dist/core/controls/CameraControls.vue.d.ts

@@ -246,129 +246,33 @@ export interface CameraControlsProps {
         three?: number;
     };
 }
-declare const _default: import("vue").DefineComponent<{
-    camera: {
-        type: import("vue").PropType<PerspectiveCamera | OrthographicCamera>;
-    };
-    distance: {
-        type: import("vue").PropType<number>;
-        default: () => number;
-    };
-    makeDefault: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    domElement: {
-        type: import("vue").PropType<HTMLElement>;
-    };
-    minPolarAngle: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxPolarAngle: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    minAzimuthAngle: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxAzimuthAngle: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    minDistance: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxDistance: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    infinityDolly: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    minZoom: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxZoom: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    smoothTime: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    draggingSmoothTime: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    azimuthRotateSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    polarRotateSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    dollySpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    dollyDragInverted: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    truckSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    dollyToCursor: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    dragToOffset: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    verticalDragToForward: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    boundaryFriction: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    restThreshold: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    colliderMeshes: {
-        type: import("vue").PropType<Object3D<import("three").Object3DEventMap>[]>;
-        default: () => never[];
-    };
-    mouseButtons: {
-        type: import("vue").PropType<{
-            left?: number | undefined;
-            right?: number | undefined;
-            wheel?: number | undefined;
-            middle?: number | undefined;
-        }>;
-    };
-    touches: {
-        type: import("vue").PropType<{
-            one?: number | undefined;
-            two?: number | undefined;
-            three?: number | undefined;
-        }>;
-    };
-}, {
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CameraControlsProps>, {
+    makeDefault: boolean;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    minAzimuthAngle: number;
+    maxAzimuthAngle: number;
+    distance: () => number;
+    minDistance: number;
+    maxDistance: number;
+    infinityDolly: boolean;
+    minZoom: number;
+    maxZoom: number;
+    smoothTime: number;
+    draggingSmoothTime: number;
+    maxSpeed: number;
+    azimuthRotateSpeed: number;
+    polarRotateSpeed: number;
+    dollySpeed: number;
+    dollyDragInverted: boolean;
+    truckSpeed: number;
+    dollyToCursor: boolean;
+    dragToOffset: boolean;
+    verticalDragToForward: boolean;
+    boundaryFriction: number;
+    restThreshold: number;
+    colliderMeshes: () => never[];
+}>, {
     value: import("vue").Ref<{
         minPolarAngle: number;
         maxPolarAngle: number;
@@ -739,7 +643,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -843,7 +750,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -899,7 +809,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -1240,12 +1153,58 @@ declare const _default: import("vue").DefineComponent<{
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
+                blendAlpha: number;
+                blendColor: {
+                    readonly isColor: true;
+                    r: number;
+                    g: number;
+                    b: number;
+                    set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                    setFromVector3: (vector: Vector3) => import("three").Color;
+                    setScalar: (scalar: number) => import("three").Color;
+                    setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    clone: () => import("three").Color;
+                    copy: (color: import("three").Color) => import("three").Color;
+                    copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                    copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                    convertSRGBToLinear: () => import("three").Color;
+                    convertLinearToSRGB: () => import("three").Color;
+                    getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                    getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                    getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                    getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                    add: (color: import("three").Color) => import("three").Color;
+                    addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                    addScalar: (s: number) => import("three").Color;
+                    applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                    sub: (color: import("three").Color) => import("three").Color;
+                    multiply: (color: import("three").Color) => import("three").Color;
+                    multiplyScalar: (s: number) => import("three").Color;
+                    lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                    lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                    lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                    equals: (color: import("three").Color) => boolean;
+                    fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                    toArray: {
+                        (array?: number[] | undefined, offset?: number | undefined): number[];
+                        (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                    };
+                    toJSON: () => number;
+                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    [Symbol.iterator]: () => Generator<number, void, unknown>;
+                };
                 blendDst: import("three").BlendingDstFactor;
                 blendDstAlpha: number | null;
                 blendEquation: import("three").BlendingEquation;
                 blendEquationAlpha: number | null;
                 blending: import("three").Blending;
-                blendSrc: 210 | import("three").BlendingDstFactor;
+                blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                 blendSrcAlpha: number | null;
                 clipIntersection: boolean;
                 clippingPlanes: {
@@ -1357,7 +1316,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -1429,12 +1388,58 @@ declare const _default: import("vue").DefineComponent<{
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
+                blendAlpha: number;
+                blendColor: {
+                    readonly isColor: true;
+                    r: number;
+                    g: number;
+                    b: number;
+                    set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                    setFromVector3: (vector: Vector3) => import("three").Color;
+                    setScalar: (scalar: number) => import("three").Color;
+                    setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    clone: () => import("three").Color;
+                    copy: (color: import("three").Color) => import("three").Color;
+                    copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                    copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                    convertSRGBToLinear: () => import("three").Color;
+                    convertLinearToSRGB: () => import("three").Color;
+                    getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                    getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                    getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                    getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                    add: (color: import("three").Color) => import("three").Color;
+                    addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                    addScalar: (s: number) => import("three").Color;
+                    applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                    sub: (color: import("three").Color) => import("three").Color;
+                    multiply: (color: import("three").Color) => import("three").Color;
+                    multiplyScalar: (s: number) => import("three").Color;
+                    lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                    lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                    lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                    equals: (color: import("three").Color) => boolean;
+                    fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                    toArray: {
+                        (array?: number[] | undefined, offset?: number | undefined): number[];
+                        (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                    };
+                    toJSON: () => number;
+                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    [Symbol.iterator]: () => Generator<number, void, unknown>;
+                };
                 blendDst: import("three").BlendingDstFactor;
                 blendDstAlpha: number | null;
                 blendEquation: import("three").BlendingEquation;
                 blendEquationAlpha: number | null;
                 blending: import("three").Blending;
-                blendSrc: 210 | import("three").BlendingDstFactor;
+                blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                 blendSrcAlpha: number | null;
                 clipIntersection: boolean;
                 clippingPlanes: {
@@ -1546,7 +1551,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -1754,7 +1759,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -1810,7 +1818,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -1866,7 +1877,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -2255,7 +2269,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -2359,7 +2376,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -2415,7 +2435,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -2756,12 +2779,58 @@ declare const _default: import("vue").DefineComponent<{
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
+                    blendAlpha: number;
+                    blendColor: {
+                        readonly isColor: true;
+                        r: number;
+                        g: number;
+                        b: number;
+                        set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                        setFromVector3: (vector: Vector3) => import("three").Color;
+                        setScalar: (scalar: number) => import("three").Color;
+                        setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        clone: () => import("three").Color;
+                        copy: (color: import("three").Color) => import("three").Color;
+                        copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                        copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                        convertSRGBToLinear: () => import("three").Color;
+                        convertLinearToSRGB: () => import("three").Color;
+                        getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                        getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                        getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                        getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                        add: (color: import("three").Color) => import("three").Color;
+                        addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                        addScalar: (s: number) => import("three").Color;
+                        applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                        sub: (color: import("three").Color) => import("three").Color;
+                        multiply: (color: import("three").Color) => import("three").Color;
+                        multiplyScalar: (s: number) => import("three").Color;
+                        lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                        lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                        lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                        equals: (color: import("three").Color) => boolean;
+                        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                        toArray: {
+                            (array?: number[] | undefined, offset?: number | undefined): number[];
+                            (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                        };
+                        toJSON: () => number;
+                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        [Symbol.iterator]: () => Generator<number, void, unknown>;
+                    };
                     blendDst: import("three").BlendingDstFactor;
                     blendDstAlpha: number | null;
                     blendEquation: import("three").BlendingEquation;
                     blendEquationAlpha: number | null;
                     blending: import("three").Blending;
-                    blendSrc: 210 | import("three").BlendingDstFactor;
+                    blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                     blendSrcAlpha: number | null;
                     clipIntersection: boolean;
                     clippingPlanes: {
@@ -2873,7 +2942,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -2945,12 +3014,58 @@ declare const _default: import("vue").DefineComponent<{
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
+                    blendAlpha: number;
+                    blendColor: {
+                        readonly isColor: true;
+                        r: number;
+                        g: number;
+                        b: number;
+                        set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                        setFromVector3: (vector: Vector3) => import("three").Color;
+                        setScalar: (scalar: number) => import("three").Color;
+                        setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        clone: () => import("three").Color;
+                        copy: (color: import("three").Color) => import("three").Color;
+                        copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                        copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                        convertSRGBToLinear: () => import("three").Color;
+                        convertLinearToSRGB: () => import("three").Color;
+                        getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                        getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                        getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                        getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                        add: (color: import("three").Color) => import("three").Color;
+                        addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                        addScalar: (s: number) => import("three").Color;
+                        applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                        sub: (color: import("three").Color) => import("three").Color;
+                        multiply: (color: import("three").Color) => import("three").Color;
+                        multiplyScalar: (s: number) => import("three").Color;
+                        lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                        lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                        lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                        equals: (color: import("three").Color) => boolean;
+                        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                        toArray: {
+                            (array?: number[] | undefined, offset?: number | undefined): number[];
+                            (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                        };
+                        toJSON: () => number;
+                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        [Symbol.iterator]: () => Generator<number, void, unknown>;
+                    };
                     blendDst: import("three").BlendingDstFactor;
                     blendDstAlpha: number | null;
                     blendEquation: import("three").BlendingEquation;
                     blendEquationAlpha: number | null;
                     blending: import("three").Blending;
-                    blendSrc: 210 | import("three").BlendingDstFactor;
+                    blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                     blendSrcAlpha: number | null;
                     clipIntersection: boolean;
                     clippingPlanes: {
@@ -3062,7 +3177,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -3542,7 +3657,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -3646,7 +3764,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -3702,7 +3823,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -4043,12 +4167,58 @@ declare const _default: import("vue").DefineComponent<{
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
+                    blendAlpha: number;
+                    blendColor: {
+                        readonly isColor: true;
+                        r: number;
+                        g: number;
+                        b: number;
+                        set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                        setFromVector3: (vector: Vector3) => import("three").Color;
+                        setScalar: (scalar: number) => import("three").Color;
+                        setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        clone: () => import("three").Color;
+                        copy: (color: import("three").Color) => import("three").Color;
+                        copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                        copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                        convertSRGBToLinear: () => import("three").Color;
+                        convertLinearToSRGB: () => import("three").Color;
+                        getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                        getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                        getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                        getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                        add: (color: import("three").Color) => import("three").Color;
+                        addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                        addScalar: (s: number) => import("three").Color;
+                        applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                        sub: (color: import("three").Color) => import("three").Color;
+                        multiply: (color: import("three").Color) => import("three").Color;
+                        multiplyScalar: (s: number) => import("three").Color;
+                        lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                        lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                        lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                        equals: (color: import("three").Color) => boolean;
+                        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                        toArray: {
+                            (array?: number[] | undefined, offset?: number | undefined): number[];
+                            (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                        };
+                        toJSON: () => number;
+                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        [Symbol.iterator]: () => Generator<number, void, unknown>;
+                    };
                     blendDst: import("three").BlendingDstFactor;
                     blendDstAlpha: number | null;
                     blendEquation: import("three").BlendingEquation;
                     blendEquationAlpha: number | null;
                     blending: import("three").Blending;
-                    blendSrc: 210 | import("three").BlendingDstFactor;
+                    blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                     blendSrcAlpha: number | null;
                     clipIntersection: boolean;
                     clippingPlanes: {
@@ -4160,7 +4330,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -4232,12 +4402,58 @@ declare const _default: import("vue").DefineComponent<{
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
+                    blendAlpha: number;
+                    blendColor: {
+                        readonly isColor: true;
+                        r: number;
+                        g: number;
+                        b: number;
+                        set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                        setFromVector3: (vector: Vector3) => import("three").Color;
+                        setScalar: (scalar: number) => import("three").Color;
+                        setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        clone: () => import("three").Color;
+                        copy: (color: import("three").Color) => import("three").Color;
+                        copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                        copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                        convertSRGBToLinear: () => import("three").Color;
+                        convertLinearToSRGB: () => import("three").Color;
+                        getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                        getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                        getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                        getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                        add: (color: import("three").Color) => import("three").Color;
+                        addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                        addScalar: (s: number) => import("three").Color;
+                        applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                        sub: (color: import("three").Color) => import("three").Color;
+                        multiply: (color: import("three").Color) => import("three").Color;
+                        multiplyScalar: (s: number) => import("three").Color;
+                        lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                        lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                        lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                        equals: (color: import("three").Color) => boolean;
+                        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                        toArray: {
+                            (array?: number[] | undefined, offset?: number | undefined): number[];
+                            (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                        };
+                        toJSON: () => number;
+                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        [Symbol.iterator]: () => Generator<number, void, unknown>;
+                    };
                     blendDst: import("three").BlendingDstFactor;
                     blendDstAlpha: number | null;
                     blendEquation: import("three").BlendingEquation;
                     blendEquationAlpha: number | null;
                     blending: import("three").Blending;
-                    blendSrc: 210 | import("three").BlendingDstFactor;
+                    blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                     blendSrcAlpha: number | null;
                     clipIntersection: boolean;
                     clippingPlanes: {
@@ -4349,7 +4565,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -4821,7 +5037,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -4925,7 +5144,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -4981,7 +5203,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -5311,12 +5536,58 @@ declare const _default: import("vue").DefineComponent<{
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
+                blendAlpha: number;
+                blendColor: {
+                    readonly isColor: true;
+                    r: number;
+                    g: number;
+                    b: number;
+                    set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                    setFromVector3: (vector: Vector3) => import("three").Color;
+                    setScalar: (scalar: number) => import("three").Color;
+                    setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    clone: () => import("three").Color;
+                    copy: (color: import("three").Color) => import("three").Color;
+                    copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                    copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                    convertSRGBToLinear: () => import("three").Color;
+                    convertLinearToSRGB: () => import("three").Color;
+                    getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                    getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                    getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                    getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                    add: (color: import("three").Color) => import("three").Color;
+                    addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                    addScalar: (s: number) => import("three").Color;
+                    applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                    sub: (color: import("three").Color) => import("three").Color;
+                    multiply: (color: import("three").Color) => import("three").Color;
+                    multiplyScalar: (s: number) => import("three").Color;
+                    lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                    lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                    lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                    equals: (color: import("three").Color) => boolean;
+                    fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                    toArray: {
+                        (array?: number[] | undefined, offset?: number | undefined): number[];
+                        (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                    };
+                    toJSON: () => number;
+                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    [Symbol.iterator]: () => Generator<number, void, unknown>;
+                };
                 blendDst: import("three").BlendingDstFactor;
                 blendDstAlpha: number | null;
                 blendEquation: import("three").BlendingEquation;
                 blendEquationAlpha: number | null;
                 blending: import("three").Blending;
-                blendSrc: 210 | import("three").BlendingDstFactor;
+                blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                 blendSrcAlpha: number | null;
                 clipIntersection: boolean;
                 clippingPlanes: {
@@ -5428,7 +5699,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -5500,12 +5771,58 @@ declare const _default: import("vue").DefineComponent<{
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
+                blendAlpha: number;
+                blendColor: {
+                    readonly isColor: true;
+                    r: number;
+                    g: number;
+                    b: number;
+                    set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                    setFromVector3: (vector: Vector3) => import("three").Color;
+                    setScalar: (scalar: number) => import("three").Color;
+                    setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    clone: () => import("three").Color;
+                    copy: (color: import("three").Color) => import("three").Color;
+                    copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                    copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                    convertSRGBToLinear: () => import("three").Color;
+                    convertLinearToSRGB: () => import("three").Color;
+                    getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                    getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                    getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                    getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                    add: (color: import("three").Color) => import("three").Color;
+                    addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                    addScalar: (s: number) => import("three").Color;
+                    applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                    sub: (color: import("three").Color) => import("three").Color;
+                    multiply: (color: import("three").Color) => import("three").Color;
+                    multiplyScalar: (s: number) => import("three").Color;
+                    lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                    lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                    lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                    equals: (color: import("three").Color) => boolean;
+                    fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                    toArray: {
+                        (array?: number[] | undefined, offset?: number | undefined): number[];
+                        (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                    };
+                    toJSON: () => number;
+                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    [Symbol.iterator]: () => Generator<number, void, unknown>;
+                };
                 blendDst: import("three").BlendingDstFactor;
                 blendDstAlpha: number | null;
                 blendEquation: import("three").BlendingEquation;
                 blendEquationAlpha: number | null;
                 blending: import("three").Blending;
-                blendSrc: 210 | import("three").BlendingDstFactor;
+                blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                 blendSrcAlpha: number | null;
                 clipIntersection: boolean;
                 clippingPlanes: {
@@ -5617,7 +5934,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -5802,7 +6119,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -5858,7 +6178,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -5914,7 +6237,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -6303,7 +6629,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -6407,7 +6736,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -6463,7 +6795,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -6804,12 +7139,58 @@ declare const _default: import("vue").DefineComponent<{
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
+                    blendAlpha: number;
+                    blendColor: {
+                        readonly isColor: true;
+                        r: number;
+                        g: number;
+                        b: number;
+                        set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                        setFromVector3: (vector: Vector3) => import("three").Color;
+                        setScalar: (scalar: number) => import("three").Color;
+                        setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        clone: () => import("three").Color;
+                        copy: (color: import("three").Color) => import("three").Color;
+                        copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                        copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                        convertSRGBToLinear: () => import("three").Color;
+                        convertLinearToSRGB: () => import("three").Color;
+                        getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                        getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                        getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                        getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                        add: (color: import("three").Color) => import("three").Color;
+                        addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                        addScalar: (s: number) => import("three").Color;
+                        applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                        sub: (color: import("three").Color) => import("three").Color;
+                        multiply: (color: import("three").Color) => import("three").Color;
+                        multiplyScalar: (s: number) => import("three").Color;
+                        lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                        lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                        lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                        equals: (color: import("three").Color) => boolean;
+                        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                        toArray: {
+                            (array?: number[] | undefined, offset?: number | undefined): number[];
+                            (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                        };
+                        toJSON: () => number;
+                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        [Symbol.iterator]: () => Generator<number, void, unknown>;
+                    };
                     blendDst: import("three").BlendingDstFactor;
                     blendDstAlpha: number | null;
                     blendEquation: import("three").BlendingEquation;
                     blendEquationAlpha: number | null;
                     blending: import("three").Blending;
-                    blendSrc: 210 | import("three").BlendingDstFactor;
+                    blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                     blendSrcAlpha: number | null;
                     clipIntersection: boolean;
                     clippingPlanes: {
@@ -6921,7 +7302,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -6993,12 +7374,58 @@ declare const _default: import("vue").DefineComponent<{
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
+                    blendAlpha: number;
+                    blendColor: {
+                        readonly isColor: true;
+                        r: number;
+                        g: number;
+                        b: number;
+                        set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                        setFromVector3: (vector: Vector3) => import("three").Color;
+                        setScalar: (scalar: number) => import("three").Color;
+                        setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        clone: () => import("three").Color;
+                        copy: (color: import("three").Color) => import("three").Color;
+                        copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                        copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                        convertSRGBToLinear: () => import("three").Color;
+                        convertLinearToSRGB: () => import("three").Color;
+                        getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                        getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                        getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                        getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                        add: (color: import("three").Color) => import("three").Color;
+                        addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                        addScalar: (s: number) => import("three").Color;
+                        applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                        sub: (color: import("three").Color) => import("three").Color;
+                        multiply: (color: import("three").Color) => import("three").Color;
+                        multiplyScalar: (s: number) => import("three").Color;
+                        lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                        lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                        lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                        equals: (color: import("three").Color) => boolean;
+                        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                        toArray: {
+                            (array?: number[] | undefined, offset?: number | undefined): number[];
+                            (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                        };
+                        toJSON: () => number;
+                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        [Symbol.iterator]: () => Generator<number, void, unknown>;
+                    };
                     blendDst: import("three").BlendingDstFactor;
                     blendDstAlpha: number | null;
                     blendEquation: import("three").BlendingEquation;
                     blendEquationAlpha: number | null;
                     blending: import("three").Blending;
-                    blendSrc: 210 | import("three").BlendingDstFactor;
+                    blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                     blendSrcAlpha: number | null;
                     clipIntersection: boolean;
                     clippingPlanes: {
@@ -7110,7 +7537,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -7590,7 +8017,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -7694,7 +8124,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -7750,7 +8183,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
-                    setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                    setPosition: {
+                        (v: Vector3): Matrix4;
+                        (x: number, y: number, z: number): Matrix4;
+                    };
                     invert: () => Matrix4;
                     scale: (v: Vector3) => Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -8091,12 +8527,58 @@ declare const _default: import("vue").DefineComponent<{
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
+                    blendAlpha: number;
+                    blendColor: {
+                        readonly isColor: true;
+                        r: number;
+                        g: number;
+                        b: number;
+                        set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                        setFromVector3: (vector: Vector3) => import("three").Color;
+                        setScalar: (scalar: number) => import("three").Color;
+                        setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        clone: () => import("three").Color;
+                        copy: (color: import("three").Color) => import("three").Color;
+                        copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                        copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                        convertSRGBToLinear: () => import("three").Color;
+                        convertLinearToSRGB: () => import("three").Color;
+                        getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                        getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                        getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                        getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                        add: (color: import("three").Color) => import("three").Color;
+                        addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                        addScalar: (s: number) => import("three").Color;
+                        applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                        sub: (color: import("three").Color) => import("three").Color;
+                        multiply: (color: import("three").Color) => import("three").Color;
+                        multiplyScalar: (s: number) => import("three").Color;
+                        lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                        lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                        lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                        equals: (color: import("three").Color) => boolean;
+                        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                        toArray: {
+                            (array?: number[] | undefined, offset?: number | undefined): number[];
+                            (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                        };
+                        toJSON: () => number;
+                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        [Symbol.iterator]: () => Generator<number, void, unknown>;
+                    };
                     blendDst: import("three").BlendingDstFactor;
                     blendDstAlpha: number | null;
                     blendEquation: import("three").BlendingEquation;
                     blendEquationAlpha: number | null;
                     blending: import("three").Blending;
-                    blendSrc: 210 | import("three").BlendingDstFactor;
+                    blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                     blendSrcAlpha: number | null;
                     clipIntersection: boolean;
                     clippingPlanes: {
@@ -8208,7 +8690,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -8280,12 +8762,58 @@ declare const _default: import("vue").DefineComponent<{
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
+                    blendAlpha: number;
+                    blendColor: {
+                        readonly isColor: true;
+                        r: number;
+                        g: number;
+                        b: number;
+                        set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                        setFromVector3: (vector: Vector3) => import("three").Color;
+                        setScalar: (scalar: number) => import("three").Color;
+                        setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                        clone: () => import("three").Color;
+                        copy: (color: import("three").Color) => import("three").Color;
+                        copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                        copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                        convertSRGBToLinear: () => import("three").Color;
+                        convertLinearToSRGB: () => import("three").Color;
+                        getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                        getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                        getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                        getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                        offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                        add: (color: import("three").Color) => import("three").Color;
+                        addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                        addScalar: (s: number) => import("three").Color;
+                        applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                        sub: (color: import("three").Color) => import("three").Color;
+                        multiply: (color: import("three").Color) => import("three").Color;
+                        multiplyScalar: (s: number) => import("three").Color;
+                        lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                        lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                        lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                        equals: (color: import("three").Color) => boolean;
+                        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                        toArray: {
+                            (array?: number[] | undefined, offset?: number | undefined): number[];
+                            (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                        };
+                        toJSON: () => number;
+                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        [Symbol.iterator]: () => Generator<number, void, unknown>;
+                    };
                     blendDst: import("three").BlendingDstFactor;
                     blendDstAlpha: number | null;
                     blendEquation: import("three").BlendingEquation;
                     blendEquationAlpha: number | null;
                     blending: import("three").Blending;
-                    blendSrc: 210 | import("three").BlendingDstFactor;
+                    blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                     blendSrcAlpha: number | null;
                     clipIntersection: boolean;
                     clippingPlanes: {
@@ -8397,7 +8925,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -8869,7 +9397,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -8973,7 +9504,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -9029,7 +9563,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
-                setPosition: (v: number | Vector3, y?: number | undefined, z?: number | undefined) => Matrix4;
+                setPosition: {
+                    (v: Vector3): Matrix4;
+                    (x: number, y: number, z: number): Matrix4;
+                };
                 invert: () => Matrix4;
                 scale: (v: Vector3) => Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -9359,12 +9896,58 @@ declare const _default: import("vue").DefineComponent<{
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
+                blendAlpha: number;
+                blendColor: {
+                    readonly isColor: true;
+                    r: number;
+                    g: number;
+                    b: number;
+                    set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                    setFromVector3: (vector: Vector3) => import("three").Color;
+                    setScalar: (scalar: number) => import("three").Color;
+                    setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    clone: () => import("three").Color;
+                    copy: (color: import("three").Color) => import("three").Color;
+                    copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                    copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                    convertSRGBToLinear: () => import("three").Color;
+                    convertLinearToSRGB: () => import("three").Color;
+                    getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                    getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                    getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                    getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                    add: (color: import("three").Color) => import("three").Color;
+                    addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                    addScalar: (s: number) => import("three").Color;
+                    applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                    sub: (color: import("three").Color) => import("three").Color;
+                    multiply: (color: import("three").Color) => import("three").Color;
+                    multiplyScalar: (s: number) => import("three").Color;
+                    lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                    lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                    lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                    equals: (color: import("three").Color) => boolean;
+                    fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                    toArray: {
+                        (array?: number[] | undefined, offset?: number | undefined): number[];
+                        (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                    };
+                    toJSON: () => number;
+                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    [Symbol.iterator]: () => Generator<number, void, unknown>;
+                };
                 blendDst: import("three").BlendingDstFactor;
                 blendDstAlpha: number | null;
                 blendEquation: import("three").BlendingEquation;
                 blendEquationAlpha: number | null;
                 blending: import("three").Blending;
-                blendSrc: 210 | import("three").BlendingDstFactor;
+                blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                 blendSrcAlpha: number | null;
                 clipIntersection: boolean;
                 clippingPlanes: {
@@ -9476,7 +10059,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -9548,12 +10131,58 @@ declare const _default: import("vue").DefineComponent<{
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
+                blendAlpha: number;
+                blendColor: {
+                    readonly isColor: true;
+                    r: number;
+                    g: number;
+                    b: number;
+                    set: (...args: [color: import("three").ColorRepresentation] | [r: number, g: number, b: number]) => import("three").Color;
+                    setFromVector3: (vector: Vector3) => import("three").Color;
+                    setScalar: (scalar: number) => import("three").Color;
+                    setHex: (hex: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setRGB: (r: number, g: number, b: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setHSL: (h: number, s: number, l: number, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setStyle: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    setColorName: (style: string, colorSpace?: import("three").ColorSpace | undefined) => import("three").Color;
+                    clone: () => import("three").Color;
+                    copy: (color: import("three").Color) => import("three").Color;
+                    copySRGBToLinear: (color: import("three").Color) => import("three").Color;
+                    copyLinearToSRGB: (color: import("three").Color) => import("three").Color;
+                    convertSRGBToLinear: () => import("three").Color;
+                    convertLinearToSRGB: () => import("three").Color;
+                    getHex: (colorSpace?: import("three").ColorSpace | undefined) => number;
+                    getHexString: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    getHSL: (target: import("three").HSL, colorSpace?: import("three").ColorSpace | undefined) => import("three").HSL;
+                    getRGB: (target: import("three").RGB, colorSpace?: import("three").ColorSpace | undefined) => import("three").RGB;
+                    getStyle: (colorSpace?: import("three").ColorSpace | undefined) => string;
+                    offsetHSL: (h: number, s: number, l: number) => import("three").Color;
+                    add: (color: import("three").Color) => import("three").Color;
+                    addColors: (color1: import("three").Color, color2: import("three").Color) => import("three").Color;
+                    addScalar: (s: number) => import("three").Color;
+                    applyMatrix3: (m: import("three").Matrix3) => import("three").Color;
+                    sub: (color: import("three").Color) => import("three").Color;
+                    multiply: (color: import("three").Color) => import("three").Color;
+                    multiplyScalar: (s: number) => import("three").Color;
+                    lerp: (color: import("three").Color, alpha: number) => import("three").Color;
+                    lerpColors: (color1: import("three").Color, color2: import("three").Color, alpha: number) => import("three").Color;
+                    lerpHSL: (color: import("three").Color, alpha: number) => import("three").Color;
+                    equals: (color: import("three").Color) => boolean;
+                    fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => import("three").Color;
+                    toArray: {
+                        (array?: number[] | undefined, offset?: number | undefined): number[];
+                        (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+                    };
+                    toJSON: () => number;
+                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    [Symbol.iterator]: () => Generator<number, void, unknown>;
+                };
                 blendDst: import("three").BlendingDstFactor;
                 blendDstAlpha: number | null;
                 blendEquation: import("three").BlendingEquation;
                 blendEquationAlpha: number | null;
                 blending: import("three").Blending;
-                blendSrc: 210 | import("three").BlendingDstFactor;
+                blendSrc: 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214;
                 blendSrcAlpha: number | null;
                 clipIntersection: boolean;
                 clippingPlanes: {
@@ -9665,7 +10294,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -9871,134 +10500,38 @@ declare const _default: import("vue").DefineComponent<{
         dispatchEvent: (event: import("camera-controls/dist/EventDispatcher").DispatcherEvent) => void;
     } | null>;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    change: (...args: any[]) => void;
     start: (...args: any[]) => void;
+    change: (...args: any[]) => void;
     end: (...args: any[]) => void;
-}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    camera: {
-        type: import("vue").PropType<PerspectiveCamera | OrthographicCamera>;
-    };
-    distance: {
-        type: import("vue").PropType<number>;
-        default: () => number;
-    };
-    makeDefault: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    domElement: {
-        type: import("vue").PropType<HTMLElement>;
-    };
-    minPolarAngle: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxPolarAngle: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    minAzimuthAngle: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxAzimuthAngle: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    minDistance: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxDistance: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    infinityDolly: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    minZoom: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxZoom: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    smoothTime: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    draggingSmoothTime: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    azimuthRotateSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    polarRotateSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    dollySpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    dollyDragInverted: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    truckSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    dollyToCursor: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    dragToOffset: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    verticalDragToForward: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    boundaryFriction: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    restThreshold: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    colliderMeshes: {
-        type: import("vue").PropType<Object3D<import("three").Object3DEventMap>[]>;
-        default: () => never[];
-    };
-    mouseButtons: {
-        type: import("vue").PropType<{
-            left?: number | undefined;
-            right?: number | undefined;
-            wheel?: number | undefined;
-            middle?: number | undefined;
-        }>;
-    };
-    touches: {
-        type: import("vue").PropType<{
-            one?: number | undefined;
-            two?: number | undefined;
-            three?: number | undefined;
-        }>;
-    };
-}>> & {
-    onChange?: ((...args: any[]) => any) | undefined;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CameraControlsProps>, {
+    makeDefault: boolean;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    minAzimuthAngle: number;
+    maxAzimuthAngle: number;
+    distance: () => number;
+    minDistance: number;
+    maxDistance: number;
+    infinityDolly: boolean;
+    minZoom: number;
+    maxZoom: number;
+    smoothTime: number;
+    draggingSmoothTime: number;
+    maxSpeed: number;
+    azimuthRotateSpeed: number;
+    polarRotateSpeed: number;
+    dollySpeed: number;
+    dollyDragInverted: boolean;
+    truckSpeed: number;
+    dollyToCursor: boolean;
+    dragToOffset: boolean;
+    verticalDragToForward: boolean;
+    boundaryFriction: number;
+    restThreshold: number;
+    colliderMeshes: () => never[];
+}>>> & {
     onStart?: ((...args: any[]) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
     onEnd?: ((...args: any[]) => any) | undefined;
 }, {
     distance: number;
@@ -10028,3 +10561,20 @@ declare const _default: import("vue").DefineComponent<{
     colliderMeshes: Object3D<import("three").Object3DEventMap>[];
 }, {}>;
 export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};