@tresjs/cientos 4.0.0-rc.2 → 4.0.0

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

@@ -1,6 +1,5 @@
 import { default as CameraControls } from 'camera-controls';
 import { Camera, Object3D, OrthographicCamera, PerspectiveCamera, Box3, Matrix4, Quaternion, Raycaster, Sphere, Spherical, Vector2, Vector3, Vector4 } from 'three';
-
 export interface CameraControlsProps {
     /**
      * Whether to make this the default controls.
@@ -289,6 +288,32 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
     touches: () => import('camera-controls/dist/types').Touches;
 }>, {
     instance: import('vue').Ref<{
+        addEventListener: {
+            <T extends never>(type: T, listener: import('three').EventListener<{}[T], T, import('three').EventDispatcher<{}> & {
+                enabled: boolean;
+            } & CameraControls>): void;
+            <T extends string>(type: T, listener: import('three').EventListener<{}, T, import('three').EventDispatcher<{}> & {
+                enabled: boolean;
+            } & CameraControls>): void;
+        } & (<K extends keyof import('camera-controls/dist/types').CameraControlsEventMap>(type: K, listener: (event: import('camera-controls/dist/types').CameraControlsEventMap[K]) => any) => void);
+        hasEventListener: {
+            <T extends never>(type: T, listener: import('three').EventListener<{}[T], T, import('three').EventDispatcher<{}> & {
+                enabled: boolean;
+            } & CameraControls>): boolean;
+            <T extends string>(type: T, listener: import('three').EventListener<{}, T, import('three').EventDispatcher<{}> & {
+                enabled: boolean;
+            } & CameraControls>): boolean;
+        } & ((type: string, listener: import('camera-controls/dist/EventDispatcher').Listener) => boolean);
+        removeEventListener: {
+            <T extends never>(type: T, listener: import('three').EventListener<{}[T], T, import('three').EventDispatcher<{}> & {
+                enabled: boolean;
+            } & CameraControls>): void;
+            <T extends string>(type: T, listener: import('three').EventListener<{}, T, import('three').EventDispatcher<{}> & {
+                enabled: boolean;
+            } & CameraControls>): void;
+        } & (<K extends keyof import('camera-controls/dist/types').CameraControlsEventMap>(type: K, listener: (event: import('camera-controls/dist/types').CameraControlsEventMap[K]) => any) => void);
+        dispatchEvent: (<T extends never>(event: import('three').BaseEvent<T> & {}[T]) => void) & ((event: import('camera-controls/dist/EventDispatcher').DispatcherEvent) => void);
+        enabled: boolean;
         minPolarAngle: number;
         maxPolarAngle: number;
         minAzimuthAngle: number;
@@ -502,8 +527,8 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromVector3: (v: Vector3, order?: import('three').EulerOrder) => import('three').Euler;
                 reorder: (newOrder: import('three').EulerOrder) => import('three').Euler;
                 equals: (euler: import('three').Euler) => boolean;
-                fromArray: (xyzo: [number, number, number, import('three').EulerOrder?, ...any[]]) => import('three').Euler;
-                toArray: (array?: Array<number | string | undefined>, offset?: number) => Array<number | string | undefined>;
+                fromArray: (array: import('three').EulerTuple) => import('three').Euler;
+                toArray: (array?: Partial<import('three').EulerTuple>, offset?: number) => import('three').EulerTuple;
                 _onChange: (callback: () => void) => import('three').Euler;
                 [Symbol.iterator]: () => Generator<string | number, void>;
             };
@@ -535,10 +560,10 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 slerp: (qb: Quaternion, t: number) => Quaternion;
                 slerpQuaternions: (qa: Quaternion, qb: Quaternion, t: number) => Quaternion;
                 equals: (v: Quaternion) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Quaternion;
+                fromArray: (array: import('three').QuaternionTuple, offset?: number) => Quaternion;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (array?: number[], offset?: number): import('three').QuaternionTuple;
+                    (array: ArrayLike<number>, offset?: number): import('three').QuaternionTuple;
                 };
                 toJSON: () => [number, number, number, number];
                 fromBufferAttribute: (attribute: import('three').BufferAttribute | import('three').InterleavedBufferAttribute, index: number) => Quaternion;
@@ -633,12 +658,13 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             };
             readonly modelViewMatrix: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -648,7 +674,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -669,37 +694,28 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             readonly normalMatrix: {
                 readonly isMatrix3: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number];
                 set: (n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number) => import('three').Matrix3;
                 identity: () => import('three').Matrix3;
-                clone: () => import('three').Matrix3;
                 copy: (m: import('three').Matrix3) => import('three').Matrix3;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => import('three').Matrix3;
                 setFromMatrix4: (m: Matrix4) => import('three').Matrix3;
+                multiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
                 multiplyScalar: (s: number) => import('three').Matrix3;
                 determinant: () => number;
                 invert: () => import('three').Matrix3;
@@ -708,46 +724,31 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 transposeIntoArray: (r: number[]) => import('three').Matrix3;
                 setUvTransform: (tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number) => import('three').Matrix3;
                 scale: (sx: number, sy: number) => import('three').Matrix3;
+                rotate: (theta: number) => import('three').Matrix3;
+                translate: (tx: number, ty: number) => import('three').Matrix3;
                 makeTranslation: {
                     (v: Vector2): import('three').Matrix3;
                     (x: number, y: number): import('three').Matrix3;
                 };
-                makeRotation: {
-                    (theta: number): import('three').Matrix3;
-                    (theta: number): import('three').Matrix3;
-                };
-                makeScale: {
-                    (x: number, y: number): import('three').Matrix3;
-                    (x: number, y: number): import('three').Matrix3;
-                };
-                rotate: (theta: number) => import('three').Matrix3;
-                translate: (tx: number, ty: number) => import('three').Matrix3;
+                makeRotation: (theta: number) => import('three').Matrix3;
+                makeScale: (x: number, y: number) => import('three').Matrix3;
                 equals: (matrix: import('three').Matrix3) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => import('three').Matrix3;
+                fromArray: (array: ArrayLike<number>, offset?: number) => import('three').Matrix3;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix3Tuple, offset?: 0): import('three').Matrix3Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
-                };
-                multiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
-                multiplyVector3: (vector: Vector3) => any;
-                multiplyVector3Array: (a: any) => any;
-                getInverse: {
-                    (matrix: Matrix4, throwOnDegenerate?: boolean): import('three').Matrix3;
-                    (matrix: import('three').Matrix): import('three').Matrix;
+                    (): import('three').Matrix3Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
+                clone: () => import('three').Matrix3;
             };
             matrix: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -757,7 +758,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -778,36 +778,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             matrixWorld: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -817,7 +807,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -838,27 +827,16 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             matrixAutoUpdate: boolean;
             matrixWorldAutoUpdate: boolean;
@@ -1377,7 +1355,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import('three').MaterialParameters) => void;
-                toJSON: (meta?: any) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                 clone: () => import('three').Material;
                 copy: (material: import('three').Material) => import('three').Material;
                 dispose: () => void;
@@ -1612,7 +1590,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import('three').MaterialParameters) => void;
-                toJSON: (meta?: any) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                 clone: () => import('three').Material;
                 copy: (material: import('three').Material) => import('three').Material;
                 dispose: () => void;
@@ -1686,12 +1664,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             updateMatrix: () => void;
             updateMatrixWorld: (force?: boolean) => void;
             updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
-            toJSON: (meta?: {
-                geometries: any;
-                materials: any;
-                textures: any;
-                images: any;
-            }) => any;
+            toJSON: (meta?: import('three').JSONMeta) => import('three').Object3DJSON;
             clone: (recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
             copy: (object: Object3D, recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
             addEventListener: {
@@ -1753,6 +1726,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             clearViewOffset: () => void;
             updateProjectionMatrix: () => void;
             setLens: (focalLength: number, frameHeight?: number) => void;
+            toJSON: (meta?: import('three').JSONMeta) => import('three').PerspectiveCameraJSON;
             readonly isCamera: true;
             layers: {
                 mask: number;
@@ -1767,12 +1741,13 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             };
             matrixWorldInverse: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -1782,7 +1757,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -1803,36 +1777,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             projectionMatrix: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -1842,7 +1806,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -1863,36 +1826,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             projectionMatrixInverse: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -1902,7 +1855,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -1923,27 +1875,16 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             coordinateSystem: import('three').CoordinateSystem;
             viewport?: {
@@ -2202,8 +2143,8 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromVector3: (v: Vector3, order?: import('three').EulerOrder) => import('three').Euler;
                     reorder: (newOrder: import('three').EulerOrder) => import('three').Euler;
                     equals: (euler: import('three').Euler) => boolean;
-                    fromArray: (xyzo: [number, number, number, import('three').EulerOrder?, ...any[]]) => import('three').Euler;
-                    toArray: (array?: Array<number | string | undefined>, offset?: number) => Array<number | string | undefined>;
+                    fromArray: (array: import('three').EulerTuple) => import('three').Euler;
+                    toArray: (array?: Partial<import('three').EulerTuple>, offset?: number) => import('three').EulerTuple;
                     _onChange: (callback: () => void) => import('three').Euler;
                     [Symbol.iterator]: () => Generator<string | number, void>;
                 };
@@ -2235,10 +2176,10 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     slerp: (qb: Quaternion, t: number) => Quaternion;
                     slerpQuaternions: (qa: Quaternion, qb: Quaternion, t: number) => Quaternion;
                     equals: (v: Quaternion) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Quaternion;
+                    fromArray: (array: import('three').QuaternionTuple, offset?: number) => Quaternion;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (array?: number[], offset?: number): import('three').QuaternionTuple;
+                        (array: ArrayLike<number>, offset?: number): import('three').QuaternionTuple;
                     };
                     toJSON: () => [number, number, number, number];
                     fromBufferAttribute: (attribute: import('three').BufferAttribute | import('three').InterleavedBufferAttribute, index: number) => Quaternion;
@@ -2333,12 +2274,13 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 };
                 readonly modelViewMatrix: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -2348,7 +2290,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -2369,37 +2310,28 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 readonly normalMatrix: {
                     readonly isMatrix3: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number];
                     set: (n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number) => import('three').Matrix3;
                     identity: () => import('three').Matrix3;
-                    clone: () => import('three').Matrix3;
                     copy: (m: import('three').Matrix3) => import('three').Matrix3;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => import('three').Matrix3;
                     setFromMatrix4: (m: Matrix4) => import('three').Matrix3;
+                    multiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                    premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                    multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
                     multiplyScalar: (s: number) => import('three').Matrix3;
                     determinant: () => number;
                     invert: () => import('three').Matrix3;
@@ -2408,46 +2340,31 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     transposeIntoArray: (r: number[]) => import('three').Matrix3;
                     setUvTransform: (tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number) => import('three').Matrix3;
                     scale: (sx: number, sy: number) => import('three').Matrix3;
+                    rotate: (theta: number) => import('three').Matrix3;
+                    translate: (tx: number, ty: number) => import('three').Matrix3;
                     makeTranslation: {
                         (v: Vector2): import('three').Matrix3;
                         (x: number, y: number): import('three').Matrix3;
                     };
-                    makeRotation: {
-                        (theta: number): import('three').Matrix3;
-                        (theta: number): import('three').Matrix3;
-                    };
-                    makeScale: {
-                        (x: number, y: number): import('three').Matrix3;
-                        (x: number, y: number): import('three').Matrix3;
-                    };
-                    rotate: (theta: number) => import('three').Matrix3;
-                    translate: (tx: number, ty: number) => import('three').Matrix3;
+                    makeRotation: (theta: number) => import('three').Matrix3;
+                    makeScale: (x: number, y: number) => import('three').Matrix3;
                     equals: (matrix: import('three').Matrix3) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => import('three').Matrix3;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => import('three').Matrix3;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix3Tuple, offset?: 0): import('three').Matrix3Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix3Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    multiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                    premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                    multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
-                    multiplyVector3: (vector: Vector3) => any;
-                    multiplyVector3Array: (a: any) => any;
-                    getInverse: {
-                        (matrix: Matrix4, throwOnDegenerate?: boolean): import('three').Matrix3;
-                        (matrix: import('three').Matrix): import('three').Matrix;
-                    };
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
+                    clone: () => import('three').Matrix3;
                 };
                 matrix: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -2457,7 +2374,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -2478,36 +2394,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 matrixWorld: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -2517,7 +2423,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -2538,27 +2443,16 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 matrixAutoUpdate: boolean;
                 matrixWorldAutoUpdate: boolean;
@@ -3077,7 +2971,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import('three').MaterialParameters) => void;
-                    toJSON: (meta?: any) => any;
+                    toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                     clone: () => import('three').Material;
                     copy: (material: import('three').Material) => import('three').Material;
                     dispose: () => void;
@@ -3312,7 +3206,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import('three').MaterialParameters) => void;
-                    toJSON: (meta?: any) => any;
+                    toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                     clone: () => import('three').Material;
                     copy: (material: import('three').Material) => import('three').Material;
                     dispose: () => void;
@@ -3386,12 +3280,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 updateMatrix: () => void;
                 updateMatrixWorld: (force?: boolean) => void;
                 updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
-                toJSON: (meta?: {
-                    geometries: any;
-                    materials: any;
-                    textures: any;
-                    images: any;
-                }) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').Object3DJSON;
                 clone: (recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
                 copy: (object: Object3D, recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
                 addEventListener: {
@@ -3599,8 +3488,8 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromVector3: (v: Vector3, order?: import('three').EulerOrder) => import('three').Euler;
                     reorder: (newOrder: import('three').EulerOrder) => import('three').Euler;
                     equals: (euler: import('three').Euler) => boolean;
-                    fromArray: (xyzo: [number, number, number, import('three').EulerOrder?, ...any[]]) => import('three').Euler;
-                    toArray: (array?: Array<number | string | undefined>, offset?: number) => Array<number | string | undefined>;
+                    fromArray: (array: import('three').EulerTuple) => import('three').Euler;
+                    toArray: (array?: Partial<import('three').EulerTuple>, offset?: number) => import('three').EulerTuple;
                     _onChange: (callback: () => void) => import('three').Euler;
                     [Symbol.iterator]: () => Generator<string | number, void>;
                 };
@@ -3632,10 +3521,10 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     slerp: (qb: Quaternion, t: number) => Quaternion;
                     slerpQuaternions: (qa: Quaternion, qb: Quaternion, t: number) => Quaternion;
                     equals: (v: Quaternion) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Quaternion;
+                    fromArray: (array: import('three').QuaternionTuple, offset?: number) => Quaternion;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (array?: number[], offset?: number): import('three').QuaternionTuple;
+                        (array: ArrayLike<number>, offset?: number): import('three').QuaternionTuple;
                     };
                     toJSON: () => [number, number, number, number];
                     fromBufferAttribute: (attribute: import('three').BufferAttribute | import('three').InterleavedBufferAttribute, index: number) => Quaternion;
@@ -3730,12 +3619,13 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 };
                 readonly modelViewMatrix: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -3745,7 +3635,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -3766,37 +3655,28 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 readonly normalMatrix: {
                     readonly isMatrix3: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number];
                     set: (n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number) => import('three').Matrix3;
                     identity: () => import('three').Matrix3;
-                    clone: () => import('three').Matrix3;
                     copy: (m: import('three').Matrix3) => import('three').Matrix3;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => import('three').Matrix3;
                     setFromMatrix4: (m: Matrix4) => import('three').Matrix3;
+                    multiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                    premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                    multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
                     multiplyScalar: (s: number) => import('three').Matrix3;
                     determinant: () => number;
                     invert: () => import('three').Matrix3;
@@ -3805,46 +3685,31 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     transposeIntoArray: (r: number[]) => import('three').Matrix3;
                     setUvTransform: (tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number) => import('three').Matrix3;
                     scale: (sx: number, sy: number) => import('three').Matrix3;
+                    rotate: (theta: number) => import('three').Matrix3;
+                    translate: (tx: number, ty: number) => import('three').Matrix3;
                     makeTranslation: {
                         (v: Vector2): import('three').Matrix3;
                         (x: number, y: number): import('three').Matrix3;
                     };
-                    makeRotation: {
-                        (theta: number): import('three').Matrix3;
-                        (theta: number): import('three').Matrix3;
-                    };
-                    makeScale: {
-                        (x: number, y: number): import('three').Matrix3;
-                        (x: number, y: number): import('three').Matrix3;
-                    };
-                    rotate: (theta: number) => import('three').Matrix3;
-                    translate: (tx: number, ty: number) => import('three').Matrix3;
+                    makeRotation: (theta: number) => import('three').Matrix3;
+                    makeScale: (x: number, y: number) => import('three').Matrix3;
                     equals: (matrix: import('three').Matrix3) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => import('three').Matrix3;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => import('three').Matrix3;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix3Tuple, offset?: 0): import('three').Matrix3Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
-                    };
-                    multiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                    premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                    multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
-                    multiplyVector3: (vector: Vector3) => any;
-                    multiplyVector3Array: (a: any) => any;
-                    getInverse: {
-                        (matrix: Matrix4, throwOnDegenerate?: boolean): import('three').Matrix3;
-                        (matrix: import('three').Matrix): import('three').Matrix;
+                        (): import('three').Matrix3Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
+                    clone: () => import('three').Matrix3;
                 };
                 matrix: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -3854,7 +3719,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -3875,36 +3739,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 matrixWorld: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -3914,7 +3768,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -3935,27 +3788,16 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 matrixAutoUpdate: boolean;
                 matrixWorldAutoUpdate: boolean;
@@ -4474,7 +4316,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import('three').MaterialParameters) => void;
-                    toJSON: (meta?: any) => any;
+                    toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                     clone: () => import('three').Material;
                     copy: (material: import('three').Material) => import('three').Material;
                     dispose: () => void;
@@ -4709,7 +4551,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import('three').MaterialParameters) => void;
-                    toJSON: (meta?: any) => any;
+                    toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                     clone: () => import('three').Material;
                     copy: (material: import('three').Material) => import('three').Material;
                     dispose: () => void;
@@ -4783,12 +4625,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 updateMatrix: () => void;
                 updateMatrixWorld: (force?: boolean) => void;
                 updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
-                toJSON: (meta?: {
-                    geometries: any;
-                    materials: any;
-                    textures: any;
-                    images: any;
-                }) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').Object3DJSON;
                 clone: (recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
                 copy: (object: Object3D, recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
                 addEventListener: {
@@ -4988,8 +4825,8 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromVector3: (v: Vector3, order?: import('three').EulerOrder) => import('three').Euler;
                 reorder: (newOrder: import('three').EulerOrder) => import('three').Euler;
                 equals: (euler: import('three').Euler) => boolean;
-                fromArray: (xyzo: [number, number, number, import('three').EulerOrder?, ...any[]]) => import('three').Euler;
-                toArray: (array?: Array<number | string | undefined>, offset?: number) => Array<number | string | undefined>;
+                fromArray: (array: import('three').EulerTuple) => import('three').Euler;
+                toArray: (array?: Partial<import('three').EulerTuple>, offset?: number) => import('three').EulerTuple;
                 _onChange: (callback: () => void) => import('three').Euler;
                 [Symbol.iterator]: () => Generator<string | number, void>;
             };
@@ -5021,10 +4858,10 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 slerp: (qb: Quaternion, t: number) => Quaternion;
                 slerpQuaternions: (qa: Quaternion, qb: Quaternion, t: number) => Quaternion;
                 equals: (v: Quaternion) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Quaternion;
+                fromArray: (array: import('three').QuaternionTuple, offset?: number) => Quaternion;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (array?: number[], offset?: number): import('three').QuaternionTuple;
+                    (array: ArrayLike<number>, offset?: number): import('three').QuaternionTuple;
                 };
                 toJSON: () => [number, number, number, number];
                 fromBufferAttribute: (attribute: import('three').BufferAttribute | import('three').InterleavedBufferAttribute, index: number) => Quaternion;
@@ -5119,12 +4956,13 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             };
             readonly modelViewMatrix: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -5134,7 +4972,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -5155,37 +4992,28 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             readonly normalMatrix: {
                 readonly isMatrix3: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number];
                 set: (n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number) => import('three').Matrix3;
                 identity: () => import('three').Matrix3;
-                clone: () => import('three').Matrix3;
                 copy: (m: import('three').Matrix3) => import('three').Matrix3;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => import('three').Matrix3;
                 setFromMatrix4: (m: Matrix4) => import('three').Matrix3;
+                multiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
                 multiplyScalar: (s: number) => import('three').Matrix3;
                 determinant: () => number;
                 invert: () => import('three').Matrix3;
@@ -5194,46 +5022,31 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 transposeIntoArray: (r: number[]) => import('three').Matrix3;
                 setUvTransform: (tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number) => import('three').Matrix3;
                 scale: (sx: number, sy: number) => import('three').Matrix3;
+                rotate: (theta: number) => import('three').Matrix3;
+                translate: (tx: number, ty: number) => import('three').Matrix3;
                 makeTranslation: {
                     (v: Vector2): import('three').Matrix3;
                     (x: number, y: number): import('three').Matrix3;
                 };
-                makeRotation: {
-                    (theta: number): import('three').Matrix3;
-                    (theta: number): import('three').Matrix3;
-                };
-                makeScale: {
-                    (x: number, y: number): import('three').Matrix3;
-                    (x: number, y: number): import('three').Matrix3;
-                };
-                rotate: (theta: number) => import('three').Matrix3;
-                translate: (tx: number, ty: number) => import('three').Matrix3;
+                makeRotation: (theta: number) => import('three').Matrix3;
+                makeScale: (x: number, y: number) => import('three').Matrix3;
                 equals: (matrix: import('three').Matrix3) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => import('three').Matrix3;
+                fromArray: (array: ArrayLike<number>, offset?: number) => import('three').Matrix3;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix3Tuple, offset?: 0): import('three').Matrix3Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix3Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                multiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
-                multiplyVector3: (vector: Vector3) => any;
-                multiplyVector3Array: (a: any) => any;
-                getInverse: {
-                    (matrix: Matrix4, throwOnDegenerate?: boolean): import('three').Matrix3;
-                    (matrix: import('three').Matrix): import('three').Matrix;
-                };
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
+                clone: () => import('three').Matrix3;
             };
             matrix: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -5243,7 +5056,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -5264,36 +5076,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             matrixWorld: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -5303,7 +5105,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -5324,27 +5125,16 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             matrixAutoUpdate: boolean;
             matrixWorldAutoUpdate: boolean;
@@ -5852,7 +5642,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import('three').MaterialParameters) => void;
-                toJSON: (meta?: any) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                 clone: () => import('three').Material;
                 copy: (material: import('three').Material) => import('three').Material;
                 dispose: () => void;
@@ -6087,7 +5877,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import('three').MaterialParameters) => void;
-                toJSON: (meta?: any) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                 clone: () => import('three').Material;
                 copy: (material: import('three').Material) => import('three').Material;
                 dispose: () => void;
@@ -6160,12 +5950,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             updateMatrix: () => void;
             updateMatrixWorld: (force?: boolean) => void;
             updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
-            toJSON: (meta?: {
-                geometries: any;
-                materials: any;
-                textures: any;
-                images: any;
-            }) => any;
             clone: (recursive?: boolean) => PerspectiveCamera;
             copy: (object: Object3D, recursive?: boolean) => PerspectiveCamera;
             addEventListener: {
@@ -6203,6 +5987,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             updateProjectionMatrix: () => void;
             setViewOffset: (fullWidth: number, fullHeight: number, offsetX: number, offsetY: number, width: number, height: number) => void;
             clearViewOffset: () => void;
+            toJSON: (meta?: import('three').JSONMeta) => import('three').OrthographicCameraJSON;
             readonly isCamera: true;
             layers: {
                 mask: number;
@@ -6217,12 +6002,13 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             };
             matrixWorldInverse: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -6232,7 +6018,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -6253,36 +6038,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             projectionMatrix: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -6292,7 +6067,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -6313,36 +6087,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             projectionMatrixInverse: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -6352,7 +6116,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -6373,27 +6136,16 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             coordinateSystem: import('three').CoordinateSystem;
             viewport?: {
@@ -6652,8 +6404,8 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromVector3: (v: Vector3, order?: import('three').EulerOrder) => import('three').Euler;
                     reorder: (newOrder: import('three').EulerOrder) => import('three').Euler;
                     equals: (euler: import('three').Euler) => boolean;
-                    fromArray: (xyzo: [number, number, number, import('three').EulerOrder?, ...any[]]) => import('three').Euler;
-                    toArray: (array?: Array<number | string | undefined>, offset?: number) => Array<number | string | undefined>;
+                    fromArray: (array: import('three').EulerTuple) => import('three').Euler;
+                    toArray: (array?: Partial<import('three').EulerTuple>, offset?: number) => import('three').EulerTuple;
                     _onChange: (callback: () => void) => import('three').Euler;
                     [Symbol.iterator]: () => Generator<string | number, void>;
                 };
@@ -6685,10 +6437,10 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     slerp: (qb: Quaternion, t: number) => Quaternion;
                     slerpQuaternions: (qa: Quaternion, qb: Quaternion, t: number) => Quaternion;
                     equals: (v: Quaternion) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Quaternion;
+                    fromArray: (array: import('three').QuaternionTuple, offset?: number) => Quaternion;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (array?: number[], offset?: number): import('three').QuaternionTuple;
+                        (array: ArrayLike<number>, offset?: number): import('three').QuaternionTuple;
                     };
                     toJSON: () => [number, number, number, number];
                     fromBufferAttribute: (attribute: import('three').BufferAttribute | import('three').InterleavedBufferAttribute, index: number) => Quaternion;
@@ -6783,12 +6535,13 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 };
                 readonly modelViewMatrix: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -6798,7 +6551,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -6819,37 +6571,28 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 readonly normalMatrix: {
                     readonly isMatrix3: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number];
                     set: (n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number) => import('three').Matrix3;
                     identity: () => import('three').Matrix3;
-                    clone: () => import('three').Matrix3;
                     copy: (m: import('three').Matrix3) => import('three').Matrix3;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => import('three').Matrix3;
                     setFromMatrix4: (m: Matrix4) => import('three').Matrix3;
+                    multiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                    premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                    multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
                     multiplyScalar: (s: number) => import('three').Matrix3;
                     determinant: () => number;
                     invert: () => import('three').Matrix3;
@@ -6858,46 +6601,31 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     transposeIntoArray: (r: number[]) => import('three').Matrix3;
                     setUvTransform: (tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number) => import('three').Matrix3;
                     scale: (sx: number, sy: number) => import('three').Matrix3;
+                    rotate: (theta: number) => import('three').Matrix3;
+                    translate: (tx: number, ty: number) => import('three').Matrix3;
                     makeTranslation: {
                         (v: Vector2): import('three').Matrix3;
                         (x: number, y: number): import('three').Matrix3;
                     };
-                    makeRotation: {
-                        (theta: number): import('three').Matrix3;
-                        (theta: number): import('three').Matrix3;
-                    };
-                    makeScale: {
-                        (x: number, y: number): import('three').Matrix3;
-                        (x: number, y: number): import('three').Matrix3;
-                    };
-                    rotate: (theta: number) => import('three').Matrix3;
-                    translate: (tx: number, ty: number) => import('three').Matrix3;
+                    makeRotation: (theta: number) => import('three').Matrix3;
+                    makeScale: (x: number, y: number) => import('three').Matrix3;
                     equals: (matrix: import('three').Matrix3) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => import('three').Matrix3;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => import('three').Matrix3;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix3Tuple, offset?: 0): import('three').Matrix3Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix3Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    multiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                    premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                    multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
-                    multiplyVector3: (vector: Vector3) => any;
-                    multiplyVector3Array: (a: any) => any;
-                    getInverse: {
-                        (matrix: Matrix4, throwOnDegenerate?: boolean): import('three').Matrix3;
-                        (matrix: import('three').Matrix): import('three').Matrix;
-                    };
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
+                    clone: () => import('three').Matrix3;
                 };
                 matrix: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -6907,7 +6635,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -6928,36 +6655,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 matrixWorld: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -6967,7 +6684,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -6988,27 +6704,16 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 matrixAutoUpdate: boolean;
                 matrixWorldAutoUpdate: boolean;
@@ -7527,7 +7232,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import('three').MaterialParameters) => void;
-                    toJSON: (meta?: any) => any;
+                    toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                     clone: () => import('three').Material;
                     copy: (material: import('three').Material) => import('three').Material;
                     dispose: () => void;
@@ -7762,7 +7467,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import('three').MaterialParameters) => void;
-                    toJSON: (meta?: any) => any;
+                    toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                     clone: () => import('three').Material;
                     copy: (material: import('three').Material) => import('three').Material;
                     dispose: () => void;
@@ -7836,12 +7541,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 updateMatrix: () => void;
                 updateMatrixWorld: (force?: boolean) => void;
                 updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
-                toJSON: (meta?: {
-                    geometries: any;
-                    materials: any;
-                    textures: any;
-                    images: any;
-                }) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').Object3DJSON;
                 clone: (recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
                 copy: (object: Object3D, recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
                 addEventListener: {
@@ -8049,8 +7749,8 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     setFromVector3: (v: Vector3, order?: import('three').EulerOrder) => import('three').Euler;
                     reorder: (newOrder: import('three').EulerOrder) => import('three').Euler;
                     equals: (euler: import('three').Euler) => boolean;
-                    fromArray: (xyzo: [number, number, number, import('three').EulerOrder?, ...any[]]) => import('three').Euler;
-                    toArray: (array?: Array<number | string | undefined>, offset?: number) => Array<number | string | undefined>;
+                    fromArray: (array: import('three').EulerTuple) => import('three').Euler;
+                    toArray: (array?: Partial<import('three').EulerTuple>, offset?: number) => import('three').EulerTuple;
                     _onChange: (callback: () => void) => import('three').Euler;
                     [Symbol.iterator]: () => Generator<string | number, void>;
                 };
@@ -8082,10 +7782,10 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     slerp: (qb: Quaternion, t: number) => Quaternion;
                     slerpQuaternions: (qa: Quaternion, qb: Quaternion, t: number) => Quaternion;
                     equals: (v: Quaternion) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Quaternion;
+                    fromArray: (array: import('three').QuaternionTuple, offset?: number) => Quaternion;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (array?: number[], offset?: number): import('three').QuaternionTuple;
+                        (array: ArrayLike<number>, offset?: number): import('three').QuaternionTuple;
                     };
                     toJSON: () => [number, number, number, number];
                     fromBufferAttribute: (attribute: import('three').BufferAttribute | import('three').InterleavedBufferAttribute, index: number) => Quaternion;
@@ -8180,12 +7880,13 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 };
                 readonly modelViewMatrix: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -8195,7 +7896,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -8216,37 +7916,28 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 readonly normalMatrix: {
                     readonly isMatrix3: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number];
                     set: (n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number) => import('three').Matrix3;
                     identity: () => import('three').Matrix3;
-                    clone: () => import('three').Matrix3;
                     copy: (m: import('three').Matrix3) => import('three').Matrix3;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => import('three').Matrix3;
                     setFromMatrix4: (m: Matrix4) => import('three').Matrix3;
+                    multiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                    premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                    multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
                     multiplyScalar: (s: number) => import('three').Matrix3;
                     determinant: () => number;
                     invert: () => import('three').Matrix3;
@@ -8255,46 +7946,31 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     transposeIntoArray: (r: number[]) => import('three').Matrix3;
                     setUvTransform: (tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number) => import('three').Matrix3;
                     scale: (sx: number, sy: number) => import('three').Matrix3;
+                    rotate: (theta: number) => import('three').Matrix3;
+                    translate: (tx: number, ty: number) => import('three').Matrix3;
                     makeTranslation: {
                         (v: Vector2): import('three').Matrix3;
                         (x: number, y: number): import('three').Matrix3;
                     };
-                    makeRotation: {
-                        (theta: number): import('three').Matrix3;
-                        (theta: number): import('three').Matrix3;
-                    };
-                    makeScale: {
-                        (x: number, y: number): import('three').Matrix3;
-                        (x: number, y: number): import('three').Matrix3;
-                    };
-                    rotate: (theta: number) => import('three').Matrix3;
-                    translate: (tx: number, ty: number) => import('three').Matrix3;
+                    makeRotation: (theta: number) => import('three').Matrix3;
+                    makeScale: (x: number, y: number) => import('three').Matrix3;
                     equals: (matrix: import('three').Matrix3) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => import('three').Matrix3;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => import('three').Matrix3;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix3Tuple, offset?: 0): import('three').Matrix3Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix3Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    multiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                    premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                    multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
-                    multiplyVector3: (vector: Vector3) => any;
-                    multiplyVector3Array: (a: any) => any;
-                    getInverse: {
-                        (matrix: Matrix4, throwOnDegenerate?: boolean): import('three').Matrix3;
-                        (matrix: import('three').Matrix): import('three').Matrix;
-                    };
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
+                    clone: () => import('three').Matrix3;
                 };
                 matrix: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -8304,7 +7980,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -8325,36 +8000,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 matrixWorld: {
                     readonly isMatrix4: true;
-                    elements: number[];
+                    elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                     set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                     identity: () => Matrix4;
                     clone: () => Matrix4;
                     copy: (m: Matrix4) => Matrix4;
                     copyPosition: (m: Matrix4) => Matrix4;
+                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                     extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                     extractRotation: (m: Matrix4) => Matrix4;
@@ -8364,7 +8029,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     multiply: (m: Matrix4) => Matrix4;
                     premultiply: (m: Matrix4) => Matrix4;
                     multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                    multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                     multiplyScalar: (s: number) => Matrix4;
                     determinant: () => number;
                     transpose: () => Matrix4;
@@ -8385,27 +8049,16 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                     makeScale: (x: number, y: number, z: number) => Matrix4;
                     makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                    compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                    decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                    compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                    decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                     makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                     equals: (matrix: Matrix4) => boolean;
-                    fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                    fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                     toArray: {
-                        (array?: number[], offset?: number): number[];
-                        (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                        (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                        (): import('three').Matrix4Tuple;
+                        <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                     };
-                    setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                    extractPosition: (m: Matrix4) => Matrix4;
-                    setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                    multiplyVector3: (v: any) => any;
-                    multiplyVector4: (v: any) => any;
-                    multiplyVector3Array: (array: number[]) => number[];
-                    rotateAxis: (v: any) => void;
-                    crossVector: (v: any) => void;
-                    flattenToArrayOffset: (array: number[], offset: number) => number[];
-                    getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
                 };
                 matrixAutoUpdate: boolean;
                 matrixWorldAutoUpdate: boolean;
@@ -8924,7 +8577,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import('three').MaterialParameters) => void;
-                    toJSON: (meta?: any) => any;
+                    toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                     clone: () => import('three').Material;
                     copy: (material: import('three').Material) => import('three').Material;
                     dispose: () => void;
@@ -9159,7 +8812,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                     onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                     customProgramCacheKey: () => string;
                     setValues: (values: import('three').MaterialParameters) => void;
-                    toJSON: (meta?: any) => any;
+                    toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                     clone: () => import('three').Material;
                     copy: (material: import('three').Material) => import('three').Material;
                     dispose: () => void;
@@ -9233,12 +8886,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 updateMatrix: () => void;
                 updateMatrixWorld: (force?: boolean) => void;
                 updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
-                toJSON: (meta?: {
-                    geometries: any;
-                    materials: any;
-                    textures: any;
-                    images: any;
-                }) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').Object3DJSON;
                 clone: (recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
                 copy: (object: Object3D, recursive?: boolean) => Object3D<import('three').Object3DEventMap>;
                 addEventListener: {
@@ -9438,8 +9086,8 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 setFromVector3: (v: Vector3, order?: import('three').EulerOrder) => import('three').Euler;
                 reorder: (newOrder: import('three').EulerOrder) => import('three').Euler;
                 equals: (euler: import('three').Euler) => boolean;
-                fromArray: (xyzo: [number, number, number, import('three').EulerOrder?, ...any[]]) => import('three').Euler;
-                toArray: (array?: Array<number | string | undefined>, offset?: number) => Array<number | string | undefined>;
+                fromArray: (array: import('three').EulerTuple) => import('three').Euler;
+                toArray: (array?: Partial<import('three').EulerTuple>, offset?: number) => import('three').EulerTuple;
                 _onChange: (callback: () => void) => import('three').Euler;
                 [Symbol.iterator]: () => Generator<string | number, void>;
             };
@@ -9471,10 +9119,10 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 slerp: (qb: Quaternion, t: number) => Quaternion;
                 slerpQuaternions: (qa: Quaternion, qb: Quaternion, t: number) => Quaternion;
                 equals: (v: Quaternion) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Quaternion;
+                fromArray: (array: import('three').QuaternionTuple, offset?: number) => Quaternion;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (array?: number[], offset?: number): import('three').QuaternionTuple;
+                    (array: ArrayLike<number>, offset?: number): import('three').QuaternionTuple;
                 };
                 toJSON: () => [number, number, number, number];
                 fromBufferAttribute: (attribute: import('three').BufferAttribute | import('three').InterleavedBufferAttribute, index: number) => Quaternion;
@@ -9569,12 +9217,13 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             };
             readonly modelViewMatrix: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -9584,7 +9233,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -9605,37 +9253,28 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             readonly normalMatrix: {
                 readonly isMatrix3: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number];
                 set: (n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number) => import('three').Matrix3;
                 identity: () => import('three').Matrix3;
-                clone: () => import('three').Matrix3;
                 copy: (m: import('three').Matrix3) => import('three').Matrix3;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => import('three').Matrix3;
                 setFromMatrix4: (m: Matrix4) => import('three').Matrix3;
+                multiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
+                multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
                 multiplyScalar: (s: number) => import('three').Matrix3;
                 determinant: () => number;
                 invert: () => import('three').Matrix3;
@@ -9644,46 +9283,31 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 transposeIntoArray: (r: number[]) => import('three').Matrix3;
                 setUvTransform: (tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number) => import('three').Matrix3;
                 scale: (sx: number, sy: number) => import('three').Matrix3;
+                rotate: (theta: number) => import('three').Matrix3;
+                translate: (tx: number, ty: number) => import('three').Matrix3;
                 makeTranslation: {
                     (v: Vector2): import('three').Matrix3;
                     (x: number, y: number): import('three').Matrix3;
                 };
-                makeRotation: {
-                    (theta: number): import('three').Matrix3;
-                    (theta: number): import('three').Matrix3;
-                };
-                makeScale: {
-                    (x: number, y: number): import('three').Matrix3;
-                    (x: number, y: number): import('three').Matrix3;
-                };
-                rotate: (theta: number) => import('three').Matrix3;
-                translate: (tx: number, ty: number) => import('three').Matrix3;
+                makeRotation: (theta: number) => import('three').Matrix3;
+                makeScale: (x: number, y: number) => import('three').Matrix3;
                 equals: (matrix: import('three').Matrix3) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => import('three').Matrix3;
+                fromArray: (array: ArrayLike<number>, offset?: number) => import('three').Matrix3;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix3Tuple, offset?: 0): import('three').Matrix3Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix3Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                multiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                premultiply: (m: import('three').Matrix3) => import('three').Matrix3;
-                multiplyMatrices: (a: import('three').Matrix3, b: import('three').Matrix3) => import('three').Matrix3;
-                multiplyVector3: (vector: Vector3) => any;
-                multiplyVector3Array: (a: any) => any;
-                getInverse: {
-                    (matrix: Matrix4, throwOnDegenerate?: boolean): import('three').Matrix3;
-                    (matrix: import('three').Matrix): import('three').Matrix;
-                };
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
+                clone: () => import('three').Matrix3;
             };
             matrix: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -9693,7 +9317,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -9714,36 +9337,26 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             matrixWorld: {
                 readonly isMatrix4: true;
-                elements: number[];
+                elements: [n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number];
                 set: (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number) => Matrix4;
                 identity: () => Matrix4;
                 clone: () => Matrix4;
                 copy: (m: Matrix4) => Matrix4;
                 copyPosition: (m: Matrix4) => Matrix4;
+                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
                 extractBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 makeBasis: (xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) => Matrix4;
                 extractRotation: (m: Matrix4) => Matrix4;
@@ -9753,7 +9366,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 multiply: (m: Matrix4) => Matrix4;
                 premultiply: (m: Matrix4) => Matrix4;
                 multiplyMatrices: (a: Matrix4, b: Matrix4) => Matrix4;
-                multiplyToArray: (a: Matrix4, b: Matrix4, r: number[]) => Matrix4;
                 multiplyScalar: (s: number) => Matrix4;
                 determinant: () => number;
                 transpose: () => Matrix4;
@@ -9774,27 +9386,16 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 makeRotationAxis: (axis: Vector3, angle: number) => Matrix4;
                 makeScale: (x: number, y: number, z: number) => Matrix4;
                 makeShear: (xy: number, xz: number, yx: number, yz: number, zx: number, zy: number) => Matrix4;
-                compose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
-                decompose: (translation: Vector3, rotation: Quaternion, scale: Vector3) => Matrix4;
+                compose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
+                decompose: (position: Vector3, quaternion: Quaternion, scale: Vector3) => Matrix4;
                 makePerspective: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 makeOrthographic: (left: number, right: number, top: number, bottom: number, near: number, far: number, coordinateSystem?: import('three').CoordinateSystem) => Matrix4;
                 equals: (matrix: Matrix4) => boolean;
-                fromArray: (array: number[] | ArrayLike<number>, offset?: number) => Matrix4;
+                fromArray: (array: ArrayLike<number>, offset?: number) => Matrix4;
                 toArray: {
-                    (array?: number[], offset?: number): number[];
-                    (array?: import('three').Matrix4Tuple, offset?: 0): import('three').Matrix4Tuple;
-                    (array?: ArrayLike<number>, offset?: number): ArrayLike<number>;
+                    (): import('three').Matrix4Tuple;
+                    <TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
                 };
-                setFromMatrix3: (m: import('three').Matrix3) => Matrix4;
-                extractPosition: (m: Matrix4) => Matrix4;
-                setRotationFromQuaternion: (q: Quaternion) => Matrix4;
-                multiplyVector3: (v: any) => any;
-                multiplyVector4: (v: any) => any;
-                multiplyVector3Array: (array: number[]) => number[];
-                rotateAxis: (v: any) => void;
-                crossVector: (v: any) => void;
-                flattenToArrayOffset: (array: number[], offset: number) => number[];
-                getInverse: (matrix: import('three').Matrix) => import('three').Matrix;
             };
             matrixAutoUpdate: boolean;
             matrixWorldAutoUpdate: boolean;
@@ -10302,7 +9903,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import('three').MaterialParameters) => void;
-                toJSON: (meta?: any) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                 clone: () => import('three').Material;
                 copy: (material: import('three').Material) => import('three').Material;
                 dispose: () => void;
@@ -10537,7 +10138,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
                 onBeforeCompile: (parameters: import('three').WebGLProgramParametersWithUniforms, renderer: import('three').WebGLRenderer) => void;
                 customProgramCacheKey: () => string;
                 setValues: (values: import('three').MaterialParameters) => void;
-                toJSON: (meta?: any) => any;
+                toJSON: (meta?: import('three').JSONMeta) => import('three').MaterialJSON;
                 clone: () => import('three').Material;
                 copy: (material: import('three').Material) => import('three').Material;
                 dispose: () => void;
@@ -10610,12 +10211,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             updateMatrix: () => void;
             updateMatrixWorld: (force?: boolean) => void;
             updateWorldMatrix: (updateParents: boolean, updateChildren: boolean) => void;
-            toJSON: (meta?: {
-                geometries: any;
-                materials: any;
-                textures: any;
-                images: any;
-            }) => any;
             clone: (recursive?: boolean) => OrthographicCamera;
             copy: (object: Object3D, recursive?: boolean) => OrthographicCamera;
             addEventListener: {
@@ -10632,7 +10227,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             };
             dispatchEvent: <T extends keyof import('three').Object3DEventMap>(event: import('three').BaseEvent<T> & import('three').Object3DEventMap[T]) => void;
         };
-        enabled: boolean;
         readonly active: boolean;
         readonly currentAction: import('camera-controls/dist/types').ACTION;
         distance: number;
@@ -10655,8 +10249,6 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
             width: number;
             height: number;
         };
-        addEventListener: <K extends keyof import('camera-controls/dist/types').CameraControlsEventMap>(type: K, listener: (event: import('camera-controls/dist/types').CameraControlsEventMap[K]) => any) => void;
-        removeEventListener: <K extends keyof import('camera-controls/dist/types').CameraControlsEventMap>(type: K, listener: (event: import('camera-controls/dist/types').CameraControlsEventMap[K]) => any) => void;
         rotate: (azimuthAngle: number, polarAngle: number, enableTransition?: boolean) => Promise<void>;
         rotateAzimuthTo: (azimuthAngle: number, enableTransition?: boolean) => Promise<void>;
         rotatePolarTo: (polarAngle: number, enableTransition?: boolean) => Promise<void>;
@@ -10689,6 +10281,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
         getSpherical: (out: Spherical, receiveEndValue?: boolean) => Spherical;
         getFocalOffset: (out: Vector3, receiveEndValue?: boolean) => Vector3;
         normalizeRotations: () => void;
+        stop: () => void;
         reset: (enableTransition?: boolean) => Promise<void[]>;
         saveState: () => void;
         updateCameraUp: () => void;
@@ -10701,9 +10294,7 @@ declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_T
         dispose: () => void;
         dampingFactor: number;
         draggingDampingFactor: number;
-        hasEventListener: (type: string, listener: import('camera-controls/dist/EventDispatcher').Listener) => boolean;
         removeAllEventListeners: (type?: string) => void;
-        dispatchEvent: (event: import('camera-controls/dist/EventDispatcher').DispatcherEvent) => void;
     } | null>;
 }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     change: (...args: any[]) => void;