@tresjs/cientos 3.7.0 → 3.8.0

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

@@ -315,34 +315,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setY: (y: number) => Vector3;
                 setZ: (z: number) => Vector3;
                 setComponent: (index: number, value: number) => Vector3;
-                setFromColor: (color: import("three").Color) => Vector3;
                 getComponent: (index: number) => number;
                 clone: () => Vector3;
-                copy: (v: Vector3) => Vector3;
-                add: (v: Vector3) => Vector3;
+                copy: (v: import("three").Vector3Like) => Vector3;
+                add: (v: import("three").Vector3Like) => Vector3;
                 addScalar: (s: number) => Vector3;
+                addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 addScaledVector: (v: Vector3, s: number) => Vector3;
-                addVectors: (a: Vector3, b: Vector3) => Vector3;
-                sub: (a: Vector3) => Vector3;
+                sub: (a: import("three").Vector3Like) => Vector3;
                 subScalar: (s: number) => Vector3;
-                subVectors: (a: Vector3, b: Vector3) => Vector3;
-                multiply: (v: Vector3) => Vector3;
+                subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                multiply: (v: import("three").Vector3Like) => Vector3;
                 multiplyScalar: (s: number) => Vector3;
-                multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 applyEuler: (euler: import("three").Euler) => Vector3;
                 applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                 applyMatrix3: (m: import("three").Matrix3) => Vector3;
                 applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                 applyMatrix4: (m: Matrix4) => Vector3;
-                applyQuaternion: (q: Quaternion) => Vector3;
+                applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                 project: (camera: import("three").Camera) => Vector3;
                 unproject: (camera: import("three").Camera) => Vector3;
                 transformDirection: (m: Matrix4) => Vector3;
-                divide: (v: Vector3) => Vector3;
+                divide: (v: import("three").Vector3Like) => Vector3;
                 divideScalar: (s: number) => Vector3;
-                min: (v: Vector3) => Vector3;
-                max: (v: Vector3) => Vector3;
-                clamp: (min: Vector3, max: Vector3) => Vector3;
+                min: (v: import("three").Vector3Like) => Vector3;
+                max: (v: import("three").Vector3Like) => Vector3;
+                clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                 clampScalar: (min: number, max: number) => Vector3;
                 clampLength: (min: number, max: number) => Vector3;
                 floor: () => Vector3;
@@ -350,25 +349,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 round: () => Vector3;
                 roundToZero: () => Vector3;
                 negate: () => Vector3;
-                dot: (v: Vector3) => number;
+                dot: (v: import("three").Vector3Like) => number;
                 lengthSq: () => number;
                 length: () => number;
-                lengthManhattan: () => number;
                 manhattanLength: () => number;
-                manhattanDistanceTo: (v: Vector3) => number;
                 normalize: () => Vector3;
                 setLength: (l: number) => Vector3;
-                lerp: (v: Vector3, alpha: number) => Vector3;
-                lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                cross: (a: Vector3) => Vector3;
-                crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                cross: (a: import("three").Vector3Like) => Vector3;
+                crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 projectOnVector: (v: Vector3) => Vector3;
                 projectOnPlane: (planeNormal: Vector3) => Vector3;
-                reflect: (vector: Vector3) => Vector3;
+                reflect: (vector: import("three").Vector3Like) => Vector3;
                 angleTo: (v: Vector3) => number;
-                distanceTo: (v: Vector3) => number;
-                distanceToSquared: (v: Vector3) => number;
-                distanceToManhattan: (v: Vector3) => number;
+                distanceTo: (v: import("three").Vector3Like) => number;
+                distanceToSquared: (v: import("three").Vector3Like) => number;
+                manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                 setFromSpherical: (s: Spherical) => Vector3;
                 setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                 setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -378,14 +375,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                 setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                 setFromEuler: (e: import("three").Euler) => Vector3;
