@tresjs/cientos 3.5.1 → 3.7.0

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

@@ -224,107 +224,32 @@ export interface OrbitControlsProps {
      */
     rotateSpeed?: number;
 }
-declare const _default: import("vue").DefineComponent<{
-    keys: {
-        type: import("vue").PropType<Record<string, string>>;
-    };
-    camera: {
-        type: import("vue").PropType<Camera>;
-    };
-    target: {
-        type: import("vue").PropType<number | import("three").Vector3 | import("@tresjs/core").VectorCoordinates | [x: number, y: number, z: 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;
-    };
-    minZoom: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxZoom: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    touches: {
-        type: import("vue").PropType<{
-            ONE?: number | undefined;
-            TWO?: number | undefined;
-        }>;
-        default: () => {
-            ONE: TOUCH;
-            TWO: TOUCH;
-        };
-    };
-    dampingFactor: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    enableDamping: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    enableZoom: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    zoomSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    enableRotate: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    rotateSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    enablePan: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    keyPanSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    autoRotate: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    autoRotateSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<OrbitControlsProps>, {
+    makeDefault: boolean;
+    autoRotate: boolean;
+    autoRotateSpeed: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    enablePan: boolean;
+    keyPanSpeed: number;
+    maxAzimuthAngle: number;
+    minAzimuthAngle: number;
+    maxPolarAngle: number;
+    minPolarAngle: number;
+    minDistance: number;
+    maxDistance: number;
+    minZoom: number;
+    maxZoom: number;
+    enableZoom: boolean;
+    zoomSpeed: number;
+    enableRotate: boolean;
+    touches: () => {
+        ONE: TOUCH;
+        TWO: TOUCH;
     };
-}, {
+    rotateSpeed: number;
+    target: () => number[];
+}>, {
     value: import("vue").Ref<{
         object: {
             readonly isPerspectiveCamera: true;
@@ -387,7 +312,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -443,7 +371,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -499,7 +430,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -888,7 +822,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -992,7 +929,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -1048,7 +988,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -1389,12 +1332,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: import("three").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: {
@@ -1506,7 +1495,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: import("three").Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -1554,55 +1543,23 @@ declare const _default: import("vue").DefineComponent<{
                     toJSON: (meta?: any) => any;
                     addEventListener: {
                         <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T], T, import("three").Material>): void;
                         <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                     };
                     hasEventListener: {
                         <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_2], T_2, import("three").Material>): boolean;
                         <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                     };
                     removeEventListener: {
                         <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_4], T_4, import("three").Material>): void;
                         <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                     };
                     dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
@@ -1610,12 +1567,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: import("three").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: {
@@ -1727,7 +1730,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: import("three").Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -1775,55 +1778,23 @@ declare const _default: import("vue").DefineComponent<{
                     toJSON: (meta?: any) => any;
                     addEventListener: {
                         <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T], T, import("three").Material>): void;
                         <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                     };
                     hasEventListener: {
                         <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_2], T_2, import("three").Material>): boolean;
                         <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                     };
                     removeEventListener: {
                         <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_4], T_4, import("three").Material>): void;
                         <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                     };
                     dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
@@ -2239,7 +2210,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -2343,7 +2317,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -2399,7 +2376,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -2740,12 +2720,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: import("three").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: {
@@ -2857,7 +2883,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: import("three").Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -2905,55 +2931,23 @@ declare const _default: import("vue").DefineComponent<{
                     toJSON: (meta?: any) => any;
                     addEventListener: {
                         <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T], T, import("three").Material>): void;
                         <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                     };
                     hasEventListener: {
                         <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_2], T_2, import("three").Material>): boolean;
                         <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                     };
                     removeEventListener: {
                         <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_4], T_4, import("three").Material>): void;
                         <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                     };
                     dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
@@ -2961,12 +2955,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: import("three").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: {
@@ -3078,7 +3118,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: import("three").Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -3126,55 +3166,23 @@ declare const _default: import("vue").DefineComponent<{
                     toJSON: (meta?: any) => any;
                     addEventListener: {
                         <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T], T, import("three").Material>): void;
                         <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                     };
                     hasEventListener: {
                         <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_2], T_2, import("three").Material>): boolean;
                         <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                     };
                     removeEventListener: {
                         <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_4], T_4, import("three").Material>): void;
                         <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                     };
                     dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
@@ -3582,7 +3590,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -3686,7 +3697,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -3742,7 +3756,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -4072,12 +4089,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: import("three").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: {
@@ -4189,7 +4252,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: import("three").Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -4237,55 +4300,23 @@ declare const _default: import("vue").DefineComponent<{
                 toJSON: (meta?: any) => any;
                 addEventListener: {
                     <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T], T, import("three").Material>): void;
                     <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                 };
                 hasEventListener: {
                     <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_2], T_2, import("three").Material>): boolean;
                     <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                 };
                 removeEventListener: {
                     <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_4], T_4, import("three").Material>): void;
                     <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                 };
                 dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                    /**
-                     * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                     *
-                     * @default 7.0
-                     * @type {number}
-                     * @memberof OrbitControlsProps
-                     * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                     */
                     dispose: {};
                 }[T_6]) => void;
             } | undefined;
@@ -4293,12 +4324,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: import("three").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: {
@@ -4410,7 +4487,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: import("three").Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -4458,55 +4535,23 @@ declare const _default: import("vue").DefineComponent<{
                 toJSON: (meta?: any) => any;
                 addEventListener: {
                     <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T], T, import("three").Material>): void;
                     <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                 };
                 hasEventListener: {
                     <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_2], T_2, import("three").Material>): boolean;
                     <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                 };
                 removeEventListener: {
                     <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_4], T_4, import("three").Material>): void;
                     <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                 };
                 dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                    /**
-                     * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                     *
-                     * @default 7.0
-                     * @type {number}
-                     * @memberof OrbitControlsProps
-                     * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                     */
                     dispose: {};
                 }[T_6]) => void;
             } | undefined;
@@ -4627,7 +4672,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -4683,7 +4731,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -4739,7 +4790,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -5128,7 +5182,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -5232,7 +5289,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -5288,7 +5348,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -5629,12 +5692,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: import("three").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: {
@@ -5746,7 +5855,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: import("three").Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -5794,55 +5903,23 @@ declare const _default: import("vue").DefineComponent<{
                     toJSON: (meta?: any) => any;
                     addEventListener: {
                         <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T], T, import("three").Material>): void;
                         <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                     };
                     hasEventListener: {
                         <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_2], T_2, import("three").Material>): boolean;
                         <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                     };
                     removeEventListener: {
                         <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_4], T_4, import("three").Material>): void;
                         <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                     };
                     dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
@@ -5850,12 +5927,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: import("three").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: {
@@ -5967,7 +6090,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: import("three").Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -6015,55 +6138,23 @@ declare const _default: import("vue").DefineComponent<{
                     toJSON: (meta?: any) => any;
                     addEventListener: {
                         <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T], T, import("three").Material>): void;
                         <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                     };
                     hasEventListener: {
                         <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_2], T_2, import("three").Material>): boolean;
                         <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                     };
                     removeEventListener: {
                         <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_4], T_4, import("three").Material>): void;
                         <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                     };
                     dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
@@ -6479,7 +6570,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -6583,7 +6677,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -6639,7 +6736,10 @@ declare const _default: import("vue").DefineComponent<{
                     multiplyScalar: (s: number) => import("three").Matrix4;
                     determinant: () => number;
                     transpose: () => import("three").Matrix4;
-                    setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                    setPosition: {
+                        (v: import("three").Vector3): import("three").Matrix4;
+                        (x: number, y: number, z: number): import("three").Matrix4;
+                    };
                     invert: () => import("three").Matrix4;
                     scale: (v: import("three").Vector3) => import("three").Matrix4;
                     getMaxScaleOnAxis: () => number;
@@ -6980,12 +7080,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: import("three").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: {
@@ -7097,7 +7243,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: import("three").Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -7145,55 +7291,23 @@ declare const _default: import("vue").DefineComponent<{
                     toJSON: (meta?: any) => any;
                     addEventListener: {
                         <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T], T, import("three").Material>): void;
                         <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                     };
                     hasEventListener: {
                         <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_2], T_2, import("three").Material>): boolean;
                         <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                     };
                     removeEventListener: {
                         <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_4], T_4, import("three").Material>): void;
                         <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                     };
                     dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
@@ -7201,12 +7315,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: import("three").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: {
@@ -7318,7 +7478,7 @@ declare const _default: import("vue").DefineComponent<{
                         translate: (offset: import("three").Vector3) => import("three").Plane;
                         equals: (plane: import("three").Plane) => boolean;
                         isIntersectionLine: (l: any) => any;
-                    }[];
+                    }[] | null;
                     clipShadows: boolean;
                     colorWrite: boolean;
                     defines: {
@@ -7366,55 +7526,23 @@ declare const _default: import("vue").DefineComponent<{
                     toJSON: (meta?: any) => any;
                     addEventListener: {
                         <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T], T, import("three").Material>): void;
                         <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                     };
                     hasEventListener: {
                         <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_2], T_2, import("three").Material>): boolean;
                         <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                     };
                     removeEventListener: {
                         <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                            /**
-                             * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                             *
-                             * @default 7.0
-                             * @type {number}
-                             * @memberof OrbitControlsProps
-                             * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                             */
                             dispose: {};
                         }[T_4], T_4, import("three").Material>): void;
                         <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                     };
                     dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
@@ -7822,7 +7950,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -7926,7 +8057,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -7982,7 +8116,10 @@ declare const _default: import("vue").DefineComponent<{
                 multiplyScalar: (s: number) => import("three").Matrix4;
                 determinant: () => number;
                 transpose: () => import("three").Matrix4;
-                setPosition: (v: number | import("three").Vector3, y?: number | undefined, z?: number | undefined) => import("three").Matrix4;
+                setPosition: {
+                    (v: import("three").Vector3): import("three").Matrix4;
+                    (x: number, y: number, z: number): import("three").Matrix4;
+                };
                 invert: () => import("three").Matrix4;
                 scale: (v: import("three").Vector3) => import("three").Matrix4;
                 getMaxScaleOnAxis: () => number;
@@ -8312,12 +8449,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: import("three").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: {
@@ -8429,7 +8612,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: import("three").Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -8477,55 +8660,23 @@ declare const _default: import("vue").DefineComponent<{
                 toJSON: (meta?: any) => any;
                 addEventListener: {
                     <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T], T, import("three").Material>): void;
                     <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                 };
                 hasEventListener: {
                     <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_2], T_2, import("three").Material>): boolean;
                     <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                 };
                 removeEventListener: {
                     <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_4], T_4, import("three").Material>): void;
                     <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                 };
                 dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                    /**
-                     * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                     *
-                     * @default 7.0
-                     * @type {number}
-                     * @memberof OrbitControlsProps
-                     * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                     */
                     dispose: {};
                 }[T_6]) => void;
             } | undefined;