-                equals: (v: Vector3) => boolean;
+                setFromColor: (color: import("three").RGB) => Vector3;
+                equals: (v: import("three").Vector3Like) => boolean;
                 fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                 toArray: {
                     (array?: number[] | undefined, offset?: number | undefined): number[];
                     (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                 random: () => Vector3;
                 randomDirection: () => Vector3;
                 [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -401,34 +399,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setY: (y: number) => Vector3;
                 setZ: (z: number) => Vector3;
                 setComponent: (index: number, value: number) => Vector3;
-                setFromColor: (color: import("three").Color) => Vector3;
                 getComponent: (index: number) => number;
                 clone: () => Vector3;
-                copy: (v: Vector3) => Vector3;
-                add: (v: Vector3) => Vector3;
+                copy: (v: import("three").Vector3Like) => Vector3;
+                add: (v: import("three").Vector3Like) => Vector3;
                 addScalar: (s: number) => Vector3;
+                addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 addScaledVector: (v: Vector3, s: number) => Vector3;
-                addVectors: (a: Vector3, b: Vector3) => Vector3;
-                sub: (a: Vector3) => Vector3;
+                sub: (a: import("three").Vector3Like) => Vector3;
                 subScalar: (s: number) => Vector3;
-                subVectors: (a: Vector3, b: Vector3) => Vector3;
-                multiply: (v: Vector3) => Vector3;
+                subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                multiply: (v: import("three").Vector3Like) => Vector3;
                 multiplyScalar: (s: number) => Vector3;
-                multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 applyEuler: (euler: import("three").Euler) => Vector3;
                 applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                 applyMatrix3: (m: import("three").Matrix3) => Vector3;
                 applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                 applyMatrix4: (m: Matrix4) => Vector3;
-                applyQuaternion: (q: Quaternion) => Vector3;
+                applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                 project: (camera: import("three").Camera) => Vector3;
                 unproject: (camera: import("three").Camera) => Vector3;
                 transformDirection: (m: Matrix4) => Vector3;
-                divide: (v: Vector3) => Vector3;
+                divide: (v: import("three").Vector3Like) => Vector3;
                 divideScalar: (s: number) => Vector3;
-                min: (v: Vector3) => Vector3;
-                max: (v: Vector3) => Vector3;
-                clamp: (min: Vector3, max: Vector3) => Vector3;
+                min: (v: import("three").Vector3Like) => Vector3;
+                max: (v: import("three").Vector3Like) => Vector3;
+                clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                 clampScalar: (min: number, max: number) => Vector3;
                 clampLength: (min: number, max: number) => Vector3;
                 floor: () => Vector3;
@@ -436,25 +433,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 round: () => Vector3;
                 roundToZero: () => Vector3;
                 negate: () => Vector3;
-                dot: (v: Vector3) => number;
+                dot: (v: import("three").Vector3Like) => number;
                 lengthSq: () => number;
                 length: () => number;
-                lengthManhattan: () => number;
                 manhattanLength: () => number;
-                manhattanDistanceTo: (v: Vector3) => number;
                 normalize: () => Vector3;
                 setLength: (l: number) => Vector3;
-                lerp: (v: Vector3, alpha: number) => Vector3;
-                lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                cross: (a: Vector3) => Vector3;
-                crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                cross: (a: import("three").Vector3Like) => Vector3;
+                crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 projectOnVector: (v: Vector3) => Vector3;
                 projectOnPlane: (planeNormal: Vector3) => Vector3;
-                reflect: (vector: Vector3) => Vector3;
+                reflect: (vector: import("three").Vector3Like) => Vector3;
                 angleTo: (v: Vector3) => number;
-                distanceTo: (v: Vector3) => number;
-                distanceToSquared: (v: Vector3) => number;
-                distanceToManhattan: (v: Vector3) => number;
+                distanceTo: (v: import("three").Vector3Like) => number;
+                distanceToSquared: (v: import("three").Vector3Like) => number;
+                manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                 setFromSpherical: (s: Spherical) => Vector3;
                 setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                 setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -464,14 +459,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                 setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                 setFromEuler: (e: import("three").Euler) => Vector3;
-                equals: (v: Vector3) => boolean;
+                setFromColor: (color: import("three").RGB) => Vector3;
+                equals: (v: import("three").Vector3Like) => boolean;
                 fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                 toArray: {
                     (array?: number[] | undefined, offset?: number | undefined): number[];
                     (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                 random: () => Vector3;
                 randomDirection: () => Vector3;
                 [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -504,11 +500,11 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 readonly isQuaternion: true;
                 set: (x: number, y: number, z: number, w: number) => Quaternion;
                 clone: () => Quaternion;
-                copy: (q: Quaternion) => Quaternion;
+                copy: (q: import("three").QuaternionLike) => Quaternion;
                 setFromEuler: (euler: import("three").Euler, update?: boolean | undefined) => Quaternion;
-                setFromAxisAngle: (axis: Vector3, angle: number) => Quaternion;
+                setFromAxisAngle: (axis: import("three").Vector3Like, angle: number) => Quaternion;
                 setFromRotationMatrix: (m: Matrix4) => Quaternion;
-                setFromUnitVectors: (vFrom: Vector3, vTo: Vector3) => Quaternion;
+                setFromUnitVectors: (vFrom: Vector3, vTo: import("three").Vector3Like) => Quaternion;
                 angleTo: (q: Quaternion) => number;
                 rotateTowards: (q: Quaternion, step: number) => Quaternion;
                 identity: () => Quaternion;
@@ -530,10 +526,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
                 toJSON: () => [number, number, number, number];
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Quaternion;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Quaternion;
                 _onChange: (callback: () => void) => Quaternion;
                 _onChangeCallback: () => void;
-                multiplyVector3: (v: any) => any;
                 random: () => Quaternion;
                 [Symbol.iterator]: () => Generator<number, void, unknown>;
             };
@@ -548,34 +543,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setY: (y: number) => Vector3;
                 setZ: (z: number) => Vector3;
                 setComponent: (index: number, value: number) => Vector3;
-                setFromColor: (color: import("three").Color) => Vector3;
                 getComponent: (index: number) => number;
                 clone: () => Vector3;
-                copy: (v: Vector3) => Vector3;
-                add: (v: Vector3) => Vector3;
+                copy: (v: import("three").Vector3Like) => Vector3;
+                add: (v: import("three").Vector3Like) => Vector3;
                 addScalar: (s: number) => Vector3;
+                addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 addScaledVector: (v: Vector3, s: number) => Vector3;
-                addVectors: (a: Vector3, b: Vector3) => Vector3;
-                sub: (a: Vector3) => Vector3;
+                sub: (a: import("three").Vector3Like) => Vector3;
                 subScalar: (s: number) => Vector3;
-                subVectors: (a: Vector3, b: Vector3) => Vector3;
-                multiply: (v: Vector3) => Vector3;
+                subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                multiply: (v: import("three").Vector3Like) => Vector3;
                 multiplyScalar: (s: number) => Vector3;
-                multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 applyEuler: (euler: import("three").Euler) => Vector3;
                 applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                 applyMatrix3: (m: import("three").Matrix3) => Vector3;
                 applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                 applyMatrix4: (m: Matrix4) => Vector3;
-                applyQuaternion: (q: Quaternion) => Vector3;
+                applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                 project: (camera: import("three").Camera) => Vector3;
                 unproject: (camera: import("three").Camera) => Vector3;
                 transformDirection: (m: Matrix4) => Vector3;
-                divide: (v: Vector3) => Vector3;
+                divide: (v: import("three").Vector3Like) => Vector3;
                 divideScalar: (s: number) => Vector3;
-                min: (v: Vector3) => Vector3;
-                max: (v: Vector3) => Vector3;
-                clamp: (min: Vector3, max: Vector3) => Vector3;
+                min: (v: import("three").Vector3Like) => Vector3;
+                max: (v: import("three").Vector3Like) => Vector3;
+                clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                 clampScalar: (min: number, max: number) => Vector3;
                 clampLength: (min: number, max: number) => Vector3;
                 floor: () => Vector3;
@@ -583,25 +577,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 round: () => Vector3;
                 roundToZero: () => Vector3;
                 negate: () => Vector3;
-                dot: (v: Vector3) => number;
+                dot: (v: import("three").Vector3Like) => number;
                 lengthSq: () => number;
                 length: () => number;
-                lengthManhattan: () => number;
                 manhattanLength: () => number;
-                manhattanDistanceTo: (v: Vector3) => number;
                 normalize: () => Vector3;
                 setLength: (l: number) => Vector3;
-                lerp: (v: Vector3, alpha: number) => Vector3;
-                lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                cross: (a: Vector3) => Vector3;
-                crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                cross: (a: import("three").Vector3Like) => Vector3;
+                crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 projectOnVector: (v: Vector3) => Vector3;
                 projectOnPlane: (planeNormal: Vector3) => Vector3;
-                reflect: (vector: Vector3) => Vector3;
+                reflect: (vector: import("three").Vector3Like) => Vector3;
                 angleTo: (v: Vector3) => number;
-                distanceTo: (v: Vector3) => number;
-                distanceToSquared: (v: Vector3) => number;
-                distanceToManhattan: (v: Vector3) => number;
+                distanceTo: (v: import("three").Vector3Like) => number;
+                distanceToSquared: (v: import("three").Vector3Like) => number;
+                manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                 setFromSpherical: (s: Spherical) => Vector3;
                 setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                 setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -611,14 +603,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                 setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                 setFromEuler: (e: import("three").Euler) => Vector3;
-                equals: (v: Vector3) => boolean;
+                setFromColor: (color: import("three").RGB) => Vector3;
+                equals: (v: import("three").Vector3Like) => boolean;
                 fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                 toArray: {
                     (array?: number[] | undefined, offset?: number | undefined): number[];
                     (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                 random: () => Vector3;
                 randomDirection: () => Vector3;
                 [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -1146,10 +1139,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 clone: () => import("three").AnimationClip;
                 toJSON: (clip: import("three").AnimationClip) => any;
             }[];
-            userData: {
-                [key: string]: any;
-            };
+            userData: Record<string, any>;
             customDepthMaterial?: {
+                readonly isMaterial: true;
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
@@ -1196,7 +1188,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => number;
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
                 blendDst: import("three").BlendingDstFactor;
@@ -1219,34 +1211,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setY: (y: number) => Vector3;
                         setZ: (z: number) => Vector3;
                         setComponent: (index: number, value: number) => Vector3;
-                        setFromColor: (color: import("three").Color) => Vector3;
                         getComponent: (index: number) => number;
                         clone: () => Vector3;
-                        copy: (v: Vector3) => Vector3;
-                        add: (v: Vector3) => Vector3;
+                        copy: (v: import("three").Vector3Like) => Vector3;
+                        add: (v: import("three").Vector3Like) => Vector3;
                         addScalar: (s: number) => Vector3;
+                        addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         addScaledVector: (v: Vector3, s: number) => Vector3;
-                        addVectors: (a: Vector3, b: Vector3) => Vector3;
-                        sub: (a: Vector3) => Vector3;
+                        sub: (a: import("three").Vector3Like) => Vector3;
                         subScalar: (s: number) => Vector3;
-                        subVectors: (a: Vector3, b: Vector3) => Vector3;
-                        multiply: (v: Vector3) => Vector3;
+                        subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                        multiply: (v: import("three").Vector3Like) => Vector3;
                         multiplyScalar: (s: number) => Vector3;
-                        multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                        multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         applyEuler: (euler: import("three").Euler) => Vector3;
                         applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                         applyMatrix3: (m: import("three").Matrix3) => Vector3;
                         applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                         applyMatrix4: (m: Matrix4) => Vector3;
-                        applyQuaternion: (q: Quaternion) => Vector3;
+                        applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                         project: (camera: import("three").Camera) => Vector3;
                         unproject: (camera: import("three").Camera) => Vector3;
                         transformDirection: (m: Matrix4) => Vector3;
-                        divide: (v: Vector3) => Vector3;
+                        divide: (v: import("three").Vector3Like) => Vector3;
                         divideScalar: (s: number) => Vector3;
-                        min: (v: Vector3) => Vector3;
-                        max: (v: Vector3) => Vector3;
-                        clamp: (min: Vector3, max: Vector3) => Vector3;
+                        min: (v: import("three").Vector3Like) => Vector3;
+                        max: (v: import("three").Vector3Like) => Vector3;
+                        clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                         clampScalar: (min: number, max: number) => Vector3;
                         clampLength: (min: number, max: number) => Vector3;
                         floor: () => Vector3;
@@ -1254,25 +1245,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         round: () => Vector3;
                         roundToZero: () => Vector3;
                         negate: () => Vector3;
-                        dot: (v: Vector3) => number;
+                        dot: (v: import("three").Vector3Like) => number;
                         lengthSq: () => number;
                         length: () => number;
-                        lengthManhattan: () => number;
                         manhattanLength: () => number;
-                        manhattanDistanceTo: (v: Vector3) => number;
                         normalize: () => Vector3;
                         setLength: (l: number) => Vector3;
-                        lerp: (v: Vector3, alpha: number) => Vector3;
-                        lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                        cross: (a: Vector3) => Vector3;
-                        crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                        lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                        lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                        cross: (a: import("three").Vector3Like) => Vector3;
+                        crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         projectOnVector: (v: Vector3) => Vector3;
                         projectOnPlane: (planeNormal: Vector3) => Vector3;
-                        reflect: (vector: Vector3) => Vector3;
+                        reflect: (vector: import("three").Vector3Like) => Vector3;
                         angleTo: (v: Vector3) => number;
-                        distanceTo: (v: Vector3) => number;
-                        distanceToSquared: (v: Vector3) => number;
-                        distanceToManhattan: (v: Vector3) => number;
+                        distanceTo: (v: import("three").Vector3Like) => number;
+                        distanceToSquared: (v: import("three").Vector3Like) => number;
+                        manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                         setFromSpherical: (s: Spherical) => Vector3;
                         setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                         setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -1282,14 +1271,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                         setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                         setFromEuler: (e: import("three").Euler) => Vector3;
-                        equals: (v: Vector3) => boolean;
+                        setFromColor: (color: import("three").RGB) => Vector3;
+                        equals: (v: import("three").Vector3Like) => boolean;
                         fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                         toArray: {
                             (array?: number[] | undefined, offset?: number | undefined): number[];
                             (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                             (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                         random: () => Vector3;
                         randomDirection: () => Vector3;
                         [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -1334,7 +1324,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 stencilFail: import("three").StencilOp;
                 stencilZFail: import("three").StencilOp;
                 stencilZPass: import("three").StencilOp;
-                readonly isMaterial: true;
                 name: string;
                 needsUpdate: boolean;
                 opacity: number;
@@ -1353,12 +1342,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 uuid: string;
                 vertexColors: boolean;
                 visible: boolean;
-                userData: any;
+                userData: Record<string, any>;
                 version: number;
                 clone: () => import("three").Material;
                 copy: (material: import("three").Material) => import("three").Material;
                 dispose: () => void;
-                onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import("three").MaterialParameters) => void;
                 toJSON: (meta?: any) => any;
@@ -1385,6 +1374,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 }[T_6]) => void;
             } | undefined;
             customDistanceMaterial?: {
+                readonly isMaterial: true;
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
@@ -1431,7 +1421,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => number;
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
                 blendDst: import("three").BlendingDstFactor;
@@ -1454,34 +1444,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setY: (y: number) => Vector3;
                         setZ: (z: number) => Vector3;
                         setComponent: (index: number, value: number) => Vector3;
-                        setFromColor: (color: import("three").Color) => Vector3;
                         getComponent: (index: number) => number;
                         clone: () => Vector3;
-                        copy: (v: Vector3) => Vector3;
-                        add: (v: Vector3) => Vector3;
+                        copy: (v: import("three").Vector3Like) => Vector3;
+                        add: (v: import("three").Vector3Like) => Vector3;
                         addScalar: (s: number) => Vector3;
+                        addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         addScaledVector: (v: Vector3, s: number) => Vector3;
-                        addVectors: (a: Vector3, b: Vector3) => Vector3;
-                        sub: (a: Vector3) => Vector3;
+                        sub: (a: import("three").Vector3Like) => Vector3;
                         subScalar: (s: number) => Vector3;
-                        subVectors: (a: Vector3, b: Vector3) => Vector3;
-                        multiply: (v: Vector3) => Vector3;
+                        subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                        multiply: (v: import("three").Vector3Like) => Vector3;
                         multiplyScalar: (s: number) => Vector3;
-                        multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                        multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         applyEuler: (euler: import("three").Euler) => Vector3;
                         applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                         applyMatrix3: (m: import("three").Matrix3) => Vector3;
                         applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                         applyMatrix4: (m: Matrix4) => Vector3;
-                        applyQuaternion: (q: Quaternion) => Vector3;
+                        applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                         project: (camera: import("three").Camera) => Vector3;
                         unproject: (camera: import("three").Camera) => Vector3;
                         transformDirection: (m: Matrix4) => Vector3;
-                        divide: (v: Vector3) => Vector3;
+                        divide: (v: import("three").Vector3Like) => Vector3;
                         divideScalar: (s: number) => Vector3;
-                        min: (v: Vector3) => Vector3;
-                        max: (v: Vector3) => Vector3;
-                        clamp: (min: Vector3, max: Vector3) => Vector3;
+                        min: (v: import("three").Vector3Like) => Vector3;
+                        max: (v: import("three").Vector3Like) => Vector3;
+                        clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                         clampScalar: (min: number, max: number) => Vector3;
                         clampLength: (min: number, max: number) => Vector3;
                         floor: () => Vector3;
@@ -1489,25 +1478,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         round: () => Vector3;
                         roundToZero: () => Vector3;
                         negate: () => Vector3;
-                        dot: (v: Vector3) => number;
+                        dot: (v: import("three").Vector3Like) => number;
                         lengthSq: () => number;
                         length: () => number;
-                        lengthManhattan: () => number;
                         manhattanLength: () => number;
-                        manhattanDistanceTo: (v: Vector3) => number;
                         normalize: () => Vector3;
                         setLength: (l: number) => Vector3;
-                        lerp: (v: Vector3, alpha: number) => Vector3;
-                        lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                        cross: (a: Vector3) => Vector3;
-                        crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                        lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                        lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                        cross: (a: import("three").Vector3Like) => Vector3;
+                        crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         projectOnVector: (v: Vector3) => Vector3;
                         projectOnPlane: (planeNormal: Vector3) => Vector3;
-                        reflect: (vector: Vector3) => Vector3;
+                        reflect: (vector: import("three").Vector3Like) => Vector3;
                         angleTo: (v: Vector3) => number;
-                        distanceTo: (v: Vector3) => number;
-                        distanceToSquared: (v: Vector3) => number;
-                        distanceToManhattan: (v: Vector3) => number;
+                        distanceTo: (v: import("three").Vector3Like) => number;
+                        distanceToSquared: (v: import("three").Vector3Like) => number;
+                        manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                         setFromSpherical: (s: Spherical) => Vector3;
                         setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                         setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -1517,14 +1504,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                         setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                         setFromEuler: (e: import("three").Euler) => Vector3;
-                        equals: (v: Vector3) => boolean;
+                        setFromColor: (color: import("three").RGB) => Vector3;
+                        equals: (v: import("three").Vector3Like) => boolean;
                         fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                         toArray: {
                             (array?: number[] | undefined, offset?: number | undefined): number[];
                             (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                             (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                         random: () => Vector3;
                         randomDirection: () => Vector3;
                         [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -1569,7 +1557,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 stencilFail: import("three").StencilOp;
                 stencilZFail: import("three").StencilOp;
                 stencilZPass: import("three").StencilOp;
-                readonly isMaterial: true;
                 name: string;
                 needsUpdate: boolean;
                 opacity: number;
@@ -1588,12 +1575,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 uuid: string;
                 vertexColors: boolean;
                 visible: boolean;
-                userData: any;
+                userData: Record<string, any>;
                 version: number;
                 clone: () => import("three").Material;
                 copy: (material: import("three").Material) => import("three").Material;
                 dispose: () => void;
-                onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import("three").MaterialParameters) => void;
                 toJSON: (meta?: any) => any;
@@ -1619,6 +1606,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     dispose: {};
                 }[T_6]) => void;
             } | undefined;
+            onBeforeShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
             onBeforeRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
             onAfterRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
             applyMatrix4: (matrix: Matrix4) => void;
@@ -1650,7 +1639,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
             getObjectById: (id: number) => Object3D<import("three").Object3DEventMap> | undefined;
             getObjectByName: (name: string) => Object3D<import("three").Object3DEventMap> | undefined;
             getObjectByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap> | undefined;
-            getObjectsByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap>[];
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: Object3D<import("three").Object3DEventMap>[] | undefined) => Object3D<import("three").Object3DEventMap>[];
             getWorldPosition: (target: Vector3) => Vector3;
             getWorldQuaternion: (target: Quaternion) => Quaternion;
             getWorldScale: (target: Vector3) => Vector3;
@@ -1692,8 +1681,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
         };
         touches: {
             one: 0 | 8 | 16 | 32 | 64 | 128;
-            two: 0 | 1024 | 512 | 32 | 64 | 256 | 128 | 4096 | 2048 | 32768 | 8192 | 16384;
-            three: 0 | 1024 | 512 | 32 | 64 | 256 | 128 | 4096 | 2048 | 32768 | 8192 | 16384;
+            two: 0 | 1024 | 512 | 256 | 32 | 64 | 128 | 4096 | 2048 | 32768 | 8192 | 16384;
+            three: 0 | 1024 | 512 | 256 | 32 | 64 | 128 | 4096 | 2048 | 32768 | 8192 | 16384;
         };
         cancel: () => void;
         lockPointer: () => void;
@@ -1723,6 +1712,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
             getEffectiveFOV: () => number;
             getFilmWidth: () => number;
             getFilmHeight: () => number;
+            getViewBounds: (distance: number, minTarget: Vector2, maxTarget: Vector2) => void;
+            getViewSize: (distance: number, target: Vector2) => Vector2;
             setViewOffset: (fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number) => void;
             clearViewOffset: () => void;
             updateProjectionMatrix: () => void;
@@ -1941,34 +1932,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -1976,25 +1966,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -2004,14 +1992,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -2027,34 +2016,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -2062,25 +2050,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -2090,14 +2076,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -2130,11 +2117,11 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     readonly isQuaternion: true;
                     set: (x: number, y: number, z: number, w: number) => Quaternion;
                     clone: () => Quaternion;
-                    copy: (q: Quaternion) => Quaternion;
+                    copy: (q: import("three").QuaternionLike) => Quaternion;
                     setFromEuler: (euler: import("three").Euler, update?: boolean | undefined) => Quaternion;
-                    setFromAxisAngle: (axis: Vector3, angle: number) => Quaternion;
+                    setFromAxisAngle: (axis: import("three").Vector3Like, angle: number) => Quaternion;
                     setFromRotationMatrix: (m: Matrix4) => Quaternion;
-                    setFromUnitVectors: (vFrom: Vector3, vTo: Vector3) => Quaternion;
+                    setFromUnitVectors: (vFrom: Vector3, vTo: import("three").Vector3Like) => Quaternion;
                     angleTo: (q: Quaternion) => number;
                     rotateTowards: (q: Quaternion, step: number) => Quaternion;
                     identity: () => Quaternion;
@@ -2156,10 +2143,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => [number, number, number, number];
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Quaternion;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Quaternion;
                     _onChange: (callback: () => void) => Quaternion;
                     _onChangeCallback: () => void;
-                    multiplyVector3: (v: any) => any;
                     random: () => Quaternion;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
@@ -2174,34 +2160,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -2209,25 +2194,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -2237,14 +2220,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -2772,10 +2756,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     clone: () => import("three").AnimationClip;
                     toJSON: (clip: import("three").AnimationClip) => any;
                 }[];
-                userData: {
-                    [key: string]: any;
-                };
+                userData: Record<string, any>;
                 customDepthMaterial?: {
+                    readonly isMaterial: true;
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
@@ -2822,7 +2805,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
                         toJSON: () => number;
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                         [Symbol.iterator]: () => Generator<number, void, unknown>;
                     };
                     blendDst: import("three").BlendingDstFactor;
@@ -2845,34 +2828,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setY: (y: number) => Vector3;
                             setZ: (z: number) => Vector3;
                             setComponent: (index: number, value: number) => Vector3;
-                            setFromColor: (color: import("three").Color) => Vector3;
                             getComponent: (index: number) => number;
                             clone: () => Vector3;
-                            copy: (v: Vector3) => Vector3;
-                            add: (v: Vector3) => Vector3;
+                            copy: (v: import("three").Vector3Like) => Vector3;
+                            add: (v: import("three").Vector3Like) => Vector3;
                             addScalar: (s: number) => Vector3;
+                            addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             addScaledVector: (v: Vector3, s: number) => Vector3;
-                            addVectors: (a: Vector3, b: Vector3) => Vector3;
-                            sub: (a: Vector3) => Vector3;
+                            sub: (a: import("three").Vector3Like) => Vector3;
                             subScalar: (s: number) => Vector3;
-                            subVectors: (a: Vector3, b: Vector3) => Vector3;
-                            multiply: (v: Vector3) => Vector3;
+                            subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                            multiply: (v: import("three").Vector3Like) => Vector3;
                             multiplyScalar: (s: number) => Vector3;
-                            multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                            multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             applyEuler: (euler: import("three").Euler) => Vector3;
                             applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                             applyMatrix3: (m: import("three").Matrix3) => Vector3;
                             applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                             applyMatrix4: (m: Matrix4) => Vector3;
-                            applyQuaternion: (q: Quaternion) => Vector3;
+                            applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                             project: (camera: import("three").Camera) => Vector3;
                             unproject: (camera: import("three").Camera) => Vector3;
                             transformDirection: (m: Matrix4) => Vector3;
-                            divide: (v: Vector3) => Vector3;
+                            divide: (v: import("three").Vector3Like) => Vector3;
                             divideScalar: (s: number) => Vector3;
-                            min: (v: Vector3) => Vector3;
-                            max: (v: Vector3) => Vector3;
-                            clamp: (min: Vector3, max: Vector3) => Vector3;
+                            min: (v: import("three").Vector3Like) => Vector3;
+                            max: (v: import("three").Vector3Like) => Vector3;
+                            clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                             clampScalar: (min: number, max: number) => Vector3;
                             clampLength: (min: number, max: number) => Vector3;
                             floor: () => Vector3;
@@ -2880,25 +2862,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             round: () => Vector3;
                             roundToZero: () => Vector3;
                             negate: () => Vector3;
-                            dot: (v: Vector3) => number;
+                            dot: (v: import("three").Vector3Like) => number;
                             lengthSq: () => number;
                             length: () => number;
-                            lengthManhattan: () => number;
                             manhattanLength: () => number;
-                            manhattanDistanceTo: (v: Vector3) => number;
                             normalize: () => Vector3;
                             setLength: (l: number) => Vector3;
-                            lerp: (v: Vector3, alpha: number) => Vector3;
-                            lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                            cross: (a: Vector3) => Vector3;
-                            crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                            lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                            lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                            cross: (a: import("three").Vector3Like) => Vector3;
+                            crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             projectOnVector: (v: Vector3) => Vector3;
                             projectOnPlane: (planeNormal: Vector3) => Vector3;
-                            reflect: (vector: Vector3) => Vector3;
+                            reflect: (vector: import("three").Vector3Like) => Vector3;
                             angleTo: (v: Vector3) => number;
-                            distanceTo: (v: Vector3) => number;
-                            distanceToSquared: (v: Vector3) => number;
-                            distanceToManhattan: (v: Vector3) => number;
+                            distanceTo: (v: import("three").Vector3Like) => number;
+                            distanceToSquared: (v: import("three").Vector3Like) => number;
+                            manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                             setFromSpherical: (s: Spherical) => Vector3;
                             setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                             setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -2908,14 +2888,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                             setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                             setFromEuler: (e: import("three").Euler) => Vector3;
-                            equals: (v: Vector3) => boolean;
+                            setFromColor: (color: import("three").RGB) => Vector3;
+                            equals: (v: import("three").Vector3Like) => boolean;
                             fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                             toArray: {
                                 (array?: number[] | undefined, offset?: number | undefined): number[];
                                 (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                                 (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                             };
-                            fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                            fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                             random: () => Vector3;
                             randomDirection: () => Vector3;
                             [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -2960,7 +2941,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     stencilFail: import("three").StencilOp;
                     stencilZFail: import("three").StencilOp;
                     stencilZPass: import("three").StencilOp;
-                    readonly isMaterial: true;
                     name: string;
                     needsUpdate: boolean;
                     opacity: number;
@@ -2979,12 +2959,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     uuid: string;
                     vertexColors: boolean;
                     visible: boolean;
-                    userData: any;
+                    userData: Record<string, any>;
                     version: number;
                     clone: () => import("three").Material;
                     copy: (material: import("three").Material) => import("three").Material;
                     dispose: () => void;
-                    onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                    onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import("three").MaterialParameters) => void;
                     toJSON: (meta?: any) => any;
@@ -3011,6 +2991,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     }[T_6]) => void;
                 } | undefined;
                 customDistanceMaterial?: {
+                    readonly isMaterial: true;
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
@@ -3057,7 +3038,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
                         toJSON: () => number;
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                         [Symbol.iterator]: () => Generator<number, void, unknown>;
                     };
                     blendDst: import("three").BlendingDstFactor;
@@ -3080,34 +3061,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setY: (y: number) => Vector3;
                             setZ: (z: number) => Vector3;
                             setComponent: (index: number, value: number) => Vector3;
-                            setFromColor: (color: import("three").Color) => Vector3;
                             getComponent: (index: number) => number;
                             clone: () => Vector3;
-                            copy: (v: Vector3) => Vector3;
-                            add: (v: Vector3) => Vector3;
+                            copy: (v: import("three").Vector3Like) => Vector3;
+                            add: (v: import("three").Vector3Like) => Vector3;
                             addScalar: (s: number) => Vector3;
+                            addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             addScaledVector: (v: Vector3, s: number) => Vector3;
-                            addVectors: (a: Vector3, b: Vector3) => Vector3;
-                            sub: (a: Vector3) => Vector3;
+                            sub: (a: import("three").Vector3Like) => Vector3;
                             subScalar: (s: number) => Vector3;
-                            subVectors: (a: Vector3, b: Vector3) => Vector3;
-                            multiply: (v: Vector3) => Vector3;
+                            subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                            multiply: (v: import("three").Vector3Like) => Vector3;
                             multiplyScalar: (s: number) => Vector3;
-                            multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                            multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             applyEuler: (euler: import("three").Euler) => Vector3;
                             applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                             applyMatrix3: (m: import("three").Matrix3) => Vector3;
                             applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                             applyMatrix4: (m: Matrix4) => Vector3;
-                            applyQuaternion: (q: Quaternion) => Vector3;
+                            applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                             project: (camera: import("three").Camera) => Vector3;
                             unproject: (camera: import("three").Camera) => Vector3;
                             transformDirection: (m: Matrix4) => Vector3;
-                            divide: (v: Vector3) => Vector3;
+                            divide: (v: import("three").Vector3Like) => Vector3;
                             divideScalar: (s: number) => Vector3;
-                            min: (v: Vector3) => Vector3;
-                            max: (v: Vector3) => Vector3;
-                            clamp: (min: Vector3, max: Vector3) => Vector3;
+                            min: (v: import("three").Vector3Like) => Vector3;
+                            max: (v: import("three").Vector3Like) => Vector3;
+                            clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                             clampScalar: (min: number, max: number) => Vector3;
                             clampLength: (min: number, max: number) => Vector3;
                             floor: () => Vector3;
@@ -3115,25 +3095,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             round: () => Vector3;
                             roundToZero: () => Vector3;
                             negate: () => Vector3;
-                            dot: (v: Vector3) => number;
+                            dot: (v: import("three").Vector3Like) => number;
                             lengthSq: () => number;
                             length: () => number;
-                            lengthManhattan: () => number;
                             manhattanLength: () => number;
-                            manhattanDistanceTo: (v: Vector3) => number;
                             normalize: () => Vector3;
                             setLength: (l: number) => Vector3;
-                            lerp: (v: Vector3, alpha: number) => Vector3;
-                            lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                            cross: (a: Vector3) => Vector3;
-                            crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                            lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                            lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                            cross: (a: import("three").Vector3Like) => Vector3;
+                            crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             projectOnVector: (v: Vector3) => Vector3;
                             projectOnPlane: (planeNormal: Vector3) => Vector3;
-                            reflect: (vector: Vector3) => Vector3;
+                            reflect: (vector: import("three").Vector3Like) => Vector3;
                             angleTo: (v: Vector3) => number;
-                            distanceTo: (v: Vector3) => number;
-                            distanceToSquared: (v: Vector3) => number;
-                            distanceToManhattan: (v: Vector3) => number;
+                            distanceTo: (v: import("three").Vector3Like) => number;
+                            distanceToSquared: (v: import("three").Vector3Like) => number;
+                            manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                             setFromSpherical: (s: Spherical) => Vector3;
                             setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                             setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -3143,14 +3121,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                             setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                             setFromEuler: (e: import("three").Euler) => Vector3;
-                            equals: (v: Vector3) => boolean;
+                            setFromColor: (color: import("three").RGB) => Vector3;
+                            equals: (v: import("three").Vector3Like) => boolean;
                             fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                             toArray: {
                                 (array?: number[] | undefined, offset?: number | undefined): number[];
                                 (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                                 (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                             };
-                            fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                            fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                             random: () => Vector3;
                             randomDirection: () => Vector3;
                             [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -3195,7 +3174,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     stencilFail: import("three").StencilOp;
                     stencilZFail: import("three").StencilOp;
                     stencilZPass: import("three").StencilOp;
-                    readonly isMaterial: true;
                     name: string;
                     needsUpdate: boolean;
                     opacity: number;
@@ -3214,12 +3192,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     uuid: string;
                     vertexColors: boolean;
                     visible: boolean;
-                    userData: any;
+                    userData: Record<string, any>;
                     version: number;
                     clone: () => import("three").Material;
                     copy: (material: import("three").Material) => import("three").Material;
                     dispose: () => void;
-                    onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                    onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import("three").MaterialParameters) => void;
                     toJSON: (meta?: any) => any;
@@ -3245,6 +3223,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
+                onBeforeShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+                onAfterShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 onBeforeRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 onAfterRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 applyMatrix4: (matrix: Matrix4) => void;
@@ -3276,7 +3256,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 getObjectById: (id: number) => Object3D<import("three").Object3DEventMap> | undefined;
                 getObjectByName: (name: string) => Object3D<import("three").Object3DEventMap> | undefined;
                 getObjectByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap> | undefined;
-                getObjectsByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap>[];
+                getObjectsByProperty: (name: string, value: any, optionalTarget?: Object3D<import("three").Object3DEventMap>[] | undefined) => Object3D<import("three").Object3DEventMap>[];
                 getWorldPosition: (target: Vector3) => Vector3;
                 getWorldQuaternion: (target: Quaternion) => Quaternion;
                 getWorldScale: (target: Vector3) => Vector3;
@@ -3329,34 +3309,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -3364,25 +3343,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -3392,14 +3369,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -3415,34 +3393,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -3450,25 +3427,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -3478,14 +3453,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -3518,11 +3494,11 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     readonly isQuaternion: true;
                     set: (x: number, y: number, z: number, w: number) => Quaternion;
                     clone: () => Quaternion;
-                    copy: (q: Quaternion) => Quaternion;
+                    copy: (q: import("three").QuaternionLike) => Quaternion;
                     setFromEuler: (euler: import("three").Euler, update?: boolean | undefined) => Quaternion;
-                    setFromAxisAngle: (axis: Vector3, angle: number) => Quaternion;
+                    setFromAxisAngle: (axis: import("three").Vector3Like, angle: number) => Quaternion;
                     setFromRotationMatrix: (m: Matrix4) => Quaternion;
-                    setFromUnitVectors: (vFrom: Vector3, vTo: Vector3) => Quaternion;
+                    setFromUnitVectors: (vFrom: Vector3, vTo: import("three").Vector3Like) => Quaternion;
                     angleTo: (q: Quaternion) => number;
                     rotateTowards: (q: Quaternion, step: number) => Quaternion;
                     identity: () => Quaternion;
@@ -3544,10 +3520,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => [number, number, number, number];
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Quaternion;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Quaternion;
                     _onChange: (callback: () => void) => Quaternion;
                     _onChangeCallback: () => void;
-                    multiplyVector3: (v: any) => any;
                     random: () => Quaternion;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
@@ -3562,34 +3537,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -3597,25 +3571,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -3625,14 +3597,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -4160,10 +4133,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     clone: () => import("three").AnimationClip;
                     toJSON: (clip: import("three").AnimationClip) => any;
                 }[];
-                userData: {
-                    [key: string]: any;
-                };
+                userData: Record<string, any>;
                 customDepthMaterial?: {
+                    readonly isMaterial: true;
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
@@ -4210,7 +4182,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
                         toJSON: () => number;
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                         [Symbol.iterator]: () => Generator<number, void, unknown>;
                     };
                     blendDst: import("three").BlendingDstFactor;
@@ -4233,34 +4205,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setY: (y: number) => Vector3;
                             setZ: (z: number) => Vector3;
                             setComponent: (index: number, value: number) => Vector3;
-                            setFromColor: (color: import("three").Color) => Vector3;
                             getComponent: (index: number) => number;
                             clone: () => Vector3;
-                            copy: (v: Vector3) => Vector3;
-                            add: (v: Vector3) => Vector3;
+                            copy: (v: import("three").Vector3Like) => Vector3;
+                            add: (v: import("three").Vector3Like) => Vector3;
                             addScalar: (s: number) => Vector3;
+                            addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             addScaledVector: (v: Vector3, s: number) => Vector3;
-                            addVectors: (a: Vector3, b: Vector3) => Vector3;
-                            sub: (a: Vector3) => Vector3;
+                            sub: (a: import("three").Vector3Like) => Vector3;
                             subScalar: (s: number) => Vector3;
-                            subVectors: (a: Vector3, b: Vector3) => Vector3;
-                            multiply: (v: Vector3) => Vector3;
+                            subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                            multiply: (v: import("three").Vector3Like) => Vector3;
                             multiplyScalar: (s: number) => Vector3;
-                            multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                            multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             applyEuler: (euler: import("three").Euler) => Vector3;
                             applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                             applyMatrix3: (m: import("three").Matrix3) => Vector3;
                             applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                             applyMatrix4: (m: Matrix4) => Vector3;
-                            applyQuaternion: (q: Quaternion) => Vector3;
+                            applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                             project: (camera: import("three").Camera) => Vector3;
                             unproject: (camera: import("three").Camera) => Vector3;
                             transformDirection: (m: Matrix4) => Vector3;
-                            divide: (v: Vector3) => Vector3;
+                            divide: (v: import("three").Vector3Like) => Vector3;
                             divideScalar: (s: number) => Vector3;
-                            min: (v: Vector3) => Vector3;
-                            max: (v: Vector3) => Vector3;
-                            clamp: (min: Vector3, max: Vector3) => Vector3;
+                            min: (v: import("three").Vector3Like) => Vector3;
+                            max: (v: import("three").Vector3Like) => Vector3;
+                            clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                             clampScalar: (min: number, max: number) => Vector3;
                             clampLength: (min: number, max: number) => Vector3;
                             floor: () => Vector3;
@@ -4268,25 +4239,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             round: () => Vector3;
                             roundToZero: () => Vector3;
                             negate: () => Vector3;
-                            dot: (v: Vector3) => number;
+                            dot: (v: import("three").Vector3Like) => number;
                             lengthSq: () => number;
                             length: () => number;
-                            lengthManhattan: () => number;
                             manhattanLength: () => number;
-                            manhattanDistanceTo: (v: Vector3) => number;
                             normalize: () => Vector3;
                             setLength: (l: number) => Vector3;
-                            lerp: (v: Vector3, alpha: number) => Vector3;
-                            lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                            cross: (a: Vector3) => Vector3;
-                            crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                            lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                            lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                            cross: (a: import("three").Vector3Like) => Vector3;
+                            crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             projectOnVector: (v: Vector3) => Vector3;
                             projectOnPlane: (planeNormal: Vector3) => Vector3;
-                            reflect: (vector: Vector3) => Vector3;
+                            reflect: (vector: import("three").Vector3Like) => Vector3;
                             angleTo: (v: Vector3) => number;
-                            distanceTo: (v: Vector3) => number;
-                            distanceToSquared: (v: Vector3) => number;
-                            distanceToManhattan: (v: Vector3) => number;
+                            distanceTo: (v: import("three").Vector3Like) => number;
+                            distanceToSquared: (v: import("three").Vector3Like) => number;
+                            manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                             setFromSpherical: (s: Spherical) => Vector3;
                             setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                             setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -4296,14 +4265,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                             setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                             setFromEuler: (e: import("three").Euler) => Vector3;
-                            equals: (v: Vector3) => boolean;
+                            setFromColor: (color: import("three").RGB) => Vector3;
+                            equals: (v: import("three").Vector3Like) => boolean;
                             fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                             toArray: {
                                 (array?: number[] | undefined, offset?: number | undefined): number[];
                                 (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                                 (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                             };
-                            fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                            fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                             random: () => Vector3;
                             randomDirection: () => Vector3;
                             [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -4348,7 +4318,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     stencilFail: import("three").StencilOp;
                     stencilZFail: import("three").StencilOp;
                     stencilZPass: import("three").StencilOp;
-                    readonly isMaterial: true;
                     name: string;
                     needsUpdate: boolean;
                     opacity: number;
@@ -4367,12 +4336,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     uuid: string;
                     vertexColors: boolean;
                     visible: boolean;
-                    userData: any;
+                    userData: Record<string, any>;
                     version: number;
                     clone: () => import("three").Material;
                     copy: (material: import("three").Material) => import("three").Material;
                     dispose: () => void;
-                    onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                    onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import("three").MaterialParameters) => void;
                     toJSON: (meta?: any) => any;
@@ -4399,6 +4368,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     }[T_6]) => void;
                 } | undefined;
                 customDistanceMaterial?: {
+                    readonly isMaterial: true;
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
@@ -4445,7 +4415,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
                         toJSON: () => number;
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                         [Symbol.iterator]: () => Generator<number, void, unknown>;
                     };
                     blendDst: import("three").BlendingDstFactor;
@@ -4468,34 +4438,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setY: (y: number) => Vector3;
                             setZ: (z: number) => Vector3;
                             setComponent: (index: number, value: number) => Vector3;
-                            setFromColor: (color: import("three").Color) => Vector3;
                             getComponent: (index: number) => number;
                             clone: () => Vector3;
-                            copy: (v: Vector3) => Vector3;
-                            add: (v: Vector3) => Vector3;
+                            copy: (v: import("three").Vector3Like) => Vector3;
+                            add: (v: import("three").Vector3Like) => Vector3;
                             addScalar: (s: number) => Vector3;
+                            addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             addScaledVector: (v: Vector3, s: number) => Vector3;
-                            addVectors: (a: Vector3, b: Vector3) => Vector3;
-                            sub: (a: Vector3) => Vector3;
+                            sub: (a: import("three").Vector3Like) => Vector3;
                             subScalar: (s: number) => Vector3;
-                            subVectors: (a: Vector3, b: Vector3) => Vector3;
-                            multiply: (v: Vector3) => Vector3;
+                            subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                            multiply: (v: import("three").Vector3Like) => Vector3;
                             multiplyScalar: (s: number) => Vector3;
-                            multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                            multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             applyEuler: (euler: import("three").Euler) => Vector3;
                             applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                             applyMatrix3: (m: import("three").Matrix3) => Vector3;
                             applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                             applyMatrix4: (m: Matrix4) => Vector3;
-                            applyQuaternion: (q: Quaternion) => Vector3;
+                            applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                             project: (camera: import("three").Camera) => Vector3;
                             unproject: (camera: import("three").Camera) => Vector3;
                             transformDirection: (m: Matrix4) => Vector3;
-                            divide: (v: Vector3) => Vector3;
+                            divide: (v: import("three").Vector3Like) => Vector3;
                             divideScalar: (s: number) => Vector3;
-                            min: (v: Vector3) => Vector3;
-                            max: (v: Vector3) => Vector3;
-                            clamp: (min: Vector3, max: Vector3) => Vector3;
+                            min: (v: import("three").Vector3Like) => Vector3;
+                            max: (v: import("three").Vector3Like) => Vector3;
+                            clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                             clampScalar: (min: number, max: number) => Vector3;
                             clampLength: (min: number, max: number) => Vector3;
                             floor: () => Vector3;
@@ -4503,25 +4472,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             round: () => Vector3;
                             roundToZero: () => Vector3;
                             negate: () => Vector3;
-                            dot: (v: Vector3) => number;
+                            dot: (v: import("three").Vector3Like) => number;
                             lengthSq: () => number;
                             length: () => number;
-                            lengthManhattan: () => number;
                             manhattanLength: () => number;
-                            manhattanDistanceTo: (v: Vector3) => number;
                             normalize: () => Vector3;
                             setLength: (l: number) => Vector3;
-                            lerp: (v: Vector3, alpha: number) => Vector3;
-                            lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                            cross: (a: Vector3) => Vector3;
-                            crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                            lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                            lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                            cross: (a: import("three").Vector3Like) => Vector3;
+                            crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             projectOnVector: (v: Vector3) => Vector3;
                             projectOnPlane: (planeNormal: Vector3) => Vector3;
-                            reflect: (vector: Vector3) => Vector3;
+                            reflect: (vector: import("three").Vector3Like) => Vector3;
                             angleTo: (v: Vector3) => number;
-                            distanceTo: (v: Vector3) => number;
-                            distanceToSquared: (v: Vector3) => number;
-                            distanceToManhattan: (v: Vector3) => number;
+                            distanceTo: (v: import("three").Vector3Like) => number;
+                            distanceToSquared: (v: import("three").Vector3Like) => number;
+                            manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                             setFromSpherical: (s: Spherical) => Vector3;
                             setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                             setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -4531,14 +4498,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                             setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                             setFromEuler: (e: import("three").Euler) => Vector3;
-                            equals: (v: Vector3) => boolean;
+                            setFromColor: (color: import("three").RGB) => Vector3;
+                            equals: (v: import("three").Vector3Like) => boolean;
                             fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                             toArray: {
                                 (array?: number[] | undefined, offset?: number | undefined): number[];
                                 (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                                 (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                             };
-                            fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                            fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                             random: () => Vector3;
                             randomDirection: () => Vector3;
                             [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -4583,7 +4551,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     stencilFail: import("three").StencilOp;
                     stencilZFail: import("three").StencilOp;
                     stencilZPass: import("three").StencilOp;
-                    readonly isMaterial: true;
                     name: string;
                     needsUpdate: boolean;
                     opacity: number;
@@ -4602,12 +4569,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     uuid: string;
                     vertexColors: boolean;
                     visible: boolean;
-                    userData: any;
+                    userData: Record<string, any>;
                     version: number;
                     clone: () => import("three").Material;
                     copy: (material: import("three").Material) => import("three").Material;
                     dispose: () => void;
-                    onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                    onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import("three").MaterialParameters) => void;
                     toJSON: (meta?: any) => any;
@@ -4633,6 +4600,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
+                onBeforeShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+                onAfterShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 onBeforeRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 onAfterRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 applyMatrix4: (matrix: Matrix4) => void;
@@ -4664,7 +4633,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 getObjectById: (id: number) => Object3D<import("three").Object3DEventMap> | undefined;
                 getObjectByName: (name: string) => Object3D<import("three").Object3DEventMap> | undefined;
                 getObjectByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap> | undefined;
-                getObjectsByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap>[];
+                getObjectsByProperty: (name: string, value: any, optionalTarget?: Object3D<import("three").Object3DEventMap>[] | undefined) => Object3D<import("three").Object3DEventMap>[];
                 getWorldPosition: (target: Vector3) => Vector3;
                 getWorldQuaternion: (target: Quaternion) => Quaternion;
                 getWorldScale: (target: Vector3) => Vector3;
@@ -4709,34 +4678,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setY: (y: number) => Vector3;
                 setZ: (z: number) => Vector3;
                 setComponent: (index: number, value: number) => Vector3;
-                setFromColor: (color: import("three").Color) => Vector3;
                 getComponent: (index: number) => number;
                 clone: () => Vector3;
-                copy: (v: Vector3) => Vector3;
-                add: (v: Vector3) => Vector3;
+                copy: (v: import("three").Vector3Like) => Vector3;
+                add: (v: import("three").Vector3Like) => Vector3;
                 addScalar: (s: number) => Vector3;
+                addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 addScaledVector: (v: Vector3, s: number) => Vector3;
-                addVectors: (a: Vector3, b: Vector3) => Vector3;
-                sub: (a: Vector3) => Vector3;
+                sub: (a: import("three").Vector3Like) => Vector3;
                 subScalar: (s: number) => Vector3;
-                subVectors: (a: Vector3, b: Vector3) => Vector3;
-                multiply: (v: Vector3) => Vector3;
+                subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                multiply: (v: import("three").Vector3Like) => Vector3;
                 multiplyScalar: (s: number) => Vector3;
-                multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 applyEuler: (euler: import("three").Euler) => Vector3;
                 applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                 applyMatrix3: (m: import("three").Matrix3) => Vector3;
                 applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                 applyMatrix4: (m: Matrix4) => Vector3;
-                applyQuaternion: (q: Quaternion) => Vector3;
+                applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                 project: (camera: import("three").Camera) => Vector3;
                 unproject: (camera: import("three").Camera) => Vector3;
                 transformDirection: (m: Matrix4) => Vector3;
-                divide: (v: Vector3) => Vector3;
+                divide: (v: import("three").Vector3Like) => Vector3;
                 divideScalar: (s: number) => Vector3;
-                min: (v: Vector3) => Vector3;
-                max: (v: Vector3) => Vector3;
-                clamp: (min: Vector3, max: Vector3) => Vector3;
+                min: (v: import("three").Vector3Like) => Vector3;
+                max: (v: import("three").Vector3Like) => Vector3;
+                clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                 clampScalar: (min: number, max: number) => Vector3;
                 clampLength: (min: number, max: number) => Vector3;
                 floor: () => Vector3;
@@ -4744,25 +4712,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 round: () => Vector3;
                 roundToZero: () => Vector3;
                 negate: () => Vector3;
-                dot: (v: Vector3) => number;
+                dot: (v: import("three").Vector3Like) => number;
                 lengthSq: () => number;
                 length: () => number;
-                lengthManhattan: () => number;
                 manhattanLength: () => number;
-                manhattanDistanceTo: (v: Vector3) => number;
                 normalize: () => Vector3;
                 setLength: (l: number) => Vector3;
-                lerp: (v: Vector3, alpha: number) => Vector3;
-                lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                cross: (a: Vector3) => Vector3;
-                crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                cross: (a: import("three").Vector3Like) => Vector3;
+                crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 projectOnVector: (v: Vector3) => Vector3;
                 projectOnPlane: (planeNormal: Vector3) => Vector3;
-                reflect: (vector: Vector3) => Vector3;
+                reflect: (vector: import("three").Vector3Like) => Vector3;
                 angleTo: (v: Vector3) => number;
-                distanceTo: (v: Vector3) => number;
-                distanceToSquared: (v: Vector3) => number;
-                distanceToManhattan: (v: Vector3) => number;
+                distanceTo: (v: import("three").Vector3Like) => number;
+                distanceToSquared: (v: import("three").Vector3Like) => number;
+                manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                 setFromSpherical: (s: Spherical) => Vector3;
                 setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                 setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -4772,14 +4738,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                 setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                 setFromEuler: (e: import("three").Euler) => Vector3;
-                equals: (v: Vector3) => boolean;
+                setFromColor: (color: import("three").RGB) => Vector3;
+                equals: (v: import("three").Vector3Like) => boolean;
                 fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                 toArray: {
                     (array?: number[] | undefined, offset?: number | undefined): number[];
                     (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                 random: () => Vector3;
                 randomDirection: () => Vector3;
                 [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -4795,34 +4762,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setY: (y: number) => Vector3;
                 setZ: (z: number) => Vector3;
                 setComponent: (index: number, value: number) => Vector3;
-                setFromColor: (color: import("three").Color) => Vector3;
                 getComponent: (index: number) => number;
                 clone: () => Vector3;
-                copy: (v: Vector3) => Vector3;
-                add: (v: Vector3) => Vector3;
+                copy: (v: import("three").Vector3Like) => Vector3;
+                add: (v: import("three").Vector3Like) => Vector3;
                 addScalar: (s: number) => Vector3;
+                addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 addScaledVector: (v: Vector3, s: number) => Vector3;
-                addVectors: (a: Vector3, b: Vector3) => Vector3;
-                sub: (a: Vector3) => Vector3;
+                sub: (a: import("three").Vector3Like) => Vector3;
                 subScalar: (s: number) => Vector3;
-                subVectors: (a: Vector3, b: Vector3) => Vector3;
-                multiply: (v: Vector3) => Vector3;
+                subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                multiply: (v: import("three").Vector3Like) => Vector3;
                 multiplyScalar: (s: number) => Vector3;
-                multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 applyEuler: (euler: import("three").Euler) => Vector3;
                 applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                 applyMatrix3: (m: import("three").Matrix3) => Vector3;
                 applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                 applyMatrix4: (m: Matrix4) => Vector3;
-                applyQuaternion: (q: Quaternion) => Vector3;
+                applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                 project: (camera: import("three").Camera) => Vector3;
                 unproject: (camera: import("three").Camera) => Vector3;
                 transformDirection: (m: Matrix4) => Vector3;
-                divide: (v: Vector3) => Vector3;
+                divide: (v: import("three").Vector3Like) => Vector3;
                 divideScalar: (s: number) => Vector3;
-                min: (v: Vector3) => Vector3;
-                max: (v: Vector3) => Vector3;
-                clamp: (min: Vector3, max: Vector3) => Vector3;
+                min: (v: import("three").Vector3Like) => Vector3;
+                max: (v: import("three").Vector3Like) => Vector3;
+                clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                 clampScalar: (min: number, max: number) => Vector3;
                 clampLength: (min: number, max: number) => Vector3;
                 floor: () => Vector3;
@@ -4830,25 +4796,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 round: () => Vector3;
                 roundToZero: () => Vector3;
                 negate: () => Vector3;
-                dot: (v: Vector3) => number;
+                dot: (v: import("three").Vector3Like) => number;
                 lengthSq: () => number;
                 length: () => number;
-                lengthManhattan: () => number;
                 manhattanLength: () => number;
-                manhattanDistanceTo: (v: Vector3) => number;
                 normalize: () => Vector3;
                 setLength: (l: number) => Vector3;
-                lerp: (v: Vector3, alpha: number) => Vector3;
-                lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                cross: (a: Vector3) => Vector3;
-                crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                cross: (a: import("three").Vector3Like) => Vector3;
+                crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 projectOnVector: (v: Vector3) => Vector3;
                 projectOnPlane: (planeNormal: Vector3) => Vector3;
-                reflect: (vector: Vector3) => Vector3;
+                reflect: (vector: import("three").Vector3Like) => Vector3;
                 angleTo: (v: Vector3) => number;
-                distanceTo: (v: Vector3) => number;
-                distanceToSquared: (v: Vector3) => number;
-                distanceToManhattan: (v: Vector3) => number;
+                distanceTo: (v: import("three").Vector3Like) => number;
+                distanceToSquared: (v: import("three").Vector3Like) => number;
+                manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                 setFromSpherical: (s: Spherical) => Vector3;
                 setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                 setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -4858,14 +4822,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                 setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                 setFromEuler: (e: import("three").Euler) => Vector3;
-                equals: (v: Vector3) => boolean;
+                setFromColor: (color: import("three").RGB) => Vector3;
+                equals: (v: import("three").Vector3Like) => boolean;
                 fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                 toArray: {
                     (array?: number[] | undefined, offset?: number | undefined): number[];
                     (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                 random: () => Vector3;
                 randomDirection: () => Vector3;
                 [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -4898,11 +4863,11 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 readonly isQuaternion: true;
                 set: (x: number, y: number, z: number, w: number) => Quaternion;
                 clone: () => Quaternion;
-                copy: (q: Quaternion) => Quaternion;
+                copy: (q: import("three").QuaternionLike) => Quaternion;
                 setFromEuler: (euler: import("three").Euler, update?: boolean | undefined) => Quaternion;
-                setFromAxisAngle: (axis: Vector3, angle: number) => Quaternion;
+                setFromAxisAngle: (axis: import("three").Vector3Like, angle: number) => Quaternion;
                 setFromRotationMatrix: (m: Matrix4) => Quaternion;
-                setFromUnitVectors: (vFrom: Vector3, vTo: Vector3) => Quaternion;
+                setFromUnitVectors: (vFrom: Vector3, vTo: import("three").Vector3Like) => Quaternion;
                 angleTo: (q: Quaternion) => number;
                 rotateTowards: (q: Quaternion, step: number) => Quaternion;
                 identity: () => Quaternion;
@@ -4924,10 +4889,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
                 toJSON: () => [number, number, number, number];
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Quaternion;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Quaternion;
                 _onChange: (callback: () => void) => Quaternion;
                 _onChangeCallback: () => void;
-                multiplyVector3: (v: any) => any;
                 random: () => Quaternion;
                 [Symbol.iterator]: () => Generator<number, void, unknown>;
             };
@@ -4942,34 +4906,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setY: (y: number) => Vector3;
                 setZ: (z: number) => Vector3;
                 setComponent: (index: number, value: number) => Vector3;
-                setFromColor: (color: import("three").Color) => Vector3;
                 getComponent: (index: number) => number;
                 clone: () => Vector3;
-                copy: (v: Vector3) => Vector3;
-                add: (v: Vector3) => Vector3;
+                copy: (v: import("three").Vector3Like) => Vector3;
+                add: (v: import("three").Vector3Like) => Vector3;
                 addScalar: (s: number) => Vector3;
+                addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 addScaledVector: (v: Vector3, s: number) => Vector3;
-                addVectors: (a: Vector3, b: Vector3) => Vector3;
-                sub: (a: Vector3) => Vector3;
+                sub: (a: import("three").Vector3Like) => Vector3;
                 subScalar: (s: number) => Vector3;
-                subVectors: (a: Vector3, b: Vector3) => Vector3;
-                multiply: (v: Vector3) => Vector3;
+                subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                multiply: (v: import("three").Vector3Like) => Vector3;
                 multiplyScalar: (s: number) => Vector3;
-                multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 applyEuler: (euler: import("three").Euler) => Vector3;
                 applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                 applyMatrix3: (m: import("three").Matrix3) => Vector3;
                 applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                 applyMatrix4: (m: Matrix4) => Vector3;
-                applyQuaternion: (q: Quaternion) => Vector3;
+                applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                 project: (camera: import("three").Camera) => Vector3;
                 unproject: (camera: import("three").Camera) => Vector3;
                 transformDirection: (m: Matrix4) => Vector3;
-                divide: (v: Vector3) => Vector3;
+                divide: (v: import("three").Vector3Like) => Vector3;
                 divideScalar: (s: number) => Vector3;
-                min: (v: Vector3) => Vector3;
-                max: (v: Vector3) => Vector3;
-                clamp: (min: Vector3, max: Vector3) => Vector3;
+                min: (v: import("three").Vector3Like) => Vector3;
+                max: (v: import("three").Vector3Like) => Vector3;
+                clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                 clampScalar: (min: number, max: number) => Vector3;
                 clampLength: (min: number, max: number) => Vector3;
                 floor: () => Vector3;
@@ -4977,25 +4940,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 round: () => Vector3;
                 roundToZero: () => Vector3;
                 negate: () => Vector3;
-                dot: (v: Vector3) => number;
+                dot: (v: import("three").Vector3Like) => number;
                 lengthSq: () => number;
                 length: () => number;
-                lengthManhattan: () => number;
                 manhattanLength: () => number;
-                manhattanDistanceTo: (v: Vector3) => number;
                 normalize: () => Vector3;
                 setLength: (l: number) => Vector3;
-                lerp: (v: Vector3, alpha: number) => Vector3;
-                lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                cross: (a: Vector3) => Vector3;
-                crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                cross: (a: import("three").Vector3Like) => Vector3;
+                crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 projectOnVector: (v: Vector3) => Vector3;
                 projectOnPlane: (planeNormal: Vector3) => Vector3;
-                reflect: (vector: Vector3) => Vector3;
+                reflect: (vector: import("three").Vector3Like) => Vector3;
                 angleTo: (v: Vector3) => number;
-                distanceTo: (v: Vector3) => number;
-                distanceToSquared: (v: Vector3) => number;
-                distanceToManhattan: (v: Vector3) => number;
+                distanceTo: (v: import("three").Vector3Like) => number;
+                distanceToSquared: (v: import("three").Vector3Like) => number;
+                manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                 setFromSpherical: (s: Spherical) => Vector3;
                 setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                 setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -5005,14 +4966,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                 setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                 setFromEuler: (e: import("three").Euler) => Vector3;
-                equals: (v: Vector3) => boolean;
+                setFromColor: (color: import("three").RGB) => Vector3;
+                equals: (v: import("three").Vector3Like) => boolean;
                 fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                 toArray: {
                     (array?: number[] | undefined, offset?: number | undefined): number[];
                     (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                 random: () => Vector3;
                 randomDirection: () => Vector3;
                 [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -5529,10 +5491,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 clone: () => import("three").AnimationClip;
                 toJSON: (clip: import("three").AnimationClip) => any;
             }[];
-            userData: {
-                [key: string]: any;
-            };
+            userData: Record<string, any>;
             customDepthMaterial?: {
+                readonly isMaterial: true;
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
@@ -5579,7 +5540,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => number;
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
                 blendDst: import("three").BlendingDstFactor;
@@ -5602,34 +5563,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setY: (y: number) => Vector3;
                         setZ: (z: number) => Vector3;
                         setComponent: (index: number, value: number) => Vector3;
-                        setFromColor: (color: import("three").Color) => Vector3;
                         getComponent: (index: number) => number;
                         clone: () => Vector3;
-                        copy: (v: Vector3) => Vector3;
-                        add: (v: Vector3) => Vector3;
+                        copy: (v: import("three").Vector3Like) => Vector3;
+                        add: (v: import("three").Vector3Like) => Vector3;
                         addScalar: (s: number) => Vector3;
+                        addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         addScaledVector: (v: Vector3, s: number) => Vector3;
-                        addVectors: (a: Vector3, b: Vector3) => Vector3;
-                        sub: (a: Vector3) => Vector3;
+                        sub: (a: import("three").Vector3Like) => Vector3;
                         subScalar: (s: number) => Vector3;
-                        subVectors: (a: Vector3, b: Vector3) => Vector3;
-                        multiply: (v: Vector3) => Vector3;
+                        subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                        multiply: (v: import("three").Vector3Like) => Vector3;
                         multiplyScalar: (s: number) => Vector3;
-                        multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                        multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         applyEuler: (euler: import("three").Euler) => Vector3;
                         applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                         applyMatrix3: (m: import("three").Matrix3) => Vector3;
                         applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                         applyMatrix4: (m: Matrix4) => Vector3;
-                        applyQuaternion: (q: Quaternion) => Vector3;
+                        applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                         project: (camera: import("three").Camera) => Vector3;
                         unproject: (camera: import("three").Camera) => Vector3;
                         transformDirection: (m: Matrix4) => Vector3;
-                        divide: (v: Vector3) => Vector3;
+                        divide: (v: import("three").Vector3Like) => Vector3;
                         divideScalar: (s: number) => Vector3;
-                        min: (v: Vector3) => Vector3;
-                        max: (v: Vector3) => Vector3;
-                        clamp: (min: Vector3, max: Vector3) => Vector3;
+                        min: (v: import("three").Vector3Like) => Vector3;
+                        max: (v: import("three").Vector3Like) => Vector3;
+                        clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                         clampScalar: (min: number, max: number) => Vector3;
                         clampLength: (min: number, max: number) => Vector3;
                         floor: () => Vector3;
@@ -5637,25 +5597,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         round: () => Vector3;
                         roundToZero: () => Vector3;
                         negate: () => Vector3;
-                        dot: (v: Vector3) => number;
+                        dot: (v: import("three").Vector3Like) => number;
                         lengthSq: () => number;
                         length: () => number;
-                        lengthManhattan: () => number;
                         manhattanLength: () => number;
-                        manhattanDistanceTo: (v: Vector3) => number;
                         normalize: () => Vector3;
                         setLength: (l: number) => Vector3;
-                        lerp: (v: Vector3, alpha: number) => Vector3;
-                        lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                        cross: (a: Vector3) => Vector3;
-                        crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                        lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                        lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                        cross: (a: import("three").Vector3Like) => Vector3;
+                        crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         projectOnVector: (v: Vector3) => Vector3;
                         projectOnPlane: (planeNormal: Vector3) => Vector3;
-                        reflect: (vector: Vector3) => Vector3;
+                        reflect: (vector: import("three").Vector3Like) => Vector3;
                         angleTo: (v: Vector3) => number;
-                        distanceTo: (v: Vector3) => number;
-                        distanceToSquared: (v: Vector3) => number;
-                        distanceToManhattan: (v: Vector3) => number;
+                        distanceTo: (v: import("three").Vector3Like) => number;
+                        distanceToSquared: (v: import("three").Vector3Like) => number;
+                        manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                         setFromSpherical: (s: Spherical) => Vector3;
                         setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                         setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -5665,14 +5623,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                         setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                         setFromEuler: (e: import("three").Euler) => Vector3;
-                        equals: (v: Vector3) => boolean;
+                        setFromColor: (color: import("three").RGB) => Vector3;
+                        equals: (v: import("three").Vector3Like) => boolean;
                         fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                         toArray: {
                             (array?: number[] | undefined, offset?: number | undefined): number[];
                             (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                             (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                         random: () => Vector3;
                         randomDirection: () => Vector3;
                         [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -5717,7 +5676,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 stencilFail: import("three").StencilOp;
                 stencilZFail: import("three").StencilOp;
                 stencilZPass: import("three").StencilOp;
-                readonly isMaterial: true;
                 name: string;
                 needsUpdate: boolean;
                 opacity: number;
@@ -5736,12 +5694,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 uuid: string;
                 vertexColors: boolean;
                 visible: boolean;
-                userData: any;
+                userData: Record<string, any>;
                 version: number;
                 clone: () => import("three").Material;
                 copy: (material: import("three").Material) => import("three").Material;
                 dispose: () => void;
-                onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import("three").MaterialParameters) => void;
                 toJSON: (meta?: any) => any;
@@ -5768,6 +5726,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 }[T_6]) => void;
             } | undefined;
             customDistanceMaterial?: {
+                readonly isMaterial: true;
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
@@ -5814,7 +5773,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => number;
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
                 blendDst: import("three").BlendingDstFactor;
@@ -5837,34 +5796,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setY: (y: number) => Vector3;
                         setZ: (z: number) => Vector3;
                         setComponent: (index: number, value: number) => Vector3;
-                        setFromColor: (color: import("three").Color) => Vector3;
                         getComponent: (index: number) => number;
                         clone: () => Vector3;
-                        copy: (v: Vector3) => Vector3;
-                        add: (v: Vector3) => Vector3;
+                        copy: (v: import("three").Vector3Like) => Vector3;
+                        add: (v: import("three").Vector3Like) => Vector3;
                         addScalar: (s: number) => Vector3;
+                        addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         addScaledVector: (v: Vector3, s: number) => Vector3;
-                        addVectors: (a: Vector3, b: Vector3) => Vector3;
-                        sub: (a: Vector3) => Vector3;
+                        sub: (a: import("three").Vector3Like) => Vector3;
                         subScalar: (s: number) => Vector3;
-                        subVectors: (a: Vector3, b: Vector3) => Vector3;
-                        multiply: (v: Vector3) => Vector3;
+                        subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                        multiply: (v: import("three").Vector3Like) => Vector3;
                         multiplyScalar: (s: number) => Vector3;
-                        multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                        multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         applyEuler: (euler: import("three").Euler) => Vector3;
                         applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                         applyMatrix3: (m: import("three").Matrix3) => Vector3;
                         applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                         applyMatrix4: (m: Matrix4) => Vector3;
-                        applyQuaternion: (q: Quaternion) => Vector3;
+                        applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                         project: (camera: import("three").Camera) => Vector3;
                         unproject: (camera: import("three").Camera) => Vector3;
                         transformDirection: (m: Matrix4) => Vector3;
-                        divide: (v: Vector3) => Vector3;
+                        divide: (v: import("three").Vector3Like) => Vector3;
                         divideScalar: (s: number) => Vector3;
-                        min: (v: Vector3) => Vector3;
-                        max: (v: Vector3) => Vector3;
-                        clamp: (min: Vector3, max: Vector3) => Vector3;
+                        min: (v: import("three").Vector3Like) => Vector3;
+                        max: (v: import("three").Vector3Like) => Vector3;
+                        clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                         clampScalar: (min: number, max: number) => Vector3;
                         clampLength: (min: number, max: number) => Vector3;
                         floor: () => Vector3;
@@ -5872,25 +5830,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         round: () => Vector3;
                         roundToZero: () => Vector3;
                         negate: () => Vector3;
-                        dot: (v: Vector3) => number;
+                        dot: (v: import("three").Vector3Like) => number;
                         lengthSq: () => number;
                         length: () => number;
-                        lengthManhattan: () => number;
                         manhattanLength: () => number;
-                        manhattanDistanceTo: (v: Vector3) => number;
                         normalize: () => Vector3;
                         setLength: (l: number) => Vector3;
-                        lerp: (v: Vector3, alpha: number) => Vector3;
-                        lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                        cross: (a: Vector3) => Vector3;
-                        crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                        lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                        lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                        cross: (a: import("three").Vector3Like) => Vector3;
+                        crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         projectOnVector: (v: Vector3) => Vector3;
                         projectOnPlane: (planeNormal: Vector3) => Vector3;
-                        reflect: (vector: Vector3) => Vector3;
+                        reflect: (vector: import("three").Vector3Like) => Vector3;
                         angleTo: (v: Vector3) => number;
-                        distanceTo: (v: Vector3) => number;
-                        distanceToSquared: (v: Vector3) => number;
-                        distanceToManhattan: (v: Vector3) => number;
+                        distanceTo: (v: import("three").Vector3Like) => number;
+                        distanceToSquared: (v: import("three").Vector3Like) => number;
+                        manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                         setFromSpherical: (s: Spherical) => Vector3;
                         setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                         setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -5900,14 +5856,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                         setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                         setFromEuler: (e: import("three").Euler) => Vector3;
-                        equals: (v: Vector3) => boolean;
+                        setFromColor: (color: import("three").RGB) => Vector3;
+                        equals: (v: import("three").Vector3Like) => boolean;
                         fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                         toArray: {
                             (array?: number[] | undefined, offset?: number | undefined): number[];
                             (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                             (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                         random: () => Vector3;
                         randomDirection: () => Vector3;
                         [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -5952,7 +5909,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 stencilFail: import("three").StencilOp;
                 stencilZFail: import("three").StencilOp;
                 stencilZPass: import("three").StencilOp;
-                readonly isMaterial: true;
                 name: string;
                 needsUpdate: boolean;
                 opacity: number;
@@ -5971,12 +5927,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 uuid: string;
                 vertexColors: boolean;
                 visible: boolean;
-                userData: any;
+                userData: Record<string, any>;
                 version: number;
                 clone: () => import("three").Material;
                 copy: (material: import("three").Material) => import("three").Material;
                 dispose: () => void;
-                onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import("three").MaterialParameters) => void;
                 toJSON: (meta?: any) => any;
@@ -6002,6 +5958,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     dispose: {};
                 }[T_6]) => void;
             } | undefined;
+            onBeforeShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
             onBeforeRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
             onAfterRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
             applyMatrix4: (matrix: Matrix4) => void;
@@ -6033,7 +5991,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
             getObjectById: (id: number) => Object3D<import("three").Object3DEventMap> | undefined;
             getObjectByName: (name: string) => Object3D<import("three").Object3DEventMap> | undefined;
             getObjectByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap> | undefined;
-            getObjectsByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap>[];
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: Object3D<import("three").Object3DEventMap>[] | undefined) => Object3D<import("three").Object3DEventMap>[];
             getWorldPosition: (target: Vector3) => Vector3;
             getWorldQuaternion: (target: Quaternion) => Quaternion;
             getWorldScale: (target: Vector3) => Vector3;
@@ -6301,34 +6259,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -6336,25 +6293,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -6364,14 +6319,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -6387,34 +6343,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -6422,25 +6377,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -6450,14 +6403,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -6490,11 +6444,11 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     readonly isQuaternion: true;
                     set: (x: number, y: number, z: number, w: number) => Quaternion;
                     clone: () => Quaternion;
-                    copy: (q: Quaternion) => Quaternion;
+                    copy: (q: import("three").QuaternionLike) => Quaternion;
                     setFromEuler: (euler: import("three").Euler, update?: boolean | undefined) => Quaternion;
-                    setFromAxisAngle: (axis: Vector3, angle: number) => Quaternion;
+                    setFromAxisAngle: (axis: import("three").Vector3Like, angle: number) => Quaternion;
                     setFromRotationMatrix: (m: Matrix4) => Quaternion;
-                    setFromUnitVectors: (vFrom: Vector3, vTo: Vector3) => Quaternion;
+                    setFromUnitVectors: (vFrom: Vector3, vTo: import("three").Vector3Like) => Quaternion;
                     angleTo: (q: Quaternion) => number;
                     rotateTowards: (q: Quaternion, step: number) => Quaternion;
                     identity: () => Quaternion;
@@ -6516,10 +6470,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => [number, number, number, number];
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Quaternion;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Quaternion;
                     _onChange: (callback: () => void) => Quaternion;
                     _onChangeCallback: () => void;
-                    multiplyVector3: (v: any) => any;
                     random: () => Quaternion;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
@@ -6534,34 +6487,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -6569,25 +6521,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -6597,14 +6547,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -7132,10 +7083,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     clone: () => import("three").AnimationClip;
                     toJSON: (clip: import("three").AnimationClip) => any;
                 }[];
-                userData: {
-                    [key: string]: any;
-                };
+                userData: Record<string, any>;
                 customDepthMaterial?: {
+                    readonly isMaterial: true;
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
@@ -7182,7 +7132,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
                         toJSON: () => number;
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                         [Symbol.iterator]: () => Generator<number, void, unknown>;
                     };
                     blendDst: import("three").BlendingDstFactor;
@@ -7205,34 +7155,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setY: (y: number) => Vector3;
                             setZ: (z: number) => Vector3;
                             setComponent: (index: number, value: number) => Vector3;
-                            setFromColor: (color: import("three").Color) => Vector3;
                             getComponent: (index: number) => number;
                             clone: () => Vector3;
-                            copy: (v: Vector3) => Vector3;
-                            add: (v: Vector3) => Vector3;
+                            copy: (v: import("three").Vector3Like) => Vector3;
+                            add: (v: import("three").Vector3Like) => Vector3;
                             addScalar: (s: number) => Vector3;
+                            addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             addScaledVector: (v: Vector3, s: number) => Vector3;
-                            addVectors: (a: Vector3, b: Vector3) => Vector3;
-                            sub: (a: Vector3) => Vector3;
+                            sub: (a: import("three").Vector3Like) => Vector3;
                             subScalar: (s: number) => Vector3;
-                            subVectors: (a: Vector3, b: Vector3) => Vector3;
-                            multiply: (v: Vector3) => Vector3;
+                            subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                            multiply: (v: import("three").Vector3Like) => Vector3;
                             multiplyScalar: (s: number) => Vector3;
-                            multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                            multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             applyEuler: (euler: import("three").Euler) => Vector3;
                             applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                             applyMatrix3: (m: import("three").Matrix3) => Vector3;
                             applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                             applyMatrix4: (m: Matrix4) => Vector3;
-                            applyQuaternion: (q: Quaternion) => Vector3;
+                            applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                             project: (camera: import("three").Camera) => Vector3;
                             unproject: (camera: import("three").Camera) => Vector3;
                             transformDirection: (m: Matrix4) => Vector3;
-                            divide: (v: Vector3) => Vector3;
+                            divide: (v: import("three").Vector3Like) => Vector3;
                             divideScalar: (s: number) => Vector3;
-                            min: (v: Vector3) => Vector3;
-                            max: (v: Vector3) => Vector3;
-                            clamp: (min: Vector3, max: Vector3) => Vector3;
+                            min: (v: import("three").Vector3Like) => Vector3;
+                            max: (v: import("three").Vector3Like) => Vector3;
+                            clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                             clampScalar: (min: number, max: number) => Vector3;
                             clampLength: (min: number, max: number) => Vector3;
                             floor: () => Vector3;
@@ -7240,25 +7189,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             round: () => Vector3;
                             roundToZero: () => Vector3;
                             negate: () => Vector3;
-                            dot: (v: Vector3) => number;
+                            dot: (v: import("three").Vector3Like) => number;
                             lengthSq: () => number;
                             length: () => number;
-                            lengthManhattan: () => number;
                             manhattanLength: () => number;
-                            manhattanDistanceTo: (v: Vector3) => number;
                             normalize: () => Vector3;
                             setLength: (l: number) => Vector3;
-                            lerp: (v: Vector3, alpha: number) => Vector3;
-                            lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                            cross: (a: Vector3) => Vector3;
-                            crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                            lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                            lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                            cross: (a: import("three").Vector3Like) => Vector3;
+                            crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             projectOnVector: (v: Vector3) => Vector3;
                             projectOnPlane: (planeNormal: Vector3) => Vector3;
-                            reflect: (vector: Vector3) => Vector3;
+                            reflect: (vector: import("three").Vector3Like) => Vector3;
                             angleTo: (v: Vector3) => number;
-                            distanceTo: (v: Vector3) => number;
-                            distanceToSquared: (v: Vector3) => number;
-                            distanceToManhattan: (v: Vector3) => number;
+                            distanceTo: (v: import("three").Vector3Like) => number;
+                            distanceToSquared: (v: import("three").Vector3Like) => number;
+                            manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                             setFromSpherical: (s: Spherical) => Vector3;
                             setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                             setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -7268,14 +7215,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                             setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                             setFromEuler: (e: import("three").Euler) => Vector3;
-                            equals: (v: Vector3) => boolean;
+                            setFromColor: (color: import("three").RGB) => Vector3;
+                            equals: (v: import("three").Vector3Like) => boolean;
                             fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                             toArray: {
                                 (array?: number[] | undefined, offset?: number | undefined): number[];
                                 (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                                 (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                             };
-                            fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                            fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                             random: () => Vector3;
                             randomDirection: () => Vector3;
                             [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -7320,7 +7268,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     stencilFail: import("three").StencilOp;
                     stencilZFail: import("three").StencilOp;
                     stencilZPass: import("three").StencilOp;
-                    readonly isMaterial: true;
                     name: string;
                     needsUpdate: boolean;
                     opacity: number;
@@ -7339,12 +7286,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     uuid: string;
                     vertexColors: boolean;
                     visible: boolean;
-                    userData: any;
+                    userData: Record<string, any>;
                     version: number;
                     clone: () => import("three").Material;
                     copy: (material: import("three").Material) => import("three").Material;
                     dispose: () => void;
-                    onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                    onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import("three").MaterialParameters) => void;
                     toJSON: (meta?: any) => any;
@@ -7371,6 +7318,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     }[T_6]) => void;
                 } | undefined;
                 customDistanceMaterial?: {
+                    readonly isMaterial: true;
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
@@ -7417,7 +7365,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
                         toJSON: () => number;
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                         [Symbol.iterator]: () => Generator<number, void, unknown>;
                     };
                     blendDst: import("three").BlendingDstFactor;
@@ -7440,34 +7388,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setY: (y: number) => Vector3;
                             setZ: (z: number) => Vector3;
                             setComponent: (index: number, value: number) => Vector3;
-                            setFromColor: (color: import("three").Color) => Vector3;
                             getComponent: (index: number) => number;
                             clone: () => Vector3;
-                            copy: (v: Vector3) => Vector3;
-                            add: (v: Vector3) => Vector3;
+                            copy: (v: import("three").Vector3Like) => Vector3;
+                            add: (v: import("three").Vector3Like) => Vector3;
                             addScalar: (s: number) => Vector3;
+                            addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             addScaledVector: (v: Vector3, s: number) => Vector3;
-                            addVectors: (a: Vector3, b: Vector3) => Vector3;
-                            sub: (a: Vector3) => Vector3;
+                            sub: (a: import("three").Vector3Like) => Vector3;
                             subScalar: (s: number) => Vector3;
-                            subVectors: (a: Vector3, b: Vector3) => Vector3;
-                            multiply: (v: Vector3) => Vector3;
+                            subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                            multiply: (v: import("three").Vector3Like) => Vector3;
                             multiplyScalar: (s: number) => Vector3;
-                            multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                            multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             applyEuler: (euler: import("three").Euler) => Vector3;
                             applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                             applyMatrix3: (m: import("three").Matrix3) => Vector3;
                             applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                             applyMatrix4: (m: Matrix4) => Vector3;
-                            applyQuaternion: (q: Quaternion) => Vector3;
+                            applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                             project: (camera: import("three").Camera) => Vector3;
                             unproject: (camera: import("three").Camera) => Vector3;
                             transformDirection: (m: Matrix4) => Vector3;
-                            divide: (v: Vector3) => Vector3;
+                            divide: (v: import("three").Vector3Like) => Vector3;
                             divideScalar: (s: number) => Vector3;
-                            min: (v: Vector3) => Vector3;
-                            max: (v: Vector3) => Vector3;
-                            clamp: (min: Vector3, max: Vector3) => Vector3;
+                            min: (v: import("three").Vector3Like) => Vector3;
+                            max: (v: import("three").Vector3Like) => Vector3;
+                            clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                             clampScalar: (min: number, max: number) => Vector3;
                             clampLength: (min: number, max: number) => Vector3;
                             floor: () => Vector3;
@@ -7475,25 +7422,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             round: () => Vector3;
                             roundToZero: () => Vector3;
                             negate: () => Vector3;
-                            dot: (v: Vector3) => number;
+                            dot: (v: import("three").Vector3Like) => number;
                             lengthSq: () => number;
                             length: () => number;
-                            lengthManhattan: () => number;
                             manhattanLength: () => number;
-                            manhattanDistanceTo: (v: Vector3) => number;
                             normalize: () => Vector3;
                             setLength: (l: number) => Vector3;
-                            lerp: (v: Vector3, alpha: number) => Vector3;
-                            lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                            cross: (a: Vector3) => Vector3;
-                            crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                            lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                            lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                            cross: (a: import("three").Vector3Like) => Vector3;
+                            crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             projectOnVector: (v: Vector3) => Vector3;
                             projectOnPlane: (planeNormal: Vector3) => Vector3;
-                            reflect: (vector: Vector3) => Vector3;
+                            reflect: (vector: import("three").Vector3Like) => Vector3;
                             angleTo: (v: Vector3) => number;
-                            distanceTo: (v: Vector3) => number;
-                            distanceToSquared: (v: Vector3) => number;
-                            distanceToManhattan: (v: Vector3) => number;
+                            distanceTo: (v: import("three").Vector3Like) => number;
+                            distanceToSquared: (v: import("three").Vector3Like) => number;
+                            manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                             setFromSpherical: (s: Spherical) => Vector3;
                             setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                             setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -7503,14 +7448,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                             setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                             setFromEuler: (e: import("three").Euler) => Vector3;
-                            equals: (v: Vector3) => boolean;
+                            setFromColor: (color: import("three").RGB) => Vector3;
+                            equals: (v: import("three").Vector3Like) => boolean;
                             fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                             toArray: {
                                 (array?: number[] | undefined, offset?: number | undefined): number[];
                                 (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                                 (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                             };
-                            fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                            fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                             random: () => Vector3;
                             randomDirection: () => Vector3;
                             [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -7555,7 +7501,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     stencilFail: import("three").StencilOp;
                     stencilZFail: import("three").StencilOp;
                     stencilZPass: import("three").StencilOp;
-                    readonly isMaterial: true;
                     name: string;
                     needsUpdate: boolean;
                     opacity: number;
@@ -7574,12 +7519,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     uuid: string;
                     vertexColors: boolean;
                     visible: boolean;
-                    userData: any;
+                    userData: Record<string, any>;
                     version: number;
                     clone: () => import("three").Material;
                     copy: (material: import("three").Material) => import("three").Material;
                     dispose: () => void;
-                    onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                    onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import("three").MaterialParameters) => void;
                     toJSON: (meta?: any) => any;
@@ -7605,6 +7550,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
+                onBeforeShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+                onAfterShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 onBeforeRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 onAfterRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 applyMatrix4: (matrix: Matrix4) => void;
@@ -7636,7 +7583,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 getObjectById: (id: number) => Object3D<import("three").Object3DEventMap> | undefined;
                 getObjectByName: (name: string) => Object3D<import("three").Object3DEventMap> | undefined;
                 getObjectByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap> | undefined;
-                getObjectsByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap>[];
+                getObjectsByProperty: (name: string, value: any, optionalTarget?: Object3D<import("three").Object3DEventMap>[] | undefined) => Object3D<import("three").Object3DEventMap>[];
                 getWorldPosition: (target: Vector3) => Vector3;
                 getWorldQuaternion: (target: Quaternion) => Quaternion;
                 getWorldScale: (target: Vector3) => Vector3;
@@ -7689,34 +7636,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -7724,25 +7670,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -7752,14 +7696,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -7775,34 +7720,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -7810,25 +7754,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -7838,14 +7780,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -7878,11 +7821,11 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     readonly isQuaternion: true;
                     set: (x: number, y: number, z: number, w: number) => Quaternion;
                     clone: () => Quaternion;
-                    copy: (q: Quaternion) => Quaternion;
+                    copy: (q: import("three").QuaternionLike) => Quaternion;
                     setFromEuler: (euler: import("three").Euler, update?: boolean | undefined) => Quaternion;
-                    setFromAxisAngle: (axis: Vector3, angle: number) => Quaternion;
+                    setFromAxisAngle: (axis: import("three").Vector3Like, angle: number) => Quaternion;
                     setFromRotationMatrix: (m: Matrix4) => Quaternion;
-                    setFromUnitVectors: (vFrom: Vector3, vTo: Vector3) => Quaternion;
+                    setFromUnitVectors: (vFrom: Vector3, vTo: import("three").Vector3Like) => Quaternion;
                     angleTo: (q: Quaternion) => number;
                     rotateTowards: (q: Quaternion, step: number) => Quaternion;
                     identity: () => Quaternion;
@@ -7904,10 +7847,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => [number, number, number, number];
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Quaternion;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Quaternion;
                     _onChange: (callback: () => void) => Quaternion;
                     _onChangeCallback: () => void;
-                    multiplyVector3: (v: any) => any;
                     random: () => Quaternion;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
@@ -7922,34 +7864,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setY: (y: number) => Vector3;
                     setZ: (z: number) => Vector3;
                     setComponent: (index: number, value: number) => Vector3;
-                    setFromColor: (color: import("three").Color) => Vector3;
                     getComponent: (index: number) => number;
                     clone: () => Vector3;
-                    copy: (v: Vector3) => Vector3;
-                    add: (v: Vector3) => Vector3;
+                    copy: (v: import("three").Vector3Like) => Vector3;
+                    add: (v: import("three").Vector3Like) => Vector3;
                     addScalar: (s: number) => Vector3;
+                    addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     addScaledVector: (v: Vector3, s: number) => Vector3;
-                    addVectors: (a: Vector3, b: Vector3) => Vector3;
-                    sub: (a: Vector3) => Vector3;
+                    sub: (a: import("three").Vector3Like) => Vector3;
                     subScalar: (s: number) => Vector3;
-                    subVectors: (a: Vector3, b: Vector3) => Vector3;
-                    multiply: (v: Vector3) => Vector3;
+                    subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                    multiply: (v: import("three").Vector3Like) => Vector3;
                     multiplyScalar: (s: number) => Vector3;
-                    multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                    multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     applyEuler: (euler: import("three").Euler) => Vector3;
                     applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                     applyMatrix3: (m: import("three").Matrix3) => Vector3;
                     applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                     applyMatrix4: (m: Matrix4) => Vector3;
-                    applyQuaternion: (q: Quaternion) => Vector3;
+                    applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                     project: (camera: import("three").Camera) => Vector3;
                     unproject: (camera: import("three").Camera) => Vector3;
                     transformDirection: (m: Matrix4) => Vector3;
-                    divide: (v: Vector3) => Vector3;
+                    divide: (v: import("three").Vector3Like) => Vector3;
                     divideScalar: (s: number) => Vector3;
-                    min: (v: Vector3) => Vector3;
-                    max: (v: Vector3) => Vector3;
-                    clamp: (min: Vector3, max: Vector3) => Vector3;
+                    min: (v: import("three").Vector3Like) => Vector3;
+                    max: (v: import("three").Vector3Like) => Vector3;
+                    clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                     clampScalar: (min: number, max: number) => Vector3;
                     clampLength: (min: number, max: number) => Vector3;
                     floor: () => Vector3;
@@ -7957,25 +7898,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     round: () => Vector3;
                     roundToZero: () => Vector3;
                     negate: () => Vector3;
-                    dot: (v: Vector3) => number;
+                    dot: (v: import("three").Vector3Like) => number;
                     lengthSq: () => number;
                     length: () => number;
-                    lengthManhattan: () => number;
                     manhattanLength: () => number;
-                    manhattanDistanceTo: (v: Vector3) => number;
                     normalize: () => Vector3;
                     setLength: (l: number) => Vector3;
-                    lerp: (v: Vector3, alpha: number) => Vector3;
-                    lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                    cross: (a: Vector3) => Vector3;
-                    crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                    lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                    lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                    cross: (a: import("three").Vector3Like) => Vector3;
+                    crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                     projectOnVector: (v: Vector3) => Vector3;
                     projectOnPlane: (planeNormal: Vector3) => Vector3;
-                    reflect: (vector: Vector3) => Vector3;
+                    reflect: (vector: import("three").Vector3Like) => Vector3;
                     angleTo: (v: Vector3) => number;
-                    distanceTo: (v: Vector3) => number;
-                    distanceToSquared: (v: Vector3) => number;
-                    distanceToManhattan: (v: Vector3) => number;
+                    distanceTo: (v: import("three").Vector3Like) => number;
+                    distanceToSquared: (v: import("three").Vector3Like) => number;
+                    manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                     setFromSpherical: (s: Spherical) => Vector3;
                     setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                     setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -7985,14 +7924,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                     setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                     setFromEuler: (e: import("three").Euler) => Vector3;
-                    equals: (v: Vector3) => boolean;
+                    setFromColor: (color: import("three").RGB) => Vector3;
+                    equals: (v: import("three").Vector3Like) => boolean;
                     fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                     toArray: {
                         (array?: number[] | undefined, offset?: number | undefined): number[];
                         (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                         (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                     random: () => Vector3;
                     randomDirection: () => Vector3;
                     [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -8520,10 +8460,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     clone: () => import("three").AnimationClip;
                     toJSON: (clip: import("three").AnimationClip) => any;
                 }[];
-                userData: {
-                    [key: string]: any;
-                };
+                userData: Record<string, any>;
                 customDepthMaterial?: {
+                    readonly isMaterial: true;
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
@@ -8570,7 +8509,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
                         toJSON: () => number;
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                         [Symbol.iterator]: () => Generator<number, void, unknown>;
                     };
                     blendDst: import("three").BlendingDstFactor;
@@ -8593,34 +8532,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setY: (y: number) => Vector3;
                             setZ: (z: number) => Vector3;
                             setComponent: (index: number, value: number) => Vector3;
-                            setFromColor: (color: import("three").Color) => Vector3;
                             getComponent: (index: number) => number;
                             clone: () => Vector3;
-                            copy: (v: Vector3) => Vector3;
-                            add: (v: Vector3) => Vector3;
+                            copy: (v: import("three").Vector3Like) => Vector3;
+                            add: (v: import("three").Vector3Like) => Vector3;
                             addScalar: (s: number) => Vector3;
+                            addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             addScaledVector: (v: Vector3, s: number) => Vector3;
-                            addVectors: (a: Vector3, b: Vector3) => Vector3;
-                            sub: (a: Vector3) => Vector3;
+                            sub: (a: import("three").Vector3Like) => Vector3;
                             subScalar: (s: number) => Vector3;
-                            subVectors: (a: Vector3, b: Vector3) => Vector3;
-                            multiply: (v: Vector3) => Vector3;
+                            subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                            multiply: (v: import("three").Vector3Like) => Vector3;
                             multiplyScalar: (s: number) => Vector3;
-                            multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                            multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             applyEuler: (euler: import("three").Euler) => Vector3;
                             applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                             applyMatrix3: (m: import("three").Matrix3) => Vector3;
                             applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                             applyMatrix4: (m: Matrix4) => Vector3;
-                            applyQuaternion: (q: Quaternion) => Vector3;
+                            applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                             project: (camera: import("three").Camera) => Vector3;
                             unproject: (camera: import("three").Camera) => Vector3;
                             transformDirection: (m: Matrix4) => Vector3;
-                            divide: (v: Vector3) => Vector3;
+                            divide: (v: import("three").Vector3Like) => Vector3;
                             divideScalar: (s: number) => Vector3;
-                            min: (v: Vector3) => Vector3;
-                            max: (v: Vector3) => Vector3;
-                            clamp: (min: Vector3, max: Vector3) => Vector3;
+                            min: (v: import("three").Vector3Like) => Vector3;
+                            max: (v: import("three").Vector3Like) => Vector3;
+                            clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                             clampScalar: (min: number, max: number) => Vector3;
                             clampLength: (min: number, max: number) => Vector3;
                             floor: () => Vector3;
@@ -8628,25 +8566,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             round: () => Vector3;
                             roundToZero: () => Vector3;
                             negate: () => Vector3;
-                            dot: (v: Vector3) => number;
+                            dot: (v: import("three").Vector3Like) => number;
                             lengthSq: () => number;
                             length: () => number;
-                            lengthManhattan: () => number;
                             manhattanLength: () => number;
-                            manhattanDistanceTo: (v: Vector3) => number;
                             normalize: () => Vector3;
                             setLength: (l: number) => Vector3;
-                            lerp: (v: Vector3, alpha: number) => Vector3;
-                            lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                            cross: (a: Vector3) => Vector3;
-                            crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                            lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                            lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                            cross: (a: import("three").Vector3Like) => Vector3;
+                            crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             projectOnVector: (v: Vector3) => Vector3;
                             projectOnPlane: (planeNormal: Vector3) => Vector3;
-                            reflect: (vector: Vector3) => Vector3;
+                            reflect: (vector: import("three").Vector3Like) => Vector3;
                             angleTo: (v: Vector3) => number;
-                            distanceTo: (v: Vector3) => number;
-                            distanceToSquared: (v: Vector3) => number;
-                            distanceToManhattan: (v: Vector3) => number;
+                            distanceTo: (v: import("three").Vector3Like) => number;
+                            distanceToSquared: (v: import("three").Vector3Like) => number;
+                            manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                             setFromSpherical: (s: Spherical) => Vector3;
                             setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                             setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -8656,14 +8592,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                             setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                             setFromEuler: (e: import("three").Euler) => Vector3;
-                            equals: (v: Vector3) => boolean;
+                            setFromColor: (color: import("three").RGB) => Vector3;
+                            equals: (v: import("three").Vector3Like) => boolean;
                             fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                             toArray: {
                                 (array?: number[] | undefined, offset?: number | undefined): number[];
                                 (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                                 (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                             };
-                            fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                            fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                             random: () => Vector3;
                             randomDirection: () => Vector3;
                             [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -8708,7 +8645,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     stencilFail: import("three").StencilOp;
                     stencilZFail: import("three").StencilOp;
                     stencilZPass: import("three").StencilOp;
-                    readonly isMaterial: true;
                     name: string;
                     needsUpdate: boolean;
                     opacity: number;
@@ -8727,12 +8663,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     uuid: string;
                     vertexColors: boolean;
                     visible: boolean;
-                    userData: any;
+                    userData: Record<string, any>;
                     version: number;
                     clone: () => import("three").Material;
                     copy: (material: import("three").Material) => import("three").Material;
                     dispose: () => void;
-                    onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                    onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import("three").MaterialParameters) => void;
                     toJSON: (meta?: any) => any;
@@ -8759,6 +8695,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     }[T_6]) => void;
                 } | undefined;
                 customDistanceMaterial?: {
+                    readonly isMaterial: true;
                     alphaHash: boolean;
                     alphaTest: number;
                     alphaToCoverage: boolean;
@@ -8805,7 +8742,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
                         toJSON: () => number;
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                         [Symbol.iterator]: () => Generator<number, void, unknown>;
                     };
                     blendDst: import("three").BlendingDstFactor;
@@ -8828,34 +8765,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setY: (y: number) => Vector3;
                             setZ: (z: number) => Vector3;
                             setComponent: (index: number, value: number) => Vector3;
-                            setFromColor: (color: import("three").Color) => Vector3;
                             getComponent: (index: number) => number;
                             clone: () => Vector3;
-                            copy: (v: Vector3) => Vector3;
-                            add: (v: Vector3) => Vector3;
+                            copy: (v: import("three").Vector3Like) => Vector3;
+                            add: (v: import("three").Vector3Like) => Vector3;
                             addScalar: (s: number) => Vector3;
+                            addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             addScaledVector: (v: Vector3, s: number) => Vector3;
-                            addVectors: (a: Vector3, b: Vector3) => Vector3;
-                            sub: (a: Vector3) => Vector3;
+                            sub: (a: import("three").Vector3Like) => Vector3;
                             subScalar: (s: number) => Vector3;
-                            subVectors: (a: Vector3, b: Vector3) => Vector3;
-                            multiply: (v: Vector3) => Vector3;
+                            subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                            multiply: (v: import("three").Vector3Like) => Vector3;
                             multiplyScalar: (s: number) => Vector3;
-                            multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                            multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             applyEuler: (euler: import("three").Euler) => Vector3;
                             applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                             applyMatrix3: (m: import("three").Matrix3) => Vector3;
                             applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                             applyMatrix4: (m: Matrix4) => Vector3;
-                            applyQuaternion: (q: Quaternion) => Vector3;
+                            applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                             project: (camera: import("three").Camera) => Vector3;
                             unproject: (camera: import("three").Camera) => Vector3;
                             transformDirection: (m: Matrix4) => Vector3;
-                            divide: (v: Vector3) => Vector3;
+                            divide: (v: import("three").Vector3Like) => Vector3;
                             divideScalar: (s: number) => Vector3;
-                            min: (v: Vector3) => Vector3;
-                            max: (v: Vector3) => Vector3;
-                            clamp: (min: Vector3, max: Vector3) => Vector3;
+                            min: (v: import("three").Vector3Like) => Vector3;
+                            max: (v: import("three").Vector3Like) => Vector3;
+                            clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                             clampScalar: (min: number, max: number) => Vector3;
                             clampLength: (min: number, max: number) => Vector3;
                             floor: () => Vector3;
@@ -8863,25 +8799,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             round: () => Vector3;
                             roundToZero: () => Vector3;
                             negate: () => Vector3;
-                            dot: (v: Vector3) => number;
+                            dot: (v: import("three").Vector3Like) => number;
                             lengthSq: () => number;
                             length: () => number;
-                            lengthManhattan: () => number;
                             manhattanLength: () => number;
-                            manhattanDistanceTo: (v: Vector3) => number;
                             normalize: () => Vector3;
                             setLength: (l: number) => Vector3;
-                            lerp: (v: Vector3, alpha: number) => Vector3;
-                            lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                            cross: (a: Vector3) => Vector3;
-                            crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                            lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                            lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                            cross: (a: import("three").Vector3Like) => Vector3;
+                            crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                             projectOnVector: (v: Vector3) => Vector3;
                             projectOnPlane: (planeNormal: Vector3) => Vector3;
-                            reflect: (vector: Vector3) => Vector3;
+                            reflect: (vector: import("three").Vector3Like) => Vector3;
                             angleTo: (v: Vector3) => number;
-                            distanceTo: (v: Vector3) => number;
-                            distanceToSquared: (v: Vector3) => number;
-                            distanceToManhattan: (v: Vector3) => number;
+                            distanceTo: (v: import("three").Vector3Like) => number;
+                            distanceToSquared: (v: import("three").Vector3Like) => number;
+                            manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                             setFromSpherical: (s: Spherical) => Vector3;
                             setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                             setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -8891,14 +8825,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                             setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                             setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                             setFromEuler: (e: import("three").Euler) => Vector3;
-                            equals: (v: Vector3) => boolean;
+                            setFromColor: (color: import("three").RGB) => Vector3;
+                            equals: (v: import("three").Vector3Like) => boolean;
                             fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                             toArray: {
                                 (array?: number[] | undefined, offset?: number | undefined): number[];
                                 (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                                 (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                             };
-                            fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                            fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                             random: () => Vector3;
                             randomDirection: () => Vector3;
                             [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -8943,7 +8878,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     stencilFail: import("three").StencilOp;
                     stencilZFail: import("three").StencilOp;
                     stencilZPass: import("three").StencilOp;
-                    readonly isMaterial: true;
                     name: string;
                     needsUpdate: boolean;
                     opacity: number;
@@ -8962,12 +8896,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     uuid: string;
                     vertexColors: boolean;
                     visible: boolean;
-                    userData: any;
+                    userData: Record<string, any>;
                     version: number;
                     clone: () => import("three").Material;
                     copy: (material: import("three").Material) => import("three").Material;
                     dispose: () => void;
-                    onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                    onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import("three").MaterialParameters) => void;
                     toJSON: (meta?: any) => any;
@@ -8993,6 +8927,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         dispose: {};
                     }[T_6]) => void;
                 } | undefined;
+                onBeforeShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+                onAfterShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 onBeforeRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 onAfterRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
                 applyMatrix4: (matrix: Matrix4) => void;
@@ -9024,7 +8960,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 getObjectById: (id: number) => Object3D<import("three").Object3DEventMap> | undefined;
                 getObjectByName: (name: string) => Object3D<import("three").Object3DEventMap> | undefined;
                 getObjectByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap> | undefined;
-                getObjectsByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap>[];
+                getObjectsByProperty: (name: string, value: any, optionalTarget?: Object3D<import("three").Object3DEventMap>[] | undefined) => Object3D<import("three").Object3DEventMap>[];
                 getWorldPosition: (target: Vector3) => Vector3;
                 getWorldQuaternion: (target: Quaternion) => Quaternion;
                 getWorldScale: (target: Vector3) => Vector3;
@@ -9069,34 +9005,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setY: (y: number) => Vector3;
                 setZ: (z: number) => Vector3;
                 setComponent: (index: number, value: number) => Vector3;
-                setFromColor: (color: import("three").Color) => Vector3;
                 getComponent: (index: number) => number;
                 clone: () => Vector3;
-                copy: (v: Vector3) => Vector3;
-                add: (v: Vector3) => Vector3;
+                copy: (v: import("three").Vector3Like) => Vector3;
+                add: (v: import("three").Vector3Like) => Vector3;
                 addScalar: (s: number) => Vector3;
+                addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 addScaledVector: (v: Vector3, s: number) => Vector3;
-                addVectors: (a: Vector3, b: Vector3) => Vector3;
-                sub: (a: Vector3) => Vector3;
+                sub: (a: import("three").Vector3Like) => Vector3;
                 subScalar: (s: number) => Vector3;
-                subVectors: (a: Vector3, b: Vector3) => Vector3;
-                multiply: (v: Vector3) => Vector3;
+                subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                multiply: (v: import("three").Vector3Like) => Vector3;
                 multiplyScalar: (s: number) => Vector3;
-                multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 applyEuler: (euler: import("three").Euler) => Vector3;
                 applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                 applyMatrix3: (m: import("three").Matrix3) => Vector3;
                 applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                 applyMatrix4: (m: Matrix4) => Vector3;
-                applyQuaternion: (q: Quaternion) => Vector3;
+                applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                 project: (camera: import("three").Camera) => Vector3;
                 unproject: (camera: import("three").Camera) => Vector3;
                 transformDirection: (m: Matrix4) => Vector3;
-                divide: (v: Vector3) => Vector3;
+                divide: (v: import("three").Vector3Like) => Vector3;
                 divideScalar: (s: number) => Vector3;
-                min: (v: Vector3) => Vector3;
-                max: (v: Vector3) => Vector3;
-                clamp: (min: Vector3, max: Vector3) => Vector3;
+                min: (v: import("three").Vector3Like) => Vector3;
+                max: (v: import("three").Vector3Like) => Vector3;
+                clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                 clampScalar: (min: number, max: number) => Vector3;
                 clampLength: (min: number, max: number) => Vector3;
                 floor: () => Vector3;
@@ -9104,25 +9039,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 round: () => Vector3;
                 roundToZero: () => Vector3;
                 negate: () => Vector3;
-                dot: (v: Vector3) => number;
+                dot: (v: import("three").Vector3Like) => number;
                 lengthSq: () => number;
                 length: () => number;
-                lengthManhattan: () => number;
                 manhattanLength: () => number;
-                manhattanDistanceTo: (v: Vector3) => number;
                 normalize: () => Vector3;
                 setLength: (l: number) => Vector3;
-                lerp: (v: Vector3, alpha: number) => Vector3;
-                lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                cross: (a: Vector3) => Vector3;
-                crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                cross: (a: import("three").Vector3Like) => Vector3;
+                crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 projectOnVector: (v: Vector3) => Vector3;
                 projectOnPlane: (planeNormal: Vector3) => Vector3;
-                reflect: (vector: Vector3) => Vector3;
+                reflect: (vector: import("three").Vector3Like) => Vector3;
                 angleTo: (v: Vector3) => number;
-                distanceTo: (v: Vector3) => number;
-                distanceToSquared: (v: Vector3) => number;
-                distanceToManhattan: (v: Vector3) => number;
+                distanceTo: (v: import("three").Vector3Like) => number;
+                distanceToSquared: (v: import("three").Vector3Like) => number;
+                manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                 setFromSpherical: (s: Spherical) => Vector3;
                 setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                 setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -9132,14 +9065,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                 setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                 setFromEuler: (e: import("three").Euler) => Vector3;
-                equals: (v: Vector3) => boolean;
+                setFromColor: (color: import("three").RGB) => Vector3;
+                equals: (v: import("three").Vector3Like) => boolean;
                 fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                 toArray: {
                     (array?: number[] | undefined, offset?: number | undefined): number[];
                     (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                 random: () => Vector3;
                 randomDirection: () => Vector3;
                 [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -9155,34 +9089,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setY: (y: number) => Vector3;
                 setZ: (z: number) => Vector3;
                 setComponent: (index: number, value: number) => Vector3;
-                setFromColor: (color: import("three").Color) => Vector3;
                 getComponent: (index: number) => number;
                 clone: () => Vector3;
-                copy: (v: Vector3) => Vector3;
-                add: (v: Vector3) => Vector3;
+                copy: (v: import("three").Vector3Like) => Vector3;
+                add: (v: import("three").Vector3Like) => Vector3;
                 addScalar: (s: number) => Vector3;
+                addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 addScaledVector: (v: Vector3, s: number) => Vector3;
-                addVectors: (a: Vector3, b: Vector3) => Vector3;
-                sub: (a: Vector3) => Vector3;
+                sub: (a: import("three").Vector3Like) => Vector3;
                 subScalar: (s: number) => Vector3;
-                subVectors: (a: Vector3, b: Vector3) => Vector3;
-                multiply: (v: Vector3) => Vector3;
+                subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                multiply: (v: import("three").Vector3Like) => Vector3;
                 multiplyScalar: (s: number) => Vector3;
-                multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 applyEuler: (euler: import("three").Euler) => Vector3;
                 applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                 applyMatrix3: (m: import("three").Matrix3) => Vector3;
                 applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                 applyMatrix4: (m: Matrix4) => Vector3;
-                applyQuaternion: (q: Quaternion) => Vector3;
+                applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                 project: (camera: import("three").Camera) => Vector3;
                 unproject: (camera: import("three").Camera) => Vector3;
                 transformDirection: (m: Matrix4) => Vector3;
-                divide: (v: Vector3) => Vector3;
+                divide: (v: import("three").Vector3Like) => Vector3;
                 divideScalar: (s: number) => Vector3;
-                min: (v: Vector3) => Vector3;
-                max: (v: Vector3) => Vector3;
-                clamp: (min: Vector3, max: Vector3) => Vector3;
+                min: (v: import("three").Vector3Like) => Vector3;
+                max: (v: import("three").Vector3Like) => Vector3;
+                clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                 clampScalar: (min: number, max: number) => Vector3;
                 clampLength: (min: number, max: number) => Vector3;
                 floor: () => Vector3;
@@ -9190,25 +9123,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 round: () => Vector3;
                 roundToZero: () => Vector3;
                 negate: () => Vector3;
-                dot: (v: Vector3) => number;
+                dot: (v: import("three").Vector3Like) => number;
                 lengthSq: () => number;
                 length: () => number;
-                lengthManhattan: () => number;
                 manhattanLength: () => number;
-                manhattanDistanceTo: (v: Vector3) => number;
                 normalize: () => Vector3;
                 setLength: (l: number) => Vector3;
-                lerp: (v: Vector3, alpha: number) => Vector3;
-                lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                cross: (a: Vector3) => Vector3;
-                crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                cross: (a: import("three").Vector3Like) => Vector3;
+                crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 projectOnVector: (v: Vector3) => Vector3;
                 projectOnPlane: (planeNormal: Vector3) => Vector3;
-                reflect: (vector: Vector3) => Vector3;
+                reflect: (vector: import("three").Vector3Like) => Vector3;
                 angleTo: (v: Vector3) => number;
-                distanceTo: (v: Vector3) => number;
-                distanceToSquared: (v: Vector3) => number;
-                distanceToManhattan: (v: Vector3) => number;
+                distanceTo: (v: import("three").Vector3Like) => number;
+                distanceToSquared: (v: import("three").Vector3Like) => number;
+                manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                 setFromSpherical: (s: Spherical) => Vector3;
                 setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                 setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -9218,14 +9149,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                 setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                 setFromEuler: (e: import("three").Euler) => Vector3;
-                equals: (v: Vector3) => boolean;
+                setFromColor: (color: import("three").RGB) => Vector3;
+                equals: (v: import("three").Vector3Like) => boolean;
                 fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                 toArray: {
                     (array?: number[] | undefined, offset?: number | undefined): number[];
                     (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                 random: () => Vector3;
                 randomDirection: () => Vector3;
                 [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -9258,11 +9190,11 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 readonly isQuaternion: true;
                 set: (x: number, y: number, z: number, w: number) => Quaternion;
                 clone: () => Quaternion;
-                copy: (q: Quaternion) => Quaternion;
+                copy: (q: import("three").QuaternionLike) => Quaternion;
                 setFromEuler: (euler: import("three").Euler, update?: boolean | undefined) => Quaternion;
-                setFromAxisAngle: (axis: Vector3, angle: number) => Quaternion;
+                setFromAxisAngle: (axis: import("three").Vector3Like, angle: number) => Quaternion;
                 setFromRotationMatrix: (m: Matrix4) => Quaternion;
-                setFromUnitVectors: (vFrom: Vector3, vTo: Vector3) => Quaternion;
+                setFromUnitVectors: (vFrom: Vector3, vTo: import("three").Vector3Like) => Quaternion;
                 angleTo: (q: Quaternion) => number;
                 rotateTowards: (q: Quaternion, step: number) => Quaternion;
                 identity: () => Quaternion;
@@ -9284,10 +9216,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
                 toJSON: () => [number, number, number, number];
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Quaternion;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Quaternion;
                 _onChange: (callback: () => void) => Quaternion;
                 _onChangeCallback: () => void;
-                multiplyVector3: (v: any) => any;
                 random: () => Quaternion;
                 [Symbol.iterator]: () => Generator<number, void, unknown>;
             };
@@ -9302,34 +9233,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setY: (y: number) => Vector3;
                 setZ: (z: number) => Vector3;
                 setComponent: (index: number, value: number) => Vector3;
-                setFromColor: (color: import("three").Color) => Vector3;
                 getComponent: (index: number) => number;
                 clone: () => Vector3;
-                copy: (v: Vector3) => Vector3;
-                add: (v: Vector3) => Vector3;
+                copy: (v: import("three").Vector3Like) => Vector3;
+                add: (v: import("three").Vector3Like) => Vector3;
                 addScalar: (s: number) => Vector3;
+                addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 addScaledVector: (v: Vector3, s: number) => Vector3;
-                addVectors: (a: Vector3, b: Vector3) => Vector3;
-                sub: (a: Vector3) => Vector3;
+                sub: (a: import("three").Vector3Like) => Vector3;
                 subScalar: (s: number) => Vector3;
-                subVectors: (a: Vector3, b: Vector3) => Vector3;
-                multiply: (v: Vector3) => Vector3;
+                subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                multiply: (v: import("three").Vector3Like) => Vector3;
                 multiplyScalar: (s: number) => Vector3;
-                multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 applyEuler: (euler: import("three").Euler) => Vector3;
                 applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                 applyMatrix3: (m: import("three").Matrix3) => Vector3;
                 applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                 applyMatrix4: (m: Matrix4) => Vector3;
-                applyQuaternion: (q: Quaternion) => Vector3;
+                applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                 project: (camera: import("three").Camera) => Vector3;
                 unproject: (camera: import("three").Camera) => Vector3;
                 transformDirection: (m: Matrix4) => Vector3;
-                divide: (v: Vector3) => Vector3;
+                divide: (v: import("three").Vector3Like) => Vector3;
                 divideScalar: (s: number) => Vector3;
-                min: (v: Vector3) => Vector3;
-                max: (v: Vector3) => Vector3;
-                clamp: (min: Vector3, max: Vector3) => Vector3;
+                min: (v: import("three").Vector3Like) => Vector3;
+                max: (v: import("three").Vector3Like) => Vector3;
+                clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                 clampScalar: (min: number, max: number) => Vector3;
                 clampLength: (min: number, max: number) => Vector3;
                 floor: () => Vector3;
@@ -9337,25 +9267,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 round: () => Vector3;
                 roundToZero: () => Vector3;
                 negate: () => Vector3;
-                dot: (v: Vector3) => number;
+                dot: (v: import("three").Vector3Like) => number;
                 lengthSq: () => number;
                 length: () => number;
-                lengthManhattan: () => number;
                 manhattanLength: () => number;
-                manhattanDistanceTo: (v: Vector3) => number;
                 normalize: () => Vector3;
                 setLength: (l: number) => Vector3;
-                lerp: (v: Vector3, alpha: number) => Vector3;
-                lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                cross: (a: Vector3) => Vector3;
-                crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                cross: (a: import("three").Vector3Like) => Vector3;
+                crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                 projectOnVector: (v: Vector3) => Vector3;
                 projectOnPlane: (planeNormal: Vector3) => Vector3;
-                reflect: (vector: Vector3) => Vector3;
+                reflect: (vector: import("three").Vector3Like) => Vector3;
                 angleTo: (v: Vector3) => number;
-                distanceTo: (v: Vector3) => number;
-                distanceToSquared: (v: Vector3) => number;
-                distanceToManhattan: (v: Vector3) => number;
+                distanceTo: (v: import("three").Vector3Like) => number;
+                distanceToSquared: (v: import("three").Vector3Like) => number;
+                manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                 setFromSpherical: (s: Spherical) => Vector3;
                 setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                 setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -9365,14 +9293,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                 setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                 setFromEuler: (e: import("three").Euler) => Vector3;
-                equals: (v: Vector3) => boolean;
+                setFromColor: (color: import("three").RGB) => Vector3;
+                equals: (v: import("three").Vector3Like) => boolean;
                 fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                 toArray: {
                     (array?: number[] | undefined, offset?: number | undefined): number[];
                     (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                     (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                 };
-                fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                 random: () => Vector3;
                 randomDirection: () => Vector3;
                 [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -9889,10 +9818,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 clone: () => import("three").AnimationClip;
                 toJSON: (clip: import("three").AnimationClip) => any;
             }[];
-            userData: {
-                [key: string]: any;
-            };
+            userData: Record<string, any>;
             customDepthMaterial?: {
+                readonly isMaterial: true;
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
@@ -9939,7 +9867,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => number;
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
                 blendDst: import("three").BlendingDstFactor;
@@ -9962,34 +9890,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setY: (y: number) => Vector3;
                         setZ: (z: number) => Vector3;
                         setComponent: (index: number, value: number) => Vector3;
-                        setFromColor: (color: import("three").Color) => Vector3;
                         getComponent: (index: number) => number;
                         clone: () => Vector3;
-                        copy: (v: Vector3) => Vector3;
-                        add: (v: Vector3) => Vector3;
+                        copy: (v: import("three").Vector3Like) => Vector3;
+                        add: (v: import("three").Vector3Like) => Vector3;
                         addScalar: (s: number) => Vector3;
+                        addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         addScaledVector: (v: Vector3, s: number) => Vector3;
-                        addVectors: (a: Vector3, b: Vector3) => Vector3;
-                        sub: (a: Vector3) => Vector3;
+                        sub: (a: import("three").Vector3Like) => Vector3;
                         subScalar: (s: number) => Vector3;
-                        subVectors: (a: Vector3, b: Vector3) => Vector3;
-                        multiply: (v: Vector3) => Vector3;
+                        subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                        multiply: (v: import("three").Vector3Like) => Vector3;
                         multiplyScalar: (s: number) => Vector3;
-                        multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                        multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         applyEuler: (euler: import("three").Euler) => Vector3;
                         applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                         applyMatrix3: (m: import("three").Matrix3) => Vector3;
                         applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                         applyMatrix4: (m: Matrix4) => Vector3;
-                        applyQuaternion: (q: Quaternion) => Vector3;
+                        applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                         project: (camera: import("three").Camera) => Vector3;
                         unproject: (camera: import("three").Camera) => Vector3;
                         transformDirection: (m: Matrix4) => Vector3;
-                        divide: (v: Vector3) => Vector3;
+                        divide: (v: import("three").Vector3Like) => Vector3;
                         divideScalar: (s: number) => Vector3;
-                        min: (v: Vector3) => Vector3;
-                        max: (v: Vector3) => Vector3;
-                        clamp: (min: Vector3, max: Vector3) => Vector3;
+                        min: (v: import("three").Vector3Like) => Vector3;
+                        max: (v: import("three").Vector3Like) => Vector3;
+                        clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                         clampScalar: (min: number, max: number) => Vector3;
                         clampLength: (min: number, max: number) => Vector3;
                         floor: () => Vector3;
@@ -9997,25 +9924,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         round: () => Vector3;
                         roundToZero: () => Vector3;
                         negate: () => Vector3;
-                        dot: (v: Vector3) => number;
+                        dot: (v: import("three").Vector3Like) => number;
                         lengthSq: () => number;
                         length: () => number;
-                        lengthManhattan: () => number;
                         manhattanLength: () => number;
-                        manhattanDistanceTo: (v: Vector3) => number;
                         normalize: () => Vector3;
                         setLength: (l: number) => Vector3;
-                        lerp: (v: Vector3, alpha: number) => Vector3;
-                        lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                        cross: (a: Vector3) => Vector3;
-                        crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                        lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                        lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                        cross: (a: import("three").Vector3Like) => Vector3;
+                        crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         projectOnVector: (v: Vector3) => Vector3;
                         projectOnPlane: (planeNormal: Vector3) => Vector3;
-                        reflect: (vector: Vector3) => Vector3;
+                        reflect: (vector: import("three").Vector3Like) => Vector3;
                         angleTo: (v: Vector3) => number;
-                        distanceTo: (v: Vector3) => number;
-                        distanceToSquared: (v: Vector3) => number;
-                        distanceToManhattan: (v: Vector3) => number;
+                        distanceTo: (v: import("three").Vector3Like) => number;
+                        distanceToSquared: (v: import("three").Vector3Like) => number;
+                        manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                         setFromSpherical: (s: Spherical) => Vector3;
                         setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                         setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -10025,14 +9950,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                         setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                         setFromEuler: (e: import("three").Euler) => Vector3;
-                        equals: (v: Vector3) => boolean;
+                        setFromColor: (color: import("three").RGB) => Vector3;
+                        equals: (v: import("three").Vector3Like) => boolean;
                         fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                         toArray: {
                             (array?: number[] | undefined, offset?: number | undefined): number[];
                             (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                             (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                         random: () => Vector3;
                         randomDirection: () => Vector3;
                         [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -10077,7 +10003,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 stencilFail: import("three").StencilOp;
                 stencilZFail: import("three").StencilOp;
                 stencilZPass: import("three").StencilOp;
-                readonly isMaterial: true;
                 name: string;
                 needsUpdate: boolean;
                 opacity: number;
@@ -10096,12 +10021,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 uuid: string;
                 vertexColors: boolean;
                 visible: boolean;
-                userData: any;
+                userData: Record<string, any>;
                 version: number;
                 clone: () => import("three").Material;
                 copy: (material: import("three").Material) => import("three").Material;
                 dispose: () => void;
-                onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import("three").MaterialParameters) => void;
                 toJSON: (meta?: any) => any;
@@ -10128,6 +10053,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 }[T_6]) => void;
             } | undefined;
             customDistanceMaterial?: {
+                readonly isMaterial: true;
                 alphaHash: boolean;
                 alphaTest: number;
                 alphaToCoverage: boolean;
@@ -10174,7 +10100,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                     };
                     toJSON: () => number;
-                    fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => import("three").Color;
+                    fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => import("three").Color;
                     [Symbol.iterator]: () => Generator<number, void, unknown>;
                 };
                 blendDst: import("three").BlendingDstFactor;
@@ -10197,34 +10123,33 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setY: (y: number) => Vector3;
                         setZ: (z: number) => Vector3;
                         setComponent: (index: number, value: number) => Vector3;
-                        setFromColor: (color: import("three").Color) => Vector3;
                         getComponent: (index: number) => number;
                         clone: () => Vector3;
-                        copy: (v: Vector3) => Vector3;
-                        add: (v: Vector3) => Vector3;
+                        copy: (v: import("three").Vector3Like) => Vector3;
+                        add: (v: import("three").Vector3Like) => Vector3;
                         addScalar: (s: number) => Vector3;
+                        addVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         addScaledVector: (v: Vector3, s: number) => Vector3;
-                        addVectors: (a: Vector3, b: Vector3) => Vector3;
-                        sub: (a: Vector3) => Vector3;
+                        sub: (a: import("three").Vector3Like) => Vector3;
                         subScalar: (s: number) => Vector3;
-                        subVectors: (a: Vector3, b: Vector3) => Vector3;
-                        multiply: (v: Vector3) => Vector3;
+                        subVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
+                        multiply: (v: import("three").Vector3Like) => Vector3;
                         multiplyScalar: (s: number) => Vector3;
-                        multiplyVectors: (a: Vector3, b: Vector3) => Vector3;
+                        multiplyVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         applyEuler: (euler: import("three").Euler) => Vector3;
                         applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
                         applyMatrix3: (m: import("three").Matrix3) => Vector3;
                         applyNormalMatrix: (m: import("three").Matrix3) => Vector3;
                         applyMatrix4: (m: Matrix4) => Vector3;
-                        applyQuaternion: (q: Quaternion) => Vector3;
+                        applyQuaternion: (q: import("three").QuaternionLike) => Vector3;
                         project: (camera: import("three").Camera) => Vector3;
                         unproject: (camera: import("three").Camera) => Vector3;
                         transformDirection: (m: Matrix4) => Vector3;
-                        divide: (v: Vector3) => Vector3;
+                        divide: (v: import("three").Vector3Like) => Vector3;
                         divideScalar: (s: number) => Vector3;
-                        min: (v: Vector3) => Vector3;
-                        max: (v: Vector3) => Vector3;
-                        clamp: (min: Vector3, max: Vector3) => Vector3;
+                        min: (v: import("three").Vector3Like) => Vector3;
+                        max: (v: import("three").Vector3Like) => Vector3;
+                        clamp: (min: import("three").Vector3Like, max: import("three").Vector3Like) => Vector3;
                         clampScalar: (min: number, max: number) => Vector3;
                         clampLength: (min: number, max: number) => Vector3;
                         floor: () => Vector3;
@@ -10232,25 +10157,23 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         round: () => Vector3;
                         roundToZero: () => Vector3;
                         negate: () => Vector3;
-                        dot: (v: Vector3) => number;
+                        dot: (v: import("three").Vector3Like) => number;
                         lengthSq: () => number;
                         length: () => number;
-                        lengthManhattan: () => number;
                         manhattanLength: () => number;
-                        manhattanDistanceTo: (v: Vector3) => number;
                         normalize: () => Vector3;
                         setLength: (l: number) => Vector3;
-                        lerp: (v: Vector3, alpha: number) => Vector3;
-                        lerpVectors: (v1: Vector3, v2: Vector3, alpha: number) => Vector3;
-                        cross: (a: Vector3) => Vector3;
-                        crossVectors: (a: Vector3, b: Vector3) => Vector3;
+                        lerp: (v: import("three").Vector3Like, alpha: number) => Vector3;
+                        lerpVectors: (v1: import("three").Vector3Like, v2: import("three").Vector3Like, alpha: number) => Vector3;
+                        cross: (a: import("three").Vector3Like) => Vector3;
+                        crossVectors: (a: import("three").Vector3Like, b: import("three").Vector3Like) => Vector3;
                         projectOnVector: (v: Vector3) => Vector3;
                         projectOnPlane: (planeNormal: Vector3) => Vector3;
-                        reflect: (vector: Vector3) => Vector3;
+                        reflect: (vector: import("three").Vector3Like) => Vector3;
                         angleTo: (v: Vector3) => number;
-                        distanceTo: (v: Vector3) => number;
-                        distanceToSquared: (v: Vector3) => number;
-                        distanceToManhattan: (v: Vector3) => number;
+                        distanceTo: (v: import("three").Vector3Like) => number;
+                        distanceToSquared: (v: import("three").Vector3Like) => number;
+                        manhattanDistanceTo: (v: import("three").Vector3Like) => number;
                         setFromSpherical: (s: Spherical) => Vector3;
                         setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
                         setFromCylindrical: (s: import("three").Cylindrical) => Vector3;
@@ -10260,14 +10183,15 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                         setFromMatrixColumn: (matrix: Matrix4, index: number) => Vector3;
                         setFromMatrix3Column: (matrix: import("three").Matrix3, index: number) => Vector3;
                         setFromEuler: (e: import("three").Euler) => Vector3;
-                        equals: (v: Vector3) => boolean;
+                        setFromColor: (color: import("three").RGB) => Vector3;
+                        equals: (v: import("three").Vector3Like) => boolean;
                         fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
                         toArray: {
                             (array?: number[] | undefined, offset?: number | undefined): number[];
                             (array?: import("three").Vector3Tuple | undefined, offset?: 0 | undefined): import("three").Vector3Tuple;
                             (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
                         };
-                        fromBufferAttribute: (attribute: import("three").InterleavedBufferAttribute | import("three").BufferAttribute, index: number) => Vector3;
+                        fromBufferAttribute: (attribute: import("three").BufferAttribute | import("three").InterleavedBufferAttribute, index: number) => Vector3;
                         random: () => Vector3;
                         randomDirection: () => Vector3;
                         [Symbol.iterator]: () => Iterator<number, any, undefined>;
@@ -10312,7 +10236,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 stencilFail: import("three").StencilOp;
                 stencilZFail: import("three").StencilOp;
                 stencilZPass: import("three").StencilOp;
-                readonly isMaterial: true;
                 name: string;
                 needsUpdate: boolean;
                 opacity: number;
@@ -10331,12 +10254,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                 uuid: string;
                 vertexColors: boolean;
                 visible: boolean;
-                userData: any;
+                userData: Record<string, any>;
                 version: number;
                 clone: () => import("three").Material;
                 copy: (material: import("three").Material) => import("three").Material;
                 dispose: () => void;
-                onBeforeCompile: (shader: import("three").Shader, renderer: import("three").WebGLRenderer) => void;
+                onBeforeCompile: (parameters: import("three").WebGLProgramParametersWithUniforms, renderer: import("three").WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import("three").MaterialParameters) => void;
                 toJSON: (meta?: any) => any;
@@ -10362,6 +10285,8 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
                     dispose: {};
                 }[T_6]) => void;
             } | undefined;
+            onBeforeShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
+            onAfterShadow: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, depthMaterial: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
             onBeforeRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
             onAfterRender: (renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry<import("three").NormalBufferAttributes>, material: import("three").Material, group: import("three").Group<import("three").Object3DEventMap>) => void;
             applyMatrix4: (matrix: Matrix4) => void;
@@ -10393,7 +10318,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
             getObjectById: (id: number) => Object3D<import("three").Object3DEventMap> | undefined;
             getObjectByName: (name: string) => Object3D<import("three").Object3DEventMap> | undefined;
             getObjectByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap> | undefined;
-            getObjectsByProperty: (name: string, value: any) => Object3D<import("three").Object3DEventMap>[];
+            getObjectsByProperty: (name: string, value: any, optionalTarget?: Object3D<import("three").Object3DEventMap>[] | undefined) => Object3D<import("three").Object3DEventMap>[];
             getWorldPosition: (target: Vector3) => Vector3;
             getWorldQuaternion: (target: Quaternion) => Quaternion;
             getWorldScale: (target: Vector3) => Vector3;
@@ -10503,7 +10428,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     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<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CameraControlsProps>, {
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CameraControlsProps>, {
     makeDefault: boolean;
     minPolarAngle: number;
     maxPolarAngle: number;