@@ -8533,12 +8684,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: import("three").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: {
@@ -8650,7 +8847,7 @@ declare const _default: import("vue").DefineComponent<{
                     translate: (offset: import("three").Vector3) => import("three").Plane;
                     equals: (plane: import("three").Plane) => boolean;
                     isIntersectionLine: (l: any) => any;
-                }[];
+                }[] | null;
                 clipShadows: boolean;
                 colorWrite: boolean;
                 defines: {
@@ -8698,55 +8895,23 @@ declare const _default: import("vue").DefineComponent<{
                 toJSON: (meta?: any) => any;
                 addEventListener: {
                     <T extends "dispose">(type: T, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T], T, import("three").Material>): void;
                     <T_1 extends string>(type: T_1, listener: import("three").EventListener<{}, T_1, import("three").Material>): void;
                 };
                 hasEventListener: {
                     <T_2 extends "dispose">(type: T_2, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_2], T_2, import("three").Material>): boolean;
                     <T_3 extends string>(type: T_3, listener: import("three").EventListener<{}, T_3, import("three").Material>): boolean;
                 };
                 removeEventListener: {
                     <T_4 extends "dispose">(type: T_4, listener: import("three").EventListener<{
-                        /**
-                         * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                         *
-                         * @default 7.0
-                         * @type {number}
-                         * @memberof OrbitControlsProps
-                         * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                         */
                         dispose: {};
                     }[T_4], T_4, import("three").Material>): void;
                     <T_5 extends string>(type: T_5, listener: import("three").EventListener<{}, T_5, import("three").Material>): void;
                 };
                 dispatchEvent: <T_6 extends "dispose">(event: import("three").BaseEvent<T_6> & {
-                    /**
-                     * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
-                     *
-                     * @default 7.0
-                     * @type {number}
-                     * @memberof OrbitControlsProps
-                     * @see https://threejs.org/docs/#examples/en/controls/OrbitControls.keyPanSpeed
-                     */
                     dispose: {};
                 }[T_6]) => void;
             } | undefined;
@@ -9142,112 +9307,37 @@ declare const _default: import("vue").DefineComponent<{
         dispatchEvent: <T_32 extends never>(event: import("three").BaseEvent<T_32> & {}[T_32]) => 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<{
-    keys: {
-        type: import("vue").PropType<Record<string, string>>;
-    };
-    camera: {
-        type: import("vue").PropType<Camera>;
-    };
-    target: {
-        type: import("vue").PropType<number | import("three").Vector3 | import("@tresjs/core").VectorCoordinates | [x: number, y: number, z: 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;
-    };
-    minZoom: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    maxZoom: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    touches: {
-        type: import("vue").PropType<{
-            ONE?: number | undefined;
-            TWO?: number | undefined;
-        }>;
-        default: () => {
-            ONE: TOUCH;
-            TWO: TOUCH;
-        };
-    };
-    dampingFactor: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    enableDamping: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    enableZoom: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    zoomSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    enableRotate: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    rotateSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    enablePan: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    keyPanSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
-    };
-    autoRotate: {
-        type: import("vue").PropType<boolean>;
-        default: boolean;
-    };
-    autoRotateSpeed: {
-        type: import("vue").PropType<number>;
-        default: number;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<OrbitControlsProps>, {
+    makeDefault: boolean;
+    autoRotate: boolean;
+    autoRotateSpeed: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    enablePan: boolean;
+    keyPanSpeed: number;
+    maxAzimuthAngle: number;
+    minAzimuthAngle: number;
+    maxPolarAngle: number;
+    minPolarAngle: number;
+    minDistance: number;
+    maxDistance: number;
+    minZoom: number;
+    maxZoom: number;
+    enableZoom: boolean;
+    zoomSpeed: number;
+    enableRotate: boolean;
+    touches: () => {
+        ONE: TOUCH;
+        TWO: TOUCH;
     };
-}>> & {
-    onChange?: ((...args: any[]) => any) | undefined;
+    rotateSpeed: number;
+    target: () => number[];
+}>>> & {
     onStart?: ((...args: any[]) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
     onEnd?: ((...args: any[]) => any) | undefined;
 }, {
     target: number | import("three").Vector3 | import("@tresjs/core").VectorCoordinates | [x: number, y: number, z: number];
@@ -9276,3 +9366,20 @@ declare const _default: import("vue").DefineComponent<{
     autoRotateSpeed: number;
 }, {}>;
 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];
+} & {};