@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Maths/math.vector.d.ts

@@ -0,0 +1,3361 @@
+/**
+ * Class representing a vector containing 2 coordinates
+ * Example Playground - Overview -  https://playground.babylonjs.com/#QYBWV4#9
+ */
+export class Vector2 {
+    /**
+     * Gets a new Vector2(0, 0)
+     * @returns a new Vector2
+     */
+    static Zero(): Vector2;
+    /**
+     * Gets a new Vector2(1, 1)
+     * @returns a new Vector2
+     */
+    static One(): Vector2;
+    /**
+     * Gets a zero Vector2 that must not be updated
+     */
+    static get ZeroReadOnly(): Vector2;
+    /**
+     * Gets a new Vector2 set from the given index element of the given array
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#79
+     * @param array defines the data source
+     * @param offset defines the offset in the data source
+     * @returns a new Vector2
+     */
+    static FromArray(array: any, offset?: number): Vector2;
+    /**
+     * Sets "result" from the given index element of the given array
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#80
+     * @param array defines the data source
+     * @param offset defines the offset in the data source
+     * @param result defines the target vector
+     */
+    static FromArrayToRef(array: any, offset: any, result: any): void;
+    /**
+     * Gets a new Vector2 located for "amount" (float) on the CatmullRom spline defined by the given four Vector2
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#65
+     * @param value1 defines 1st point of control
+     * @param value2 defines 2nd point of control
+     * @param value3 defines 3rd point of control
+     * @param value4 defines 4th point of control
+     * @param amount defines the interpolation factor
+     * @returns a new Vector2
+     */
+    static CatmullRom(value1: any, value2: any, value3: any, value4: any, amount: any): Vector2;
+    /**
+     * Returns a new Vector2 set with same the coordinates than "value" ones if the vector "value" is in the square defined by "min" and "max".
+     * If a coordinate of "value" is lower than "min" coordinates, the returned Vector2 is given this "min" coordinate.
+     * If a coordinate of "value" is greater than "max" coordinates, the returned Vector2 is given this "max" coordinate
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#76
+     * @param value defines the value to clamp
+     * @param min defines the lower limit
+     * @param max defines the upper limit
+     * @returns a new Vector2
+     */
+    static Clamp(value: any, min: any, max: any): Vector2;
+    /**
+     * Returns a new Vector2 located for "amount" (float) on the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2"
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#81
+     * @param value1 defines the 1st control point
+     * @param tangent1 defines the outgoing tangent
+     * @param value2 defines the 2nd control point
+     * @param tangent2 defines the incoming tangent
+     * @param amount defines the interpolation factor
+     * @returns a new Vector2
+     */
+    static Hermite(value1: any, tangent1: any, value2: any, tangent2: any, amount: any): Vector2;
+    /**
+     * Returns a new Vector2 which is the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2".
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#82
+     * @param value1 defines the first control point
+     * @param tangent1 defines the first tangent
+     * @param value2 defines the second control point
+     * @param tangent2 defines the second tangent
+     * @param time define where the derivative must be done
+     * @returns 1st derivative
+     */
+    static Hermite1stDerivative(value1: any, tangent1: any, value2: any, tangent2: any, time: any): Vector2;
+    /**
+     * Returns a new Vector2 which is the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2".
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#83
+     * @param value1 defines the first control point
+     * @param tangent1 defines the first tangent
+     * @param value2 defines the second control point
+     * @param tangent2 defines the second tangent
+     * @param time define where the derivative must be done
+     * @param result define where the derivative will be stored
+     */
+    static Hermite1stDerivativeToRef(value1: any, tangent1: any, value2: any, tangent2: any, time: any, result: any): void;
+    /**
+     * Returns a new Vector2 located for "amount" (float) on the linear interpolation between the vector "start" adn the vector "end".
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#84
+     * @param start defines the start vector
+     * @param end defines the end vector
+     * @param amount defines the interpolation factor
+     * @returns a new Vector2
+     */
+    static Lerp(start: any, end: any, amount: any): Vector2;
+    /**
+     * Gets the dot product of the vector "left" and the vector "right"
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#90
+     * @param left defines first vector
+     * @param right defines second vector
+     * @returns the dot product (float)
+     */
+    static Dot(left: any, right: any): number;
+    /**
+     * Returns a new Vector2 equal to the normalized given vector
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#46
+     * @param vector defines the vector to normalize
+     * @returns a new Vector2
+     */
+    static Normalize(vector: any): Vector2;
+    /**
+     * Normalize a given vector into a second one
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#50
+     * @param vector defines the vector to normalize
+     * @param result defines the vector where to store the result
+     */
+    static NormalizeToRef(vector: any, result: any): void;
+    /**
+     * Gets a new Vector2 set with the minimal coordinate values from the "left" and "right" vectors
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#86
+     * @param left defines 1st vector
+     * @param right defines 2nd vector
+     * @returns a new Vector2
+     */
+    static Minimize(left: any, right: any): Vector2;
+    /**
+     * Gets a new Vector2 set with the maximal coordinate values from the "left" and "right" vectors
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#86
+     * @param left defines 1st vector
+     * @param right defines 2nd vector
+     * @returns a new Vector2
+     */
+    static Maximize(left: any, right: any): Vector2;
+    /**
+     * Gets a new Vector2 set with the transformed coordinates of the given vector by the given transformation matrix
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#17
+     * @param vector defines the vector to transform
+     * @param transformation defines the matrix to apply
+     * @returns a new Vector2
+     */
+    static Transform(vector: any, transformation: any): Vector2;
+    /**
+     * Transforms the given vector coordinates by the given transformation matrix and stores the result in the vector "result" coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#19
+     * @param vector defines the vector to transform
+     * @param transformation defines the matrix to apply
+     * @param result defines the target vector
+     */
+    static TransformToRef(vector: any, transformation: any, result: any): void;
+    /**
+     * Determines if a given vector is included in a triangle
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#87
+     * @param p defines the vector to test
+     * @param p0 defines 1st triangle point
+     * @param p1 defines 2nd triangle point
+     * @param p2 defines 3rd triangle point
+     * @returns true if the point "p" is in the triangle defined by the vectors "p0", "p1", "p2"
+     */
+    static PointInTriangle(p: any, p0: any, p1: any, p2: any): boolean;
+    /**
+     * Gets the distance between the vectors "value1" and "value2"
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#71
+     * @param value1 defines first vector
+     * @param value2 defines second vector
+     * @returns the distance between vectors
+     */
+    static Distance(value1: any, value2: any): number;
+    /**
+     * Returns the squared distance between the vectors "value1" and "value2"
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#72
+     * @param value1 defines first vector
+     * @param value2 defines second vector
+     * @returns the squared distance between vectors
+     */
+    static DistanceSquared(value1: any, value2: any): number;
+    /**
+     * Gets a new Vector2 located at the center of the vectors "value1" and "value2"
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#86
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#66
+     * @param value1 defines first vector
+     * @param value2 defines second vector
+     * @returns a new Vector2
+     */
+    static Center(value1: any, value2: any): any;
+    /**
+     * Gets the center of the vectors "value1" and "value2" and stores the result in the vector "ref"
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#66
+     * @param value1 defines first vector
+     * @param value2 defines second vector
+     * @param ref defines third vector
+     * @returns ref
+     */
+    static CenterToRef(value1: any, value2: any, ref: any): any;
+    /**
+     * Gets the shortest distance (float) between the point "p" and the segment defined by the two points "segA" and "segB".
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#77
+     * @param p defines the middle point
+     * @param segA defines one point of the segment
+     * @param segB defines the other point of the segment
+     * @returns the shortest distance
+     */
+    static DistanceOfPointFromSegment(p: any, segA: any, segB: any): number;
+    /**
+     * Creates a new Vector2 from the given x and y coordinates
+     * @param x defines the first coordinate
+     * @param y defines the second coordinate
+     */
+    constructor(x?: number, y?: number);
+    x: number;
+    y: number;
+    /**
+     * Gets a string with the Vector2 coordinates
+     * @returns a string with the Vector2 coordinates
+     */
+    toString(): string;
+    /**
+     * Gets class name
+     * @returns the string "Vector2"
+     */
+    getClassName(): string;
+    /**
+     * Gets current vector hash code
+     * @returns the Vector2 hash code as a number
+     */
+    getHashCode(): number;
+    /**
+     * Sets the Vector2 coordinates in the given array or Float32Array from the given index.
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#15
+     * @param array defines the source array
+     * @param index defines the offset in source array
+     * @returns the current Vector2
+     */
+    toArray(array: any, index?: number): Vector2;
+    /**
+     * Update the current vector from an array
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#39
+     * @param array defines the destination array
+     * @param index defines the offset in the destination array
+     * @returns the current Vector3
+     */
+    fromArray(array: any, index?: number): Vector2;
+    /**
+     * Copy the current vector to an array
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#40
+     * @returns a new array with 2 elements: the Vector2 coordinates.
+     */
+    asArray(): any[];
+    /**
+     * Sets the Vector2 coordinates with the given Vector2 coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#24
+     * @param source defines the source Vector2
+     * @returns the current updated Vector2
+     */
+    copyFrom(source: any): Vector2;
+    /**
+     * Sets the Vector2 coordinates with the given floats
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#25
+     * @param x defines the first coordinate
+     * @param y defines the second coordinate
+     * @returns the current updated Vector2
+     */
+    copyFromFloats(x: any, y: any): Vector2;
+    /**
+     * Sets the Vector2 coordinates with the given floats
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#62
+     * @param x defines the first coordinate
+     * @param y defines the second coordinate
+     * @returns the current updated Vector2
+     */
+    set(x: any, y: any): Vector2;
+    /**
+     * Add another vector with the current one
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#11
+     * @param otherVector defines the other vector
+     * @returns a new Vector2 set with the addition of the current Vector2 and the given one coordinates
+     */
+    add(otherVector: any): Vector2;
+    /**
+     * Sets the "result" coordinates with the addition of the current Vector2 and the given one coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#12
+     * @param otherVector defines the other vector
+     * @param result defines the target vector
+     * @returns the unmodified current Vector2
+     */
+    addToRef(otherVector: any, result: any): Vector2;
+    /**
+     * Set the Vector2 coordinates by adding the given Vector2 coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#13
+     * @param otherVector defines the other vector
+     * @returns the current updated Vector2
+     */
+    addInPlace(otherVector: any): Vector2;
+    /**
+     * Gets a new Vector2 by adding the current Vector2 coordinates to the given Vector3 x, y coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#14
+     * @param otherVector defines the other vector
+     * @returns a new Vector2
+     */
+    addVector3(otherVector: any): Vector2;
+    /**
+     * Gets a new Vector2 set with the subtracted coordinates of the given one from the current Vector2
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#61
+     * @param otherVector defines the other vector
+     * @returns a new Vector2
+     */
+    subtract(otherVector: any): Vector2;
+    /**
+     * Sets the "result" coordinates with the subtraction of the given one from the current Vector2 coordinates.
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#63
+     * @param otherVector defines the other vector
+     * @param result defines the target vector
+     * @returns the unmodified current Vector2
+     */
+    subtractToRef(otherVector: any, result: any): Vector2;
+    /**
+     * Sets the current Vector2 coordinates by subtracting from it the given one coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#88
+     * @param otherVector defines the other vector
+     * @returns the current updated Vector2
+     */
+    subtractInPlace(otherVector: any): Vector2;
+    /**
+     * Multiplies in place the current Vector2 coordinates by the given ones
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#43
+     * @param otherVector defines the other vector
+     * @returns the current updated Vector2
+     */
+    multiplyInPlace(otherVector: any): Vector2;
+    /**
+     * Returns a new Vector2 set with the multiplication of the current Vector2 and the given one coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#42
+     * @param otherVector defines the other vector
+     * @returns a new Vector2
+     */
+    multiply(otherVector: any): Vector2;
+    /**
+     * Sets "result" coordinates with the multiplication of the current Vector2 and the given one coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#44
+     * @param otherVector defines the other vector
+     * @param result defines the target vector
+     * @returns the unmodified current Vector2
+     */
+    multiplyToRef(otherVector: any, result: any): Vector2;
+    /**
+     * Gets a new Vector2 set with the Vector2 coordinates multiplied by the given floats
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#89
+     * @param x defines the first coordinate
+     * @param y defines the second coordinate
+     * @returns a new Vector2
+     */
+    multiplyByFloats(x: any, y: any): Vector2;
+    /**
+     * Returns a new Vector2 set with the Vector2 coordinates divided by the given one coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#27
+     * @param otherVector defines the other vector
+     * @returns a new Vector2
+     */
+    divide(otherVector: any): Vector2;
+    /**
+     * Sets the "result" coordinates with the Vector2 divided by the given one coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#30
+     * @param otherVector defines the other vector
+     * @param result defines the target vector
+     * @returns the unmodified current Vector2
+     */
+    divideToRef(otherVector: any, result: any): Vector2;
+    /**
+     * Divides the current Vector2 coordinates by the given ones
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#28
+     * @param otherVector defines the other vector
+     * @returns the current updated Vector2
+     */
+    divideInPlace(otherVector: any): Vector2;
+    /**
+     * Gets a new Vector2 with current Vector2 negated coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#22
+     * @returns a new Vector2
+     */
+    negate(): Vector2;
+    /**
+     * Negate this vector in place
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#23
+     * @returns this
+     */
+    negateInPlace(): Vector2;
+    /**
+     * Negate the current Vector2 and stores the result in the given vector "result" coordinates
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#41
+     * @param result defines the Vector3 object where to store the result
+     * @returns the result
+     */
+    negateToRef(result: any): any;
+    /**
+     * Multiply the Vector2 coordinates by
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#59
+     * @param scale defines the scaling factor
+     * @returns the current updated Vector2
+     */
+    scaleInPlace(scale: any): Vector2;
+    /**
+     * Returns a new Vector2 scaled by "scale" from the current Vector2
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#52
+     * @param scale defines the scaling factor
+     * @returns a new Vector2
+     */
+    scale(scale: any): Vector2;
+    /**
+     * Scale the current Vector2 values by a factor to a given Vector2
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#57
+     * @param scale defines the scale factor
+     * @param result defines the Vector2 object where to store the result
+     * @returns the unmodified current Vector2
+     */
+    scaleToRef(scale: any, result: any): Vector2;
+    /**
+     * Scale the current Vector2 values by a factor and add the result to a given Vector2
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#58
+     * @param scale defines the scale factor
+     * @param result defines the Vector2 object where to store the result
+     * @returns the unmodified current Vector2
+     */
+    scaleAndAddToRef(scale: any, result: any): Vector2;
+    /**
+     * Gets a boolean if two vectors are equals
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#31
+     * @param otherVector defines the other vector
+     * @returns true if the given vector coordinates strictly equal the current Vector2 ones
+     */
+    equals(otherVector: any): any;
+    /**
+     * Gets a boolean if two vectors are equals (using an epsilon value)
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#32
+     * @param otherVector defines the other vector
+     * @param epsilon defines the minimal distance to consider equality
+     * @returns true if the given vector coordinates are close to the current ones by a distance of epsilon.
+     */
+    equalsWithEpsilon(otherVector: any, epsilon?: number): any;
+    /**
+     * Gets a new Vector2 from current Vector2 floored values
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#35
+     * eg (1.2, 2.31) returns (1, 2)
+     * @returns a new Vector2
+     */
+    floor(): Vector2;
+    /**
+     * Gets a new Vector2 from current Vector2 fractional values
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#34
+     * eg (1.2, 2.31) returns (0.2, 0.31)
+     * @returns a new Vector2
+     */
+    fract(): Vector2;
+    /**
+     * Rotate the current vector into a given result vector
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#49
+     * @param angle defines the rotation angle
+     * @param result defines the result vector where to store the rotated vector
+     * @returns the current vector
+     */
+    rotateToRef(angle: any, result: any): Vector2;
+    /**
+     * Gets the length of the vector
+     * @returns the vector length (float)
+     */
+    length(): number;
+    /**
+     * Gets the vector squared length
+     * @returns the vector squared length (float)
+     */
+    lengthSquared(): number;
+    /**
+     * Normalize the vector
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#48
+     * @returns the current updated Vector2
+     */
+    normalize(): Vector2;
+    /**
+     * Gets a new Vector2 copied from the Vector2
+     * Example Playground https://playground.babylonjs.com/#QYBWV4#20
+     * @returns a new Vector2
+     */
+    clone(): Vector2;
+}
+export namespace Vector2 {
+    const _ZeroReadOnly: Vector2;
+}
+/**
+ * Class used to store (x,y,z) vector representation
+ * A Vector3 is the main object used in 3D geometry
+ * It can represent either the coordinates of a point the space, either a direction
+ * Reminder: js uses a left handed forward facing system
+ * Example Playground - Overview - https://playground.babylonjs.com/#R1F8YU
+ */
+export class Vector3 {
+    /**
+     * Get the clip factor between two vectors
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#126
+     * @param vector0 defines the first operand
+     * @param vector1 defines the second operand
+     * @param axis defines the axis to use
+     * @param size defines the size along the axis
+     * @returns the clip factor
+     */
+    static GetClipFactor(vector0: any, vector1: any, axis: any, size: any): number;
+    /**
+     * Get angle between two vectors
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#86
+     * @param vector0 the starting point
+     * @param vector1 the ending point
+     * @param normal direction of the normal
+     * @returns the angle between vector0 and vector1
+     */
+    static GetAngleBetweenVectors(vector0: any, vector1: any, normal: any): number;
+    /**
+     * Get angle between two vectors projected on a plane
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#87
+     * Expectation compute time: 0.01 ms (median) and 0.02 ms (percentile 95%)
+     * @param vector0 angle between vector0 and vector1
+     * @param vector1 angle between vector0 and vector1
+     * @param normal Normal of the projection plane
+     * @returns the angle in radians (float) between vector0 and vector1 projected on the plane with the specified normal
+     */
+    static GetAngleBetweenVectorsOnPlane(vector0: any, vector1: any, normal: any): number;
+    /**
+     * Gets the rotation that aligns the roll axis (Y) to the line joining the start point to the target point and stores it in the ref Vector3
+     * Example PG https://playground.babylonjs.com/#R1F8YU#189
+     * @param start the starting point
+     * @param target the target point
+     * @param ref the vector3 to store the result
+     * @returns ref in the form (pitch, yaw, 0)
+     */
+    static PitchYawRollToMoveBetweenPointsToRef(start: any, target: any, ref: any): any;
+    /**
+     * Gets the rotation that aligns the roll axis (Y) to the line joining the start point to the target point
+     * Example PG https://playground.babylonjs.com/#R1F8YU#188
+     * @param start the starting point
+     * @param target the target point
+     * @returns the rotation in the form (pitch, yaw, 0)
+     */
+    static PitchYawRollToMoveBetweenPoints(start: any, target: any): any;
+    /**
+     * Slerp between two vectors. See also `SmoothToRef`
+     * Slerp is a spherical linear interpolation
+     * giving a slow in and out effect
+     * Example Playground 1 https://playground.babylonjs.com/#R1F8YU#108
+     * Example Playground 2 https://playground.babylonjs.com/#R1F8YU#109
+     * @param vector0 Start vector
+     * @param vector1 End vector
+     * @param slerp amount (will be clamped between 0 and 1)
+     * @param result The slerped vector
+     */
+    static SlerpToRef(vector0: any, vector1: any, slerp: any, result: any): void;
+    /**
+     * Smooth interpolation between two vectors using Slerp
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#110
+     * @param source source vector
+     * @param goal goal vector
+     * @param deltaTime current interpolation frame
+     * @param lerpTime total interpolation time
+     * @param result the smoothed vector
+     */
+    static SmoothToRef(source: any, goal: any, deltaTime: any, lerpTime: any, result: any): void;
+    /**
+     * Returns a new Vector3 set from the index "offset" of the given array
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#83
+     * @param array defines the source array
+     * @param offset defines the offset in the source array
+     * @returns the new Vector3
+     */
+    static FromArray(array: any, offset?: number): Vector3;
+    /**
+     * Returns a new Vector3 set from the index "offset" of the given Float32Array
+     * @param array defines the source array
+     * @param offset defines the offset in the source array
+     * @returns the new Vector3
+     * @deprecated Please use FromArray instead.
+     */
+    static FromFloatArray(array: any, offset: any): Vector3;
+    /**
+     * Sets the given vector "result" with the element values from the index "offset" of the given array
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#84
+     * @param array defines the source array
+     * @param offset defines the offset in the source array
+     * @param result defines the Vector3 where to store the result
+     */
+    static FromArrayToRef(array: any, offset: any, result: any): void;
+    /**
+     * Sets the given vector "result" with the element values from the index "offset" of the given Float32Array
+     * @param array defines the source array
+     * @param offset defines the offset in the source array
+     * @param result defines the Vector3 where to store the result
+     * @deprecated Please use FromArrayToRef instead.
+     */
+    static FromFloatArrayToRef(array: any, offset: any, result: any): void;
+    /**
+     * Sets the given vector "result" with the given floats.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#85
+     * @param x defines the x coordinate of the source
+     * @param y defines the y coordinate of the source
+     * @param z defines the z coordinate of the source
+     * @param result defines the Vector3 where to store the result
+     */
+    static FromFloatsToRef(x: any, y: any, z: any, result: any): void;
+    /**
+     * Returns a new Vector3 set to (0.0, 0.0, 0.0)
+     * @returns a new empty Vector3
+     */
+    static Zero(): Vector3;
+    /**
+     * Returns a new Vector3 set to (1.0, 1.0, 1.0)
+     * @returns a new Vector3
+     */
+    static One(): Vector3;
+    /**
+     * Returns a new Vector3 set to (0.0, 1.0, 0.0)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#71
+     * @returns a new up Vector3
+     */
+    static Up(): Vector3;
+    /**
+     * Gets an up Vector3 that must not be updated
+     */
+    static get UpReadOnly(): Vector3;
+    /**
+     * Gets a down Vector3 that must not be updated
+     */
+    static get DownReadOnly(): Vector3;
+    /**
+     * Gets a right Vector3 that must not be updated
+     */
+    static get RightReadOnly(): Vector3;
+    /**
+     * Gets a left Vector3 that must not be updated
+     */
+    static get LeftReadOnly(): Vector3;
+    /**
+     * Gets a forward Vector3 that must not be updated
+     */
+    static get LeftHandedForwardReadOnly(): Vector3;
+    /**
+     * Gets a forward Vector3 that must not be updated
+     */
+    static get RightHandedForwardReadOnly(): Vector3;
+    /**
+     * Gets a zero Vector3 that must not be updated
+     */
+    static get ZeroReadOnly(): Vector3;
+    /**
+     * Returns a new Vector3 set to (0.0, -1.0, 0.0)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#71
+     * @returns a new down Vector3
+     */
+    static Down(): Vector3;
+    /**
+     * Returns a new Vector3 set to (0.0, 0.0, 1.0)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#71
+     * @param rightHandedSystem is the scene right-handed (negative z)
+     * @returns a new forward Vector3
+     */
+    static Forward(rightHandedSystem?: boolean): Vector3;
+    /**
+     * Returns a new Vector3 set to (0.0, 0.0, -1.0)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#71
+     * @param rightHandedSystem is the scene right-handed (negative-z)
+     * @returns a new Backward Vector3
+     */
+    static Backward(rightHandedSystem?: boolean): Vector3;
+    /**
+     * Returns a new Vector3 set to (1.0, 0.0, 0.0)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#71
+     * @returns a new right Vector3
+     */
+    static Right(): Vector3;
+    /**
+     * Returns a new Vector3 set to (-1.0, 0.0, 0.0)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#71
+     * @returns a new left Vector3
+     */
+    static Left(): Vector3;
+    /**
+     * Returns a new Vector3 set with the result of the transformation by the given matrix of the given vector.
+     * This method computes transformed coordinates only, not transformed direction vectors (ie. it takes translation in account)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#111
+     * @param vector defines the Vector3 to transform
+     * @param transformation defines the transformation matrix
+     * @returns the transformed Vector3
+     */
+    static TransformCoordinates(vector: any, transformation: any): Vector3;
+    /**
+     * Sets the given vector "result" coordinates with the result of the transformation by the given matrix of the given vector
+     * This method computes transformed coordinates only, not transformed direction vectors (ie. it takes translation in account)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#113
+     * @param vector defines the Vector3 to transform
+     * @param transformation defines the transformation matrix
+     * @param result defines the Vector3 where to store the result
+     */
+    static TransformCoordinatesToRef(vector: any, transformation: any, result: any): void;
+    /**
+     * Sets the given vector "result" coordinates with the result of the transformation by the given matrix of the given floats (x, y, z)
+     * This method computes transformed coordinates only, not transformed direction vectors
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#115
+     * @param x define the x coordinate of the source vector
+     * @param y define the y coordinate of the source vector
+     * @param z define the z coordinate of the source vector
+     * @param transformation defines the transformation matrix
+     * @param result defines the Vector3 where to store the result
+     */
+    static TransformCoordinatesFromFloatsToRef(x: any, y: any, z: any, transformation: any, result: any): void;
+    /**
+     * Returns a new Vector3 set with the result of the normal transformation by the given matrix of the given vector
+     * This methods computes transformed normalized direction vectors only (ie. it does not apply translation)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#112
+     * @param vector defines the Vector3 to transform
+     * @param transformation defines the transformation matrix
+     * @returns the new Vector3
+     */
+    static TransformNormal(vector: any, transformation: any): Vector3;
+    /**
+     * Sets the given vector "result" with the result of the normal transformation by the given matrix of the given vector
+     * This methods computes transformed normalized direction vectors only (ie. it does not apply translation)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#114
+     * @param vector defines the Vector3 to transform
+     * @param transformation defines the transformation matrix
+     * @param result defines the Vector3 where to store the result
+     */
+    static TransformNormalToRef(vector: any, transformation: any, result: any): void;
+    /**
+     * Sets the given vector "result" with the result of the normal transformation by the given matrix of the given floats (x, y, z)
+     * This methods computes transformed normalized direction vectors only (ie. it does not apply translation)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#116
+     * @param x define the x coordinate of the source vector
+     * @param y define the y coordinate of the source vector
+     * @param z define the z coordinate of the source vector
+     * @param transformation defines the transformation matrix
+     * @param result defines the Vector3 where to store the result
+     */
+    static TransformNormalFromFloatsToRef(x: any, y: any, z: any, transformation: any, result: any): void;
+    /**
+     * Returns a new Vector3 located for "amount" on the CatmullRom interpolation spline defined by the vectors "value1", "value2", "value3", "value4"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#69
+     * @param value1 defines the first control point
+     * @param value2 defines the second control point
+     * @param value3 defines the third control point
+     * @param value4 defines the fourth control point
+     * @param amount defines the amount on the spline to use
+     * @returns the new Vector3
+     */
+    static CatmullRom(value1: any, value2: any, value3: any, value4: any, amount: any): Vector3;
+    /**
+     * Returns a new Vector3 set with the coordinates of "value", if the vector "value" is in the cube defined by the vectors "min" and "max"
+     * If a coordinate value of "value" is lower than one of the "min" coordinate, then this "value" coordinate is set with the "min" one
+     * If a coordinate value of "value" is greater than one of the "max" coordinate, then this "value" coordinate is set with the "max" one
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#76
+     * @param value defines the current value
+     * @param min defines the lower range value
+     * @param max defines the upper range value
+     * @returns the new Vector3
+     */
+    static Clamp(value: any, min: any, max: any): Vector3;
+    /**
+     * Sets the given vector "result" with the coordinates of "value", if the vector "value" is in the cube defined by the vectors "min" and "max"
+     * If a coordinate value of "value" is lower than one of the "min" coordinate, then this "value" coordinate is set with the "min" one
+     * If a coordinate value of "value" is greater than one of the "max" coordinate, then this "value" coordinate is set with the "max" one
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#77
+     * @param value defines the current value
+     * @param min defines the lower range value
+     * @param max defines the upper range value
+     * @param result defines the Vector3 where to store the result
+     */
+    static ClampToRef(value: any, min: any, max: any, result: any): void;
+    /**
+     * Checks if a given vector is inside a specific range
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#75
+     * @param v defines the vector to test
+     * @param min defines the minimum range
+     * @param max defines the maximum range
+     */
+    static CheckExtends(v: any, min: any, max: any): void;
+    /**
+     * Returns a new Vector3 located for "amount" (float) on the Hermite interpolation spline defined by the vectors "value1", "tangent1", "value2", "tangent2"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#89
+     * @param value1 defines the first control point
+     * @param tangent1 defines the first tangent vector
+     * @param value2 defines the second control point
+     * @param tangent2 defines the second tangent vector
+     * @param amount defines the amount on the interpolation spline (between 0 and 1)
+     * @returns the new Vector3
+     */
+    static Hermite(value1: any, tangent1: any, value2: any, tangent2: any, amount: any): Vector3;
+    /**
+     * Returns a new Vector3 which is the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2".
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#90
+     * @param value1 defines the first control point
+     * @param tangent1 defines the first tangent
+     * @param value2 defines the second control point
+     * @param tangent2 defines the second tangent
+     * @param time define where the derivative must be done
+     * @returns 1st derivative
+     */
+    static Hermite1stDerivative(value1: any, tangent1: any, value2: any, tangent2: any, time: any): Vector3;
+    /**
+     * Update a Vector3 with the 1st derivative of the Hermite spline defined by the vectors "value1", "value2", "tangent1", "tangent2".
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#91
+     * @param value1 defines the first control point
+     * @param tangent1 defines the first tangent
+     * @param value2 defines the second control point
+     * @param tangent2 defines the second tangent
+     * @param time define where the derivative must be done
+     * @param result define where to store the derivative
+     */
+    static Hermite1stDerivativeToRef(value1: any, tangent1: any, value2: any, tangent2: any, time: any, result: any): void;
+    /**
+     * Returns a new Vector3 located for "amount" (float) on the linear interpolation between the vectors "start" and "end"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#95
+     * @param start defines the start value
+     * @param end defines the end value
+     * @param amount max defines amount between both (between 0 and 1)
+     * @returns the new Vector3
+     */
+    static Lerp(start: any, end: any, amount: any): Vector3;
+    /**
+     * Sets the given vector "result" with the result of the linear interpolation from the vector "start" for "amount" to the vector "end"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#93
+     * @param start defines the start value
+     * @param end defines the end value
+     * @param amount max defines amount between both (between 0 and 1)
+     * @param result defines the Vector3 where to store the result
+     */
+    static LerpToRef(start: any, end: any, amount: any, result: any): void;
+    /**
+     * Returns the dot product (float) between the vectors "left" and "right"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#82
+     * @param left defines the left operand
+     * @param right defines the right operand
+     * @returns the dot product
+     */
+    static Dot(left: any, right: any): number;
+    /**
+     * Returns a new Vector3 as the cross product of the vectors "left" and "right"
+     * The cross product is then orthogonal to both "left" and "right"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#15
+     * @param left defines the left operand
+     * @param right defines the right operand
+     * @returns the cross product
+     */
+    static Cross(left: any, right: any): Vector3;
+    /**
+     * Sets the given vector "result" with the cross product of "left" and "right"
+     * The cross product is then orthogonal to both "left" and "right"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#78
+     * @param left defines the left operand
+     * @param right defines the right operand
+     * @param result defines the Vector3 where to store the result
+     */
+    static CrossToRef(left: any, right: any, result: any): void;
+    /**
+     * Returns a new Vector3 as the normalization of the given vector
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#98
+     * @param vector defines the Vector3 to normalize
+     * @returns the new Vector3
+     */
+    static Normalize(vector: any): Vector3;
+    /**
+     * Sets the given vector "result" with the normalization of the given first vector
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#98
+     * @param vector defines the Vector3 to normalize
+     * @param result defines the Vector3 where to store the result
+     */
+    static NormalizeToRef(vector: any, result: any): void;
+    /**
+     * Project a Vector3 onto screen space
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#101
+     * @param vector defines the Vector3 to project
+     * @param world defines the world matrix to use
+     * @param transform defines the transform (view x projection) matrix to use
+     * @param viewport defines the screen viewport to use
+     * @returns the new Vector3
+     */
+    static Project(vector: any, world: any, transform: any, viewport: any): Vector3;
+    /**
+     * Project a Vector3 onto screen space to reference
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#102
+     * @param vector defines the Vector3 to project
+     * @param world defines the world matrix to use
+     * @param transform defines the transform (view x projection) matrix to use
+     * @param viewport defines the screen viewport to use
+     * @param result the vector in which the screen space will be stored
+     * @returns the new Vector3
+     */
+    static ProjectToRef(vector: any, world: any, transform: any, viewport: any, result: any): any;
+    /**
+     * @internal
+     */
+    static _UnprojectFromInvertedMatrixToRef(source: any, matrix: any, result: any): void;
+    /**
+     * Unproject from screen space to object space
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#121
+     * @param source defines the screen space Vector3 to use
+     * @param viewportWidth defines the current width of the viewport
+     * @param viewportHeight defines the current height of the viewport
+     * @param world defines the world matrix to use (can be set to Identity to go to world space)
+     * @param transform defines the transform (view x projection) matrix to use
+     * @returns the new Vector3
+     */
+    static UnprojectFromTransform(source: any, viewportWidth: any, viewportHeight: any, world: any, transform: any): Vector3;
+    /**
+     * Unproject from screen space to object space
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#117
+     * @param source defines the screen space Vector3 to use
+     * @param viewportWidth defines the current width of the viewport
+     * @param viewportHeight defines the current height of the viewport
+     * @param world defines the world matrix to use (can be set to Identity to go to world space)
+     * @param view defines the view matrix to use
+     * @param projection defines the projection matrix to use
+     * @returns the new Vector3
+     */
+    static Unproject(source: any, viewportWidth: any, viewportHeight: any, world: any, view: any, projection: any): Vector3;
+    /**
+     * Unproject from screen space to object space
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#119
+     * @param source defines the screen space Vector3 to use
+     * @param viewportWidth defines the current width of the viewport
+     * @param viewportHeight defines the current height of the viewport
+     * @param world defines the world matrix to use (can be set to Identity to go to world space)
+     * @param view defines the view matrix to use
+     * @param projection defines the projection matrix to use
+     * @param result defines the Vector3 where to store the result
+     */
+    static UnprojectToRef(source: any, viewportWidth: any, viewportHeight: any, world: any, view: any, projection: any, result: any): void;
+    /**
+     * Unproject from screen space to object space
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#120
+     * @param sourceX defines the screen space x coordinate to use
+     * @param sourceY defines the screen space y coordinate to use
+     * @param sourceZ defines the screen space z coordinate to use
+     * @param viewportWidth defines the current width of the viewport
+     * @param viewportHeight defines the current height of the viewport
+     * @param world defines the world matrix to use (can be set to Identity to go to world space)
+     * @param view defines the view matrix to use
+     * @param projection defines the projection matrix to use
+     * @param result defines the Vector3 where to store the result
+     */
+    static UnprojectFloatsToRef(sourceX: any, sourceY: any, sourceZ: any, viewportWidth: any, viewportHeight: any, world: any, view: any, projection: any, result: any): void;
+    /**
+     * Gets the minimal coordinate values between two Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#97
+     * @param left defines the first operand
+     * @param right defines the second operand
+     * @returns the new Vector3
+     */
+    static Minimize(left: any, right: any): any;
+    /**
+     * Gets the maximal coordinate values between two Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#96
+     * @param left defines the first operand
+     * @param right defines the second operand
+     * @returns the new Vector3
+     */
+    static Maximize(left: any, right: any): any;
+    /**
+     * Returns the distance between the vectors "value1" and "value2"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#81
+     * @param value1 defines the first operand
+     * @param value2 defines the second operand
+     * @returns the distance
+     */
+    static Distance(value1: any, value2: any): number;
+    /**
+     * Returns the squared distance between the vectors "value1" and "value2"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#80
+     * @param value1 defines the first operand
+     * @param value2 defines the second operand
+     * @returns the squared distance
+     */
+    static DistanceSquared(value1: any, value2: any): number;
+    /**
+     * Projects "vector" on the triangle determined by its extremities "p0", "p1" and "p2", stores the result in "ref"
+     * and returns the distance to the projected point.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#104
+     * From http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.4264&rep=rep1&type=pdf
+     *
+     * @param vector the vector to get distance from
+     * @param p0 extremity of the triangle
+     * @param p1 extremity of the triangle
+     * @param p2 extremity of the triangle
+     * @param ref variable to store the result to
+     * @returns The distance between "ref" and "vector"
+     */
+    static ProjectOnTriangleToRef(vector: any, p0: any, p1: any, p2: any, ref: any): number;
+    /**
+     * Returns a new Vector3 located at the center between "value1" and "value2"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#72
+     * @param value1 defines the first operand
+     * @param value2 defines the second operand
+     * @returns the new Vector3
+     */
+    static Center(value1: any, value2: any): any;
+    /**
+     * Gets the center of the vectors "value1" and "value2" and stores the result in the vector "ref"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#73
+     * @param value1 defines first vector
+     * @param value2 defines second vector
+     * @param ref defines third vector
+     * @returns ref
+     */
+    static CenterToRef(value1: any, value2: any, ref: any): any;
+    /**
+     * Given three orthogonal normalized left-handed oriented Vector3 axis in space (target system),
+     * RotationFromAxis() returns the rotation Euler angles (ex : rotation.x, rotation.y, rotation.z) to apply
+     * to something in order to rotate it from its local system to the given target system
+     * Note: axis1, axis2 and axis3 are normalized during this operation
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#106
+     * @param axis1 defines the first axis
+     * @param axis2 defines the second axis
+     * @param axis3 defines the third axis
+     * @returns a new Vector3
+     * @see https://doc.babylonjs.com/divingDeeper/mesh/transforms/center_origin/target_align
+     */
+    static RotationFromAxis(axis1: any, axis2: any, axis3: any): Vector3;
+    /**
+     * The same than RotationFromAxis but updates the given ref Vector3 parameter instead of returning a new Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#107
+     * @param axis1 defines the first axis
+     * @param axis2 defines the second axis
+     * @param axis3 defines the third axis
+     * @param ref defines the Vector3 where to store the result
+     */
+    static RotationFromAxisToRef(axis1: any, axis2: any, axis3: any, ref: any): void;
+    /**
+     * Creates a new Vector3 object from the given x, y, z (floats) coordinates.
+     * @param x defines the first coordinates (on X axis)
+     * @param y defines the second coordinates (on Y axis)
+     * @param z defines the third coordinates (on Z axis)
+     */
+    constructor(x?: number, y?: number, z?: number);
+    /** @internal */
+    _isDirty: boolean;
+    _x: number;
+    _y: number;
+    _z: number;
+    set x(arg: number);
+    /** Gets or sets the x coordinate */
+    get x(): number;
+    set y(arg: number);
+    /** Gets or sets the y coordinate */
+    get y(): number;
+    set z(arg: number);
+    /** Gets or sets the z coordinate */
+    get z(): number;
+    /**
+     * Creates a string representation of the Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#67
+     * @returns a string with the Vector3 coordinates.
+     */
+    toString(): string;
+    /**
+     * Gets the class name
+     * @returns the string "Vector3"
+     */
+    getClassName(): string;
+    /**
+     * Creates the Vector3 hash code
+     * @returns a number which tends to be unique between Vector3 instances
+     */
+    getHashCode(): number;
+    /**
+     * Creates an array containing three elements : the coordinates of the Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#10
+     * @returns a new array of numbers
+     */
+    asArray(): any[];
+    /**
+     * Populates the given array or Float32Array from the given index with the successive coordinates of the Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#65
+     * @param array defines the destination array
+     * @param index defines the offset in the destination array
+     * @returns the current Vector3
+     */
+    toArray(array: any, index?: number): Vector3;
+    /**
+     * Update the current vector from an array
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#24
+     * @param array defines the destination array
+     * @param index defines the offset in the destination array
+     * @returns the current Vector3
+     */
+    fromArray(array: any, index?: number): Vector3;
+    /**
+     * Converts the current Vector3 into a quaternion (considering that the Vector3 contains Euler angles representation of a rotation)
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#66
+     * @returns a new Quaternion object, computed from the Vector3 coordinates
+     */
+    toQuaternion(): Quaternion;
+    /**
+     * Adds the given vector to the current Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#4
+     * @param otherVector defines the second operand
+     * @returns the current updated Vector3
+     */
+    addInPlace(otherVector: any): Vector3;
+    /**
+     * Adds the given coordinates to the current Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#5
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @returns the current updated Vector3
+     */
+    addInPlaceFromFloats(x: any, y: any, z: any): Vector3;
+    /**
+     * Gets a new Vector3, result of the addition the current Vector3 and the given vector
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#3
+     * @param otherVector defines the second operand
+     * @returns the resulting Vector3
+     */
+    add(otherVector: any): Vector3;
+    /**
+     * Adds the current Vector3 to the given one and stores the result in the vector "result"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#6
+     * @param otherVector defines the second operand
+     * @param result defines the Vector3 object where to store the result
+     * @returns the result
+     */
+    addToRef(otherVector: any, result: any): any;
+    /**
+     * Subtract the given vector from the current Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#61
+     * @param otherVector defines the second operand
+     * @returns the current updated Vector3
+     */
+    subtractInPlace(otherVector: any): Vector3;
+    /**
+     * Returns a new Vector3, result of the subtraction of the given vector from the current Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#60
+     * @param otherVector defines the second operand
+     * @returns the resulting Vector3
+     */
+    subtract(otherVector: any): Vector3;
+    /**
+     * Subtracts the given vector from the current Vector3 and stores the result in the vector "result".
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#63
+     * @param otherVector defines the second operand
+     * @param result defines the Vector3 object where to store the result
+     * @returns the result
+     */
+    subtractToRef(otherVector: any, result: any): any;
+    /**
+     * Returns a new Vector3 set with the subtraction of the given floats from the current Vector3 coordinates
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#62
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @returns the resulting Vector3
+     */
+    subtractFromFloats(x: any, y: any, z: any): Vector3;
+    /**
+     * Subtracts the given floats from the current Vector3 coordinates and set the given vector "result" with this result
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#64
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @param result defines the Vector3 object where to store the result
+     * @returns the result
+     */
+    subtractFromFloatsToRef(x: any, y: any, z: any, result: any): any;
+    /**
+     * Gets a new Vector3 set with the current Vector3 negated coordinates
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#35
+     * @returns a new Vector3
+     */
+    negate(): Vector3;
+    /**
+     * Negate this vector in place
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#36
+     * @returns this
+     */
+    negateInPlace(): Vector3;
+    /**
+     * Negate the current Vector3 and stores the result in the given vector "result" coordinates
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#37
+     * @param result defines the Vector3 object where to store the result
+     * @returns the result
+     */
+    negateToRef(result: any): any;
+    /**
+     * Multiplies the Vector3 coordinates by the float "scale"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#56
+     * @param scale defines the multiplier factor
+     * @returns the current updated Vector3
+     */
+    scaleInPlace(scale: any): Vector3;
+    /**
+     * Returns a new Vector3 set with the current Vector3 coordinates multiplied by the float "scale"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#53
+     * @param scale defines the multiplier factor
+     * @returns a new Vector3
+     */
+    scale(scale: any): Vector3;
+    /**
+     * Multiplies the current Vector3 coordinates by the float "scale" and stores the result in the given vector "result" coordinates
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#57
+     * @param scale defines the multiplier factor
+     * @param result defines the Vector3 object where to store the result
+     * @returns the result
+     */
+    scaleToRef(scale: any, result: any): any;
+    /**
+     * Creates a vector normal (perpendicular) to the current Vector3 and stores the result in the given vector
+     * @param result defines the Vector3 object where to store the resultant normal
+     * returns the result
+     * @hidden
+     */
+    _getNormalToRef(result: any): any;
+    /**
+     * Rotates the vector using the given unit quaternion and stores the new vector in result
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#9
+     * @param q the unit quaternion representing the rotation
+     * @param result the output vector
+     * @returns the result
+     */
+    applyRotationQuaternionToRef(q: any, result: any): any;
+    /**
+     * Rotates the vector in place using the given unit quaternion
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#8
+     * @param q the unit quaternion representing the rotation
+     * @returns the current updated Vector3
+     */
+    applyRotationQuaternionInPlace(q: any): any;
+    /**
+     * Rotates the vector using the given unit quaternion and returns the new vector
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#7
+     * @param q the unit quaternion representing the rotation
+     * @returns a new Vector3
+     */
+    applyRotationQuaternion(q: any): any;
+    /**
+     * Scale the current Vector3 values by a factor and add the result to a given Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#55
+     * @param scale defines the scale factor
+     * @param result defines the Vector3 object where to store the result
+     * @returns the unmodified current Vector3
+     */
+    scaleAndAddToRef(scale: any, result: any): any;
+    /**
+     * Projects the current point Vector3 to a plane along a ray starting from a specified origin and passing through the current point Vector3.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#48
+     * @param plane defines the plane to project to
+     * @param origin defines the origin of the projection ray
+     * @returns the projected vector3
+     */
+    projectOnPlane(plane: any, origin: any): Vector3;
+    /**
+     * Projects the current point Vector3 to a plane along a ray starting from a specified origin and passing through the current point Vector3.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#49
+     * @param plane defines the plane to project to
+     * @param origin defines the origin of the projection ray
+     * @param result defines the Vector3 where to store the result
+     */
+    projectOnPlaneToRef(plane: any, origin: any, result: any): void;
+    /**
+     * Returns true if the current Vector3 and the given vector coordinates are strictly equal
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#19
+     * @param otherVector defines the second operand
+     * @returns true if both vectors are equals
+     */
+    equals(otherVector: any): any;
+    /**
+     * Returns true if the current Vector3 and the given vector coordinates are distant less than epsilon
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#21
+     * @param otherVector defines the second operand
+     * @param epsilon defines the minimal distance to define values as equals
+     * @returns true if both vectors are distant less than epsilon
+     */
+    equalsWithEpsilon(otherVector: any, epsilon?: number): any;
+    /**
+     * Returns true if the current Vector3 coordinates equals the given floats
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#20
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @returns true if both vectors are equal
+     */
+    equalsToFloats(x: any, y: any, z: any): boolean;
+    /**
+     * Multiplies the current Vector3 coordinates by the given ones
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#32
+     * @param otherVector defines the second operand
+     * @returns the current updated Vector3
+     */
+    multiplyInPlace(otherVector: any): Vector3;
+    /**
+     * Returns a new Vector3, result of the multiplication of the current Vector3 by the given vector
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#31
+     * @param otherVector defines the second operand
+     * @returns the new Vector3
+     */
+    multiply(otherVector: any): Vector3;
+    /**
+     * Multiplies the current Vector3 by the given one and stores the result in the given vector "result"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#33
+     * @param otherVector defines the second operand
+     * @param result defines the Vector3 object where to store the result
+     * @returns the result
+     */
+    multiplyToRef(otherVector: any, result: any): any;
+    /**
+     * Returns a new Vector3 set with the result of the multiplication of the current Vector3 coordinates by the given floats
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#34
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @returns the new Vector3
+     */
+    multiplyByFloats(x: any, y: any, z: any): Vector3;
+    /**
+     * Returns a new Vector3 set with the result of the division of the current Vector3 coordinates by the given ones
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#16
+     * @param otherVector defines the second operand
+     * @returns the new Vector3
+     */
+    divide(otherVector: any): Vector3;
+    /**
+     * Divides the current Vector3 coordinates by the given ones and stores the result in the given vector "result"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#18
+     * @param otherVector defines the second operand
+     * @param result defines the Vector3 object where to store the result
+     * @returns the result
+     */
+    divideToRef(otherVector: any, result: any): any;
+    /**
+     * Divides the current Vector3 coordinates by the given ones.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#17
+     * @param otherVector defines the second operand
+     * @returns the current updated Vector3
+     */
+    divideInPlace(otherVector: any): any;
+    /**
+     * Updates the current Vector3 with the minimal coordinate values between its and the given vector ones
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#29
+     * @param other defines the second operand
+     * @returns the current updated Vector3
+     */
+    minimizeInPlace(other: any): Vector3;
+    /**
+     * Updates the current Vector3 with the maximal coordinate values between its and the given vector ones.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#27
+     * @param other defines the second operand
+     * @returns the current updated Vector3
+     */
+    maximizeInPlace(other: any): Vector3;
+    /**
+     * Updates the current Vector3 with the minimal coordinate values between its and the given coordinates
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#30
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @returns the current updated Vector3
+     */
+    minimizeInPlaceFromFloats(x: any, y: any, z: any): Vector3;
+    /**
+     * Updates the current Vector3 with the maximal coordinate values between its and the given coordinates.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#28
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @returns the current updated Vector3
+     */
+    maximizeInPlaceFromFloats(x: any, y: any, z: any): Vector3;
+    /**
+     * Due to float precision, scale of a mesh could be uniform but float values are off by a small fraction
+     * Check if is non uniform within a certain amount of decimal places to account for this
+     * @param epsilon the amount the values can differ
+     * @returns if the the vector is non uniform to a certain number of decimal places
+     */
+    isNonUniformWithinEpsilon(epsilon: any): boolean;
+    /**
+     * Gets a boolean indicating that the vector is non uniform meaning x, y or z are not all the same
+     */
+    get isNonUniform(): boolean;
+    /**
+     * Gets a new Vector3 from current Vector3 floored values
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#22
+     * @returns a new Vector3
+     */
+    floor(): Vector3;
+    /**
+     * Gets a new Vector3 from current Vector3 fractional values
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#23
+     * @returns a new Vector3
+     */
+    fract(): Vector3;
+    /**
+     * Gets the length of the Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#25
+     * @returns the length of the Vector3
+     */
+    length(): number;
+    /**
+     * Gets the squared length of the Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#26
+     * @returns squared length of the Vector3
+     */
+    lengthSquared(): number;
+    /**
+     * Gets a boolean indicating if the vector contains a zero in one of its components
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#1
+     */
+    get hasAZeroComponent(): boolean;
+    /**
+     * Normalize the current Vector3.
+     * Please note that this is an in place operation.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#122
+     * @returns the current updated Vector3
+     */
+    normalize(): Vector3;
+    /**
+     * Reorders the x y z properties of the vector in place
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#44
+     * @param order new ordering of the properties (eg. for vector 1,2,3 with "ZYX" will produce 3,2,1)
+     * @returns the current updated vector
+     */
+    reorderInPlace(order: any): Vector3;
+    /**
+     * Rotates the vector around 0,0,0 by a quaternion
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#47
+     * @param quaternion the rotation quaternion
+     * @param result vector to store the result
+     * @returns the resulting vector
+     */
+    rotateByQuaternionToRef(quaternion: any, result: any): any;
+    /**
+     * Rotates a vector around a given point
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#46
+     * @param quaternion the rotation quaternion
+     * @param point the point to rotate around
+     * @param result vector to store the result
+     * @returns the resulting vector
+     */
+    rotateByQuaternionAroundPointToRef(quaternion: any, point: any, result: any): any;
+    /**
+     * Returns a new Vector3 as the cross product of the current vector and the "other" one
+     * The cross product is then orthogonal to both current and "other"
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#14
+     * @param other defines the right operand
+     * @returns the cross product
+     */
+    cross(other: any): Vector3;
+    /**
+     * Normalize the current Vector3 with the given input length.
+     * Please note that this is an in place operation.
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#123
+     * @param len the length of the vector
+     * @returns the current updated Vector3
+     */
+    normalizeFromLength(len: any): Vector3;
+    /**
+     * Normalize the current Vector3 to a new vector
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#124
+     * @returns the new Vector3
+     */
+    normalizeToNew(): Vector3;
+    /**
+     * Normalize the current Vector3 to the reference
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#125
+     * @param reference define the Vector3 to update
+     * @returns the updated Vector3
+     */
+    normalizeToRef(reference: any): any;
+    /**
+     * Creates a new Vector3 copied from the current Vector3
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#11
+     * @returns the new Vector3
+     */
+    clone(): Vector3;
+    /**
+     * Copies the given vector coordinates to the current Vector3 ones
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#12
+     * @param source defines the source Vector3
+     * @returns the current updated Vector3
+     */
+    copyFrom(source: any): Vector3;
+    /**
+     * Copies the given floats to the current Vector3 coordinates
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#13
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @returns the current updated Vector3
+     */
+    copyFromFloats(x: any, y: any, z: any): Vector3;
+    /**
+     * Copies the given floats to the current Vector3 coordinates
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#58
+     * @param x defines the x coordinate of the operand
+     * @param y defines the y coordinate of the operand
+     * @param z defines the z coordinate of the operand
+     * @returns the current updated Vector3
+     */
+    set(x: any, y: any, z: any): Vector3;
+    /**
+     * Copies the given float to the current Vector3 coordinates
+     * Example Playground https://playground.babylonjs.com/#R1F8YU#59
+     * @param v defines the x, y and z coordinates of the operand
+     * @returns the current updated Vector3
+     */
+    setAll(v: any): Vector3;
+}
+export namespace Vector3 {
+    export const _UpReadOnly: Vector3;
+    export const _DownReadOnly: Vector3;
+    export const _LeftHandedForwardReadOnly: Vector3;
+    export const _RightHandedForwardReadOnly: Vector3;
+    export const _RightReadOnly: Vector3;
+    export const _LeftReadOnly: Vector3;
+    const _ZeroReadOnly_1: Vector3;
+    export { _ZeroReadOnly_1 as _ZeroReadOnly };
+}
+/**
+ * Vector4 class created for EulerAngle class conversion to Quaternion
+ */
+export class Vector4 {
+    /**
+     * Returns a new Vector4 set from the starting index of the given array.
+     * @param array the array to pull values from
+     * @param offset the offset into the array to start at
+     * @returns the new vector
+     */
+    static FromArray(array: any, offset: any): Vector4;
+    /**
+     * Updates the given vector "result" from the starting index of the given array.
+     * @param array the array to pull values from
+     * @param offset the offset into the array to start at
+     * @param result the vector to store the result in
+     */
+    static FromArrayToRef(array: any, offset: any, result: any): void;
+    /**
+     * Updates the given vector "result" from the starting index of the given Float32Array.
+     * @param array the array to pull values from
+     * @param offset the offset into the array to start at
+     * @param result the vector to store the result in
+     */
+    static FromFloatArrayToRef(array: any, offset: any, result: any): void;
+    /**
+     * Updates the given vector "result" coordinates from the given floats.
+     * @param x float to set from
+     * @param y float to set from
+     * @param z float to set from
+     * @param w float to set from
+     * @param result the vector to the floats in
+     */
+    static FromFloatsToRef(x: any, y: any, z: any, w: any, result: any): void;
+    /**
+     * Returns a new Vector4 set to (0.0, 0.0, 0.0, 0.0)
+     * @returns the new vector
+     */
+    static Zero(): Vector4;
+    /**
+     * Returns a new Vector4 set to (1.0, 1.0, 1.0, 1.0)
+     * @returns the new vector
+     */
+    static One(): Vector4;
+    /**
+     * Gets a zero Vector4 that must not be updated
+     */
+    static get ZeroReadOnly(): Vector4;
+    /**
+     * Returns a new normalized Vector4 from the given one.
+     * @param vector the vector to normalize
+     * @returns the vector
+     */
+    static Normalize(vector: any): Vector4;
+    /**
+     * Updates the given vector "result" from the normalization of the given one.
+     * @param vector the vector to normalize
+     * @param result the vector to store the result in
+     */
+    static NormalizeToRef(vector: any, result: any): void;
+    /**
+     * Returns a vector with the minimum values from the left and right vectors
+     * @param left left vector to minimize
+     * @param right right vector to minimize
+     * @returns a new vector with the minimum of the left and right vector values
+     */
+    static Minimize(left: any, right: any): any;
+    /**
+     * Returns a vector with the maximum values from the left and right vectors
+     * @param left left vector to maximize
+     * @param right right vector to maximize
+     * @returns a new vector with the maximum of the left and right vector values
+     */
+    static Maximize(left: any, right: any): any;
+    /**
+     * Returns the distance (float) between the vectors "value1" and "value2".
+     * @param value1 value to calulate the distance between
+     * @param value2 value to calulate the distance between
+     * @returns the distance between the two vectors
+     */
+    static Distance(value1: any, value2: any): number;
+    /**
+     * Returns the squared distance (float) between the vectors "value1" and "value2".
+     * @param value1 value to calulate the distance between
+     * @param value2 value to calulate the distance between
+     * @returns the distance between the two vectors squared
+     */
+    static DistanceSquared(value1: any, value2: any): number;
+    /**
+     * Returns a new Vector4 located at the center between the vectors "value1" and "value2".
+     * @param value1 value to calulate the center between
+     * @param value2 value to calulate the center between
+     * @returns the center between the two vectors
+     */
+    static Center(value1: any, value2: any): any;
+    /**
+     * Gets the center of the vectors "value1" and "value2" and stores the result in the vector "ref"
+     * @param value1 defines first vector
+     * @param value2 defines second vector
+     * @param ref defines third vector
+     * @returns ref
+     */
+    static CenterToRef(value1: any, value2: any, ref: any): any;
+    /**
+     * Returns a new Vector4 set with the result of the transformation by the given matrix of the given vector.
+     * This method computes tranformed coordinates only, not transformed direction vectors (ie. it takes translation in account)
+     * The difference with Vector3.TransformCoordinates is that the w component is not used to divide the other coordinates but is returned in the w coordinate instead
+     * @param vector defines the Vector3 to transform
+     * @param transformation defines the transformation matrix
+     * @returns the transformed Vector4
+     */
+    static TransformCoordinates(vector: any, transformation: any): Vector4;
+    /**
+     * Sets the given vector "result" coordinates with the result of the transformation by the given matrix of the given vector
+     * This method computes tranformed coordinates only, not transformed direction vectors (ie. it takes translation in account)
+     * The difference with Vector3.TransformCoordinatesToRef is that the w component is not used to divide the other coordinates but is returned in the w coordinate instead
+     * @param vector defines the Vector3 to transform
+     * @param transformation defines the transformation matrix
+     * @param result defines the Vector4 where to store the result
+     */
+    static TransformCoordinatesToRef(vector: any, transformation: any, result: any): void;
+    /**
+     * Sets the given vector "result" coordinates with the result of the transformation by the given matrix of the given floats (x, y, z)
+     * This method computes tranformed coordinates only, not transformed direction vectors
+     * The difference with Vector3.TransformCoordinatesFromFloatsToRef is that the w component is not used to divide the other coordinates but is returned in the w coordinate instead
+     * @param x define the x coordinate of the source vector
+     * @param y define the y coordinate of the source vector
+     * @param z define the z coordinate of the source vector
+     * @param transformation defines the transformation matrix
+     * @param result defines the Vector4 where to store the result
+     */
+    static TransformCoordinatesFromFloatsToRef(x: any, y: any, z: any, transformation: any, result: any): void;
+    /**
+     * Returns a new Vector4 set with the result of the normal transformation by the given matrix of the given vector.
+     * This methods computes transformed normalized direction vectors only.
+     * @param vector the vector to transform
+     * @param transformation the transformation matrix to apply
+     * @returns the new vector
+     */
+    static TransformNormal(vector: any, transformation: any): Vector4;
+    /**
+     * Sets the given vector "result" with the result of the normal transformation by the given matrix of the given vector.
+     * This methods computes transformed normalized direction vectors only.
+     * @param vector the vector to transform
+     * @param transformation the transformation matrix to apply
+     * @param result the vector to store the result in
+     */
+    static TransformNormalToRef(vector: any, transformation: any, result: any): void;
+    /**
+     * Sets the given vector "result" with the result of the normal transformation by the given matrix of the given floats (x, y, z, w).
+     * This methods computes transformed normalized direction vectors only.
+     * @param x value to transform
+     * @param y value to transform
+     * @param z value to transform
+     * @param w value to transform
+     * @param transformation the transformation matrix to apply
+     * @param result the vector to store the results in
+     */
+    static TransformNormalFromFloatsToRef(x: any, y: any, z: any, w: any, transformation: any, result: any): void;
+    /**
+     * Creates a new Vector4 from a Vector3
+     * @param source defines the source data
+     * @param w defines the 4th component (default is 0)
+     * @returns a new Vector4
+     */
+    static FromVector3(source: any, w?: number): Vector4;
+    /**
+     * Creates a Vector4 object from the given floats.
+     * @param x x value of the vector
+     * @param y y value of the vector
+     * @param z z value of the vector
+     * @param w w value of the vector
+     */
+    constructor(x: any, y: any, z: any, w: any);
+    x: any;
+    y: any;
+    z: any;
+    w: any;
+    /**
+     * Returns the string with the Vector4 coordinates.
+     * @returns a string containing all the vector values
+     */
+    toString(): string;
+    /**
+     * Returns the string "Vector4".
+     * @returns "Vector4"
+     */
+    getClassName(): string;
+    /**
+     * Returns the Vector4 hash code.
+     * @returns a unique hash code
+     */
+    getHashCode(): number;
+    /**
+     * Returns a new array populated with 4 elements : the Vector4 coordinates.
+     * @returns the resulting array
+     */
+    asArray(): any[];
+    /**
+     * Populates the given array from the given index with the Vector4 coordinates.
+     * @param array array to populate
+     * @param index index of the array to start at (default: 0)
+     * @returns the Vector4.
+     */
+    toArray(array: any, index: any): Vector4;
+    /**
+     * Update the current vector from an array
+     * @param array defines the destination array
+     * @param index defines the offset in the destination array
+     * @returns the current Vector3
+     */
+    fromArray(array: any, index?: number): Vector4;
+    /**
+     * Adds the given vector to the current Vector4.
+     * @param otherVector the vector to add
+     * @returns the updated Vector4.
+     */
+    addInPlace(otherVector: any): Vector4;
+    /**
+     * Returns a new Vector4 as the result of the addition of the current Vector4 and the given one.
+     * @param otherVector the vector to add
+     * @returns the resulting vector
+     */
+    add(otherVector: any): Vector4;
+    /**
+     * Updates the given vector "result" with the result of the addition of the current Vector4 and the given one.
+     * @param otherVector the vector to add
+     * @param result the vector to store the result
+     * @returns the current Vector4.
+     */
+    addToRef(otherVector: any, result: any): Vector4;
+    /**
+     * Subtract in place the given vector from the current Vector4.
+     * @param otherVector the vector to subtract
+     * @returns the updated Vector4.
+     */
+    subtractInPlace(otherVector: any): Vector4;
+    /**
+     * Returns a new Vector4 with the result of the subtraction of the given vector from the current Vector4.
+     * @param otherVector the vector to add
+     * @returns the new vector with the result
+     */
+    subtract(otherVector: any): Vector4;
+    /**
+     * Sets the given vector "result" with the result of the subtraction of the given vector from the current Vector4.
+     * @param otherVector the vector to subtract
+     * @param result the vector to store the result
+     * @returns the current Vector4.
+     */
+    subtractToRef(otherVector: any, result: any): Vector4;
+    /**
+     * Returns a new Vector4 set with the result of the subtraction of the given floats from the current Vector4 coordinates.
+     */
+    /**
+     * Returns a new Vector4 set with the result of the subtraction of the given floats from the current Vector4 coordinates.
+     * @param x value to subtract
+     * @param y value to subtract
+     * @param z value to subtract
+     * @param w value to subtract
+     * @returns new vector containing the result
+     */
+    subtractFromFloats(x: any, y: any, z: any, w: any): Vector4;
+    /**
+     * Sets the given vector "result" set with the result of the subtraction of the given floats from the current Vector4 coordinates.
+     * @param x value to subtract
+     * @param y value to subtract
+     * @param z value to subtract
+     * @param w value to subtract
+     * @param result the vector to store the result in
+     * @returns the current Vector4.
+     */
+    subtractFromFloatsToRef(x: any, y: any, z: any, w: any, result: any): Vector4;
+    /**
+     * Returns a new Vector4 set with the current Vector4 negated coordinates.
+     * @returns a new vector with the negated values
+     */
+    negate(): Vector4;
+    /**
+     * Negate this vector in place
+     * @returns this
+     */
+    negateInPlace(): Vector4;
+    /**
+     * Negate the current Vector4 and stores the result in the given vector "result" coordinates
+     * @param result defines the Vector3 object where to store the result
+     * @returns the result
+     */
+    negateToRef(result: any): any;
+    /**
+     * Multiplies the current Vector4 coordinates by scale (float).
+     * @param scale the number to scale with
+     * @returns the updated Vector4.
+     */
+    scaleInPlace(scale: any): Vector4;
+    /**
+     * Returns a new Vector4 set with the current Vector4 coordinates multiplied by scale (float).
+     * @param scale the number to scale with
+     * @returns a new vector with the result
+     */
+    scale(scale: any): Vector4;
+    /**
+     * Sets the given vector "result" with the current Vector4 coordinates multiplied by scale (float).
+     * @param scale the number to scale with
+     * @param result a vector to store the result in
+     * @returns the current Vector4.
+     */
+    scaleToRef(scale: any, result: any): Vector4;
+    /**
+     * Scale the current Vector4 values by a factor and add the result to a given Vector4
+     * @param scale defines the scale factor
+     * @param result defines the Vector4 object where to store the result
+     * @returns the unmodified current Vector4
+     */
+    scaleAndAddToRef(scale: any, result: any): Vector4;
+    /**
+     * Boolean : True if the current Vector4 coordinates are stricly equal to the given ones.
+     * @param otherVector the vector to compare against
+     * @returns true if they are equal
+     */
+    equals(otherVector: any): any;
+    /**
+     * Boolean : True if the current Vector4 coordinates are each beneath the distance "epsilon" from the given vector ones.
+     * @param otherVector vector to compare against
+     * @param epsilon (Default: very small number)
+     * @returns true if they are equal
+     */
+    equalsWithEpsilon(otherVector: any, epsilon?: number): any;
+    /**
+     * Boolean : True if the given floats are strictly equal to the current Vector4 coordinates.
+     * @param x x value to compare against
+     * @param y y value to compare against
+     * @param z z value to compare against
+     * @param w w value to compare against
+     * @returns true if equal
+     */
+    equalsToFloats(x: any, y: any, z: any, w: any): boolean;
+    /**
+     * Multiplies in place the current Vector4 by the given one.
+     * @param otherVector vector to multiple with
+     * @returns the updated Vector4.
+     */
+    multiplyInPlace(otherVector: any): Vector4;
+    /**
+     * Returns a new Vector4 set with the multiplication result of the current Vector4 and the given one.
+     * @param otherVector vector to multiple with
+     * @returns resulting new vector
+     */
+    multiply(otherVector: any): Vector4;
+    /**
+     * Updates the given vector "result" with the multiplication result of the current Vector4 and the given one.
+     * @param otherVector vector to multiple with
+     * @param result vector to store the result
+     * @returns the current Vector4.
+     */
+    multiplyToRef(otherVector: any, result: any): Vector4;
+    /**
+     * Returns a new Vector4 set with the multiplication result of the given floats and the current Vector4 coordinates.
+     * @param x x value multiply with
+     * @param y y value multiply with
+     * @param z z value multiply with
+     * @param w w value multiply with
+     * @returns resulting new vector
+     */
+    multiplyByFloats(x: any, y: any, z: any, w: any): Vector4;
+    /**
+     * Returns a new Vector4 set with the division result of the current Vector4 by the given one.
+     * @param otherVector vector to devide with
+     * @returns resulting new vector
+     */
+    divide(otherVector: any): Vector4;
+    /**
+     * Updates the given vector "result" with the division result of the current Vector4 by the given one.
+     * @param otherVector vector to devide with
+     * @param result vector to store the result
+     * @returns the current Vector4.
+     */
+    divideToRef(otherVector: any, result: any): Vector4;
+    /**
+     * Divides the current Vector3 coordinates by the given ones.
+     * @param otherVector vector to devide with
+     * @returns the updated Vector3.
+     */
+    divideInPlace(otherVector: any): Vector4;
+    /**
+     * Updates the Vector4 coordinates with the minimum values between its own and the given vector ones
+     * @param other defines the second operand
+     * @returns the current updated Vector4
+     */
+    minimizeInPlace(other: any): Vector4;
+    /**
+     * Updates the Vector4 coordinates with the maximum values between its own and the given vector ones
+     * @param other defines the second operand
+     * @returns the current updated Vector4
+     */
+    maximizeInPlace(other: any): Vector4;
+    /**
+     * Gets a new Vector4 from current Vector4 floored values
+     * @returns a new Vector4
+     */
+    floor(): Vector4;
+    /**
+     * Gets a new Vector4 from current Vector4 fractional values
+     * @returns a new Vector4
+     */
+    fract(): Vector4;
+    /**
+     * Returns the Vector4 length (float).
+     * @returns the length
+     */
+    length(): number;
+    /**
+     * Returns the Vector4 squared length (float).
+     * @returns the length squared
+     */
+    lengthSquared(): number;
+    /**
+     * Normalizes in place the Vector4.
+     * @returns the updated Vector4.
+     */
+    normalize(): Vector4;
+    /**
+     * Returns a new Vector3 from the Vector4 (x, y, z) coordinates.
+     * @returns this converted to a new vector3
+     */
+    toVector3(): Vector3;
+    /**
+     * Returns a new Vector4 copied from the current one.
+     * @returns the new cloned vector
+     */
+    clone(): Vector4;
+    /**
+     * Updates the current Vector4 with the given one coordinates.
+     * @param source the source vector to copy from
+     * @returns the updated Vector4.
+     */
+    copyFrom(source: any): Vector4;
+    /**
+     * Updates the current Vector4 coordinates with the given floats.
+     * @param x float to copy from
+     * @param y float to copy from
+     * @param z float to copy from
+     * @param w float to copy from
+     * @returns the updated Vector4.
+     */
+    copyFromFloats(x: any, y: any, z: any, w: any): Vector4;
+    /**
+     * Updates the current Vector4 coordinates with the given floats.
+     * @param x float to set from
+     * @param y float to set from
+     * @param z float to set from
+     * @param w float to set from
+     * @returns the updated Vector4.
+     */
+    set(x: any, y: any, z: any, w: any): Vector4;
+    /**
+     * Copies the given float to the current Vector3 coordinates
+     * @param v defines the x, y, z and w coordinates of the operand
+     * @returns the current updated Vector3
+     */
+    setAll(v: any): Vector4;
+}
+export namespace Vector4 {
+    const _ZeroReadOnly_2: Vector4;
+    export { _ZeroReadOnly_2 as _ZeroReadOnly };
+}
+/**
+ * Class used to store quaternion data
+ * @see https://en.wikipedia.org/wiki/Quaternion
+ * @see https://doc.babylonjs.com/features/position,_rotation,_scaling
+ */
+export class Quaternion {
+    /**
+     * Creates a new quaternion from a rotation matrix
+     * @param matrix defines the source matrix
+     * @returns a new quaternion created from the given rotation matrix values
+     */
+    static FromRotationMatrix(matrix: any): Quaternion;
+    /**
+     * Updates the given quaternion with the given rotation matrix values
+     * @param matrix defines the source matrix
+     * @param result defines the target quaternion
+     */
+    static FromRotationMatrixToRef(matrix: any, result: any): void;
+    /**
+     * Creates the rotation quaternion needed to rotate from one Vector3 onto another Vector3
+     * Example PG https://playground.babylonjs.com/#L49EJ7#2
+     * @param fromVector the starting vector
+     * @param toVector the ending vector
+     * @returns the rotation quaternion needed
+     */
+    static RotationQuaternionFromOnto(fromVector: any, toVector: any): any;
+    /**
+     * Creates the rotation quaternion needed to rotate from one Vector3 onto another Vector3 and stores in a result Quaternion
+     * Example PG https://playground.babylonjs.com/#L49EJ7#3
+     * @param fromVector the starting vector
+     * @param toVector the ending vector
+     * @param result the rotation quaternion needed
+     * @returns the result
+     */
+    static RotationQuaternionFromOntoToRef(fromVector: any, toVector: any, result: any): any;
+    /**
+     * Returns the dot product (float) between the quaternions "left" and "right"
+     * @param left defines the left operand
+     * @param right defines the right operand
+     * @returns the dot product
+     */
+    static Dot(left: any, right: any): number;
+    /**
+     * Checks if the orientations of two rotation quaternions are close to each other
+     * @param quat0 defines the first quaternion to check
+     * @param quat1 defines the second quaternion to check
+     * @param epsilon defines closeness, 0 same orientation, 1 PI apart, default 0.1
+     * @returns true if the two quaternions are close to each other within epsilon
+     */
+    static AreClose(quat0: any, quat1: any, epsilon?: number): boolean;
+    /**
+     * Smooth interpolation between two quaternions using Slerp
+     *
+     * @param source source quaternion
+     * @param goal goal quaternion
+     * @param deltaTime current interpolation frame
+     * @param lerpTime total interpolation time
+     * @param result the smoothed quaternion
+     */
+    static SmoothToRef(source: any, goal: any, deltaTime: any, lerpTime: any, result: any): void;
+    /**
+     * Creates an empty quaternion
+     * @returns a new quaternion set to (0.0, 0.0, 0.0)
+     */
+    static Zero(): Quaternion;
+    /**
+     * Inverse a given quaternion
+     * @param q defines the source quaternion
+     * @returns a new quaternion as the inverted current quaternion
+     */
+    static Inverse(q: any): Quaternion;
+    /**
+     * Inverse a given quaternion
+     * @param q defines the source quaternion
+     * @param result the quaternion the result will be stored in
+     * @returns the result quaternion
+     */
+    static InverseToRef(q: any, result: any): any;
+    /**
+     * Creates an identity quaternion
+     * @returns the identity quaternion
+     */
+    static Identity(): Quaternion;
+    /**
+     * Gets a boolean indicating if the given quaternion is identity
+     * @param quaternion defines the quaternion to check
+     * @returns true if the quaternion is identity
+     */
+    static IsIdentity(quaternion: any): any;
+    /**
+     * Creates a quaternion from a rotation around an axis
+     * @param axis defines the axis to use
+     * @param angle defines the angle to use
+     * @returns a new quaternion created from the given axis (Vector3) and angle in radians (float)
+     */
+    static RotationAxis(axis: any, angle: any): any;
+    /**
+     * Creates a rotation around an axis and stores it into the given quaternion
+     * @param axis defines the axis to use
+     * @param angle defines the angle to use
+     * @param result defines the target quaternion
+     * @returns the target quaternion
+     */
+    static RotationAxisToRef(axis: any, angle: any, result: any): any;
+    /**
+     * Creates a new quaternion from data stored into an array
+     * @param array defines the data source
+     * @param offset defines the offset in the source array where the data starts
+     * @returns a new quaternion
+     */
+    static FromArray(array: any, offset: any): Quaternion;
+    /**
+     * Updates the given quaternion "result" from the starting index of the given array.
+     * @param array the array to pull values from
+     * @param offset the offset into the array to start at
+     * @param result the quaternion to store the result in
+     */
+    static FromArrayToRef(array: any, offset: any, result: any): void;
+    /**
+     * Create a quaternion from Euler rotation angles
+     * @param x Pitch
+     * @param y Yaw
+     * @param z Roll
+     * @returns the new Quaternion
+     */
+    static FromEulerAngles(x: any, y: any, z: any): Quaternion;
+    /**
+     * Updates a quaternion from Euler rotation angles
+     * @param x Pitch
+     * @param y Yaw
+     * @param z Roll
+     * @param result the quaternion to store the result
+     * @returns the updated quaternion
+     */
+    static FromEulerAnglesToRef(x: any, y: any, z: any, result: any): any;
+    /**
+     * Create a quaternion from Euler rotation vector
+     * @param vec the Euler vector (x Pitch, y Yaw, z Roll)
+     * @returns the new Quaternion
+     */
+    static FromEulerVector(vec: any): Quaternion;
+    /**
+     * Updates a quaternion from Euler rotation vector
+     * @param vec the Euler vector (x Pitch, y Yaw, z Roll)
+     * @param result the quaternion to store the result
+     * @returns the updated quaternion
+     */
+    static FromEulerVectorToRef(vec: any, result: any): any;
+    /**
+     * Updates a quaternion so that it rotates vector vecFrom to vector vecTo
+     * @param vecFrom defines the direction vector from which to rotate
+     * @param vecTo defines the direction vector to which to rotate
+     * @param result the quaternion to store the result
+     * @returns the updated quaternion
+     */
+    static FromUnitVectorsToRef(vecFrom: any, vecTo: any, result: any): any;
+    /**
+     * Creates a new quaternion from the given Euler float angles (y, x, z)
+     * @param yaw defines the rotation around Y axis
+     * @param pitch defines the rotation around X axis
+     * @param roll defines the rotation around Z axis
+     * @returns the new quaternion
+     */
+    static RotationYawPitchRoll(yaw: any, pitch: any, roll: any): Quaternion;
+    /**
+     * Creates a new rotation from the given Euler float angles (y, x, z) and stores it in the target quaternion
+     * @param yaw defines the rotation around Y axis
+     * @param pitch defines the rotation around X axis
+     * @param roll defines the rotation around Z axis
+     * @param result defines the target quaternion
+     */
+    static RotationYawPitchRollToRef(yaw: any, pitch: any, roll: any, result: any): void;
+    /**
+     * Creates a new quaternion from the given Euler float angles expressed in z-x-z orientation
+     * @param alpha defines the rotation around first axis
+     * @param beta defines the rotation around second axis
+     * @param gamma defines the rotation around third axis
+     * @returns the new quaternion
+     */
+    static RotationAlphaBetaGamma(alpha: any, beta: any, gamma: any): Quaternion;
+    /**
+     * Creates a new quaternion from the given Euler float angles expressed in z-x-z orientation and stores it in the target quaternion
+     * @param alpha defines the rotation around first axis
+     * @param beta defines the rotation around second axis
+     * @param gamma defines the rotation around third axis
+     * @param result defines the target quaternion
+     */
+    static RotationAlphaBetaGammaToRef(alpha: any, beta: any, gamma: any, result: any): void;
+    /**
+     * Creates a new quaternion containing the rotation value to reach the target (axis1, axis2, axis3) orientation as a rotated XYZ system (axis1, axis2 and axis3 are normalized during this operation)
+     * @param axis1 defines the first axis
+     * @param axis2 defines the second axis
+     * @param axis3 defines the third axis
+     * @returns the new quaternion
+     */
+    static RotationQuaternionFromAxis(axis1: any, axis2: any, axis3: any): Quaternion;
+    /**
+     * Creates a rotation value to reach the target (axis1, axis2, axis3) orientation as a rotated XYZ system (axis1, axis2 and axis3 are normalized during this operation) and stores it in the target quaternion
+     * @param axis1 defines the first axis
+     * @param axis2 defines the second axis
+     * @param axis3 defines the third axis
+     * @param ref defines the target quaternion
+     */
+    static RotationQuaternionFromAxisToRef(axis1: any, axis2: any, axis3: any, ref: any): void;
+    /**
+     * Creates a new rotation value to orient an object to look towards the given forward direction, the up direction being oriented like "up".
+     * This function works in left handed mode
+     * @param forward defines the forward direction - Must be normalized and orthogonal to up.
+     * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
+     * @returns A new quaternion oriented toward the specified forward and up.
+     */
+    static FromLookDirectionLH(forward: any, up: any): Quaternion;
+    /**
+     * Creates a new rotation value to orient an object to look towards the given forward direction with the up direction being oriented like "up", and stores it in the target quaternion.
+     * This function works in left handed mode
+     * @param forward defines the forward direction - Must be normalized and orthogonal to up.
+     * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
+     * @param ref defines the target quaternion.
+     */
+    static FromLookDirectionLHToRef(forward: any, up: any, ref: any): void;
+    /**
+     * Creates a new rotation value to orient an object to look towards the given forward direction, the up direction being oriented like "up".
+     * This function works in right handed mode
+     * @param forward defines the forward direction - Must be normalized and orthogonal to up.
+     * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
+     * @returns A new quaternion oriented toward the specified forward and up.
+     */
+    static FromLookDirectionRH(forward: any, up: any): Quaternion;
+    /**
+     * Creates a new rotation value to orient an object to look towards the given forward direction with the up direction being oriented like "up", and stores it in the target quaternion.
+     * This function works in right handed mode
+     * @param forward defines the forward direction - Must be normalized and orthogonal to up.
+     * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
+     * @param ref defines the target quaternion.
+     */
+    static FromLookDirectionRHToRef(forward: any, up: any, ref: any): void;
+    /**
+     * Interpolates between two quaternions
+     * @param left defines first quaternion
+     * @param right defines second quaternion
+     * @param amount defines the gradient to use
+     * @returns the new interpolated quaternion
+     */
+    static Slerp(left: any, right: any, amount: any): Quaternion;
+    /**
+     * Interpolates between two quaternions and stores it into a target quaternion
+     * @param left defines first quaternion
+     * @param right defines second quaternion
+     * @param amount defines the gradient to use
+     * @param result defines the target quaternion
+     */
+    static SlerpToRef(left: any, right: any, amount: any, result: any): void;
+    /**
+     * Interpolate between two quaternions using Hermite interpolation
+     * @param value1 defines first quaternion
+     * @param tangent1 defines the incoming tangent
+     * @param value2 defines second quaternion
+     * @param tangent2 defines the outgoing tangent
+     * @param amount defines the target quaternion
+     * @returns the new interpolated quaternion
+     */
+    static Hermite(value1: any, tangent1: any, value2: any, tangent2: any, amount: any): Quaternion;
+    /**
+     * Returns a new Quaternion which is the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2".
+     * @param value1 defines the first control point
+     * @param tangent1 defines the first tangent
+     * @param value2 defines the second control point
+     * @param tangent2 defines the second tangent
+     * @param time define where the derivative must be done
+     * @returns 1st derivative
+     */
+    static Hermite1stDerivative(value1: any, tangent1: any, value2: any, tangent2: any, time: any): Quaternion;
+    /**
+     * Update a Quaternion with the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2".
+     * @param value1 defines the first control point
+     * @param tangent1 defines the first tangent
+     * @param value2 defines the second control point
+     * @param tangent2 defines the second tangent
+     * @param time define where the derivative must be done
+     * @param result define where to store the derivative
+     */
+    static Hermite1stDerivativeToRef(value1: any, tangent1: any, value2: any, tangent2: any, time: any, result: any): void;
+    /**
+     * Creates a new Quaternion from the given floats
+     * @param x defines the first component (0 by default)
+     * @param y defines the second component (0 by default)
+     * @param z defines the third component (0 by default)
+     * @param w defines the fourth component (1.0 by default)
+     */
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    /** @internal */
+    _isDirty: boolean;
+    _x: number;
+    _y: number;
+    _z: number;
+    _w: number;
+    set x(arg: number);
+    /** Gets or sets the x coordinate */
+    get x(): number;
+    set y(arg: number);
+    /** Gets or sets the y coordinate */
+    get y(): number;
+    set z(arg: number);
+    /** Gets or sets the z coordinate */
+    get z(): number;
+    set w(arg: number);
+    /** Gets or sets the w coordinate */
+    get w(): number;
+    /**
+     * Gets a string representation for the current quaternion
+     * @returns a string with the Quaternion coordinates
+     */
+    toString(): string;
+    /**
+     * Gets the class name of the quaternion
+     * @returns the string "Quaternion"
+     */
+    getClassName(): string;
+    /**
+     * Gets a hash code for this quaternion
+     * @returns the quaternion hash code
+     */
+    getHashCode(): number;
+    /**
+     * Copy the quaternion to an array
+     * @returns a new array populated with 4 elements from the quaternion coordinates
+     */
+    asArray(): number[];
+    /**
+     * Stores from the starting index in the given array the Quaternion successive values
+     * @param array defines the array where to store the x,y,z,w components
+     * @param index defines an optional index in the target array to define where to start storing values
+     * @returns the current Quaternion object
+     */
+    toArray(array: any, index?: number): Quaternion;
+    /**
+     * Check if two quaternions are equals
+     * @param otherQuaternion defines the second operand
+     * @returns true if the current quaternion and the given one coordinates are strictly equals
+     */
+    equals(otherQuaternion: any): any;
+    /**
+     * Gets a boolean if two quaternions are equals (using an epsilon value)
+     * @param otherQuaternion defines the other quaternion
+     * @param epsilon defines the minimal distance to consider equality
+     * @returns true if the given quaternion coordinates are close to the current ones by a distance of epsilon.
+     */
+    equalsWithEpsilon(otherQuaternion: any, epsilon?: number): any;
+    /**
+     * Clone the current quaternion
+     * @returns a new quaternion copied from the current one
+     */
+    clone(): Quaternion;
+    /**
+     * Copy a quaternion to the current one
+     * @param other defines the other quaternion
+     * @returns the updated current quaternion
+     */
+    copyFrom(other: any): Quaternion;
+    /**
+     * Updates the current quaternion with the given float coordinates
+     * @param x defines the x coordinate
+     * @param y defines the y coordinate
+     * @param z defines the z coordinate
+     * @param w defines the w coordinate
+     * @returns the updated current quaternion
+     */
+    copyFromFloats(x: any, y: any, z: any, w: any): Quaternion;
+    /**
+     * Updates the current quaternion from the given float coordinates
+     * @param x defines the x coordinate
+     * @param y defines the y coordinate
+     * @param z defines the z coordinate
+     * @param w defines the w coordinate
+     * @returns the updated current quaternion
+     */
+    set(x: any, y: any, z: any, w: any): Quaternion;
+    /**
+     * Adds two quaternions
+     * @param other defines the second operand
+     * @returns a new quaternion as the addition result of the given one and the current quaternion
+     */
+    add(other: any): Quaternion;
+    /**
+     * Add a quaternion to the current one
+     * @param other defines the quaternion to add
+     * @returns the current quaternion
+     */
+    addInPlace(other: any): Quaternion;
+    /**
+     * Subtract two quaternions
+     * @param other defines the second operand
+     * @returns a new quaternion as the subtraction result of the given one from the current one
+     */
+    subtract(other: any): Quaternion;
+    /**
+     * Subtract a quaternion to the current one
+     * @param other defines the quaternion to subtract
+     * @returns the current quaternion
+     */
+    subtractInPlace(other: any): Quaternion;
+    /**
+     * Multiplies the current quaternion by a scale factor
+     * @param value defines the scale factor
+     * @returns a new quaternion set by multiplying the current quaternion coordinates by the float "scale"
+     */
+    scale(value: any): Quaternion;
+    /**
+     * Scale the current quaternion values by a factor and stores the result to a given quaternion
+     * @param scale defines the scale factor
+     * @param result defines the Quaternion object where to store the result
+     * @returns the unmodified current quaternion
+     */
+    scaleToRef(scale: any, result: any): Quaternion;
+    /**
+     * Multiplies in place the current quaternion by a scale factor
+     * @param value defines the scale factor
+     * @returns the current modified quaternion
+     */
+    scaleInPlace(value: any): Quaternion;
+    /**
+     * Scale the current quaternion values by a factor and add the result to a given quaternion
+     * @param scale defines the scale factor
+     * @param result defines the Quaternion object where to store the result
+     * @returns the unmodified current quaternion
+     */
+    scaleAndAddToRef(scale: any, result: any): Quaternion;
+    /**
+     * Multiplies two quaternions
+     * @param q1 defines the second operand
+     * @returns a new quaternion set as the multiplication result of the current one with the given one "q1"
+     */
+    multiply(q1: any): Quaternion;
+    /**
+     * Sets the given "result" as the the multiplication result of the current one with the given one "q1"
+     * @param q1 defines the second operand
+     * @param result defines the target quaternion
+     * @returns the current quaternion
+     */
+    multiplyToRef(q1: any, result: any): Quaternion;
+    /**
+     * Updates the current quaternion with the multiplication of itself with the given one "q1"
+     * @param q1 defines the second operand
+     * @returns the currentupdated quaternion
+     */
+    multiplyInPlace(q1: any): Quaternion;
+    /**
+     * Conjugates the current quaternion and stores the result in the given quaternion
+     * @param ref defines the target quaternion
+     * @returns the current quaternion
+     */
+    conjugateToRef(ref: any): Quaternion;
+    /**
+     * Conjugates in place the current quaternion
+     * @returns the current updated quaternion
+     */
+    conjugateInPlace(): Quaternion;
+    /**
+     * Conjugates (1-q) the current quaternion
+     * @returns a new quaternion
+     */
+    conjugate(): Quaternion;
+    /**
+     * Returns the inverse of the current quaternion
+     * @returns a new quaternion
+     */
+    invert(): Quaternion;
+    /**
+     * Invert in place the current quaternion
+     * @returns this quaternion
+     */
+    invertInPlace(): Quaternion;
+    /**
+     * Gets squared length of current quaternion
+     * @returns the quaternion length (float)
+     */
+    lengthSquared(): number;
+    /**
+     * Gets length of current quaternion
+     * @returns the quaternion length (float)
+     */
+    length(): number;
+    /**
+     * Normalize in place the current quaternion
+     * @returns the current updated quaternion
+     */
+    normalize(): Quaternion;
+    /**
+     * Normalize a copy of the current quaternion
+     * @returns the normalized quaternion
+     */
+    normalizeToNew(): Quaternion;
+    /**
+     * Returns a new Vector3 set with the Euler angles translated from the current quaternion
+     * @returns a new Vector3 containing the Euler angles
+     * @see https://doc.babylonjs.com/divingDeeper/mesh/transforms/center_origin/rotation_conventions
+     */
+    toEulerAngles(): Vector3;
+    /**
+     * Sets the given vector3 "result" with the Euler angles translated from the current quaternion
+     * @param result defines the vector which will be filled with the Euler angles
+     * @returns the current unchanged quaternion
+     * @see https://doc.babylonjs.com/divingDeeper/mesh/transforms/center_origin/rotation_conventions
+     */
+    toEulerAnglesToRef(result: any): Quaternion;
+    /**
+     * Updates the given rotation matrix with the current quaternion values
+     * @param result defines the target matrix
+     * @returns the current unchanged quaternion
+     */
+    toRotationMatrix(result: any): Quaternion;
+    /**
+     * Updates the current quaternion from the given rotation matrix values
+     * @param matrix defines the source matrix
+     * @returns the current updated quaternion
+     */
+    fromRotationMatrix(matrix: any): Quaternion;
+}
+/**
+ * Class used to store matrix data (4x4)
+ */
+export class Matrix {
+    /**
+     * Gets the precision of matrix computations
+     */
+    static get Use64Bits(): boolean;
+    /**
+     * Creates a matrix from an array
+     * @param array defines the source array
+     * @param offset defines an offset in the source array
+     * @returns a new Matrix set from the starting index of the given array
+     */
+    static FromArray(array: any, offset?: number): Matrix;
+    /**
+     * Copy the content of an array into a given matrix
+     * @param array defines the source array
+     * @param offset defines an offset in the source array
+     * @param result defines the target matrix
+     */
+    static FromArrayToRef(array: any, offset: any, result: any): void;
+    /**
+     * Stores an array into a matrix after having multiplied each component by a given factor
+     * @param array defines the source array
+     * @param offset defines the offset in the source array
+     * @param scale defines the scaling factor
+     * @param result defines the target matrix
+     */
+    static FromFloat32ArrayToRefScaled(array: any, offset: any, scale: any, result: any): void;
+    /**
+     * Gets an identity matrix that must not be updated
+     */
+    static get IdentityReadOnly(): Matrix;
+    /**
+     * Stores a list of values (16) inside a given matrix
+     * @param initialM11 defines 1st value of 1st row
+     * @param initialM12 defines 2nd value of 1st row
+     * @param initialM13 defines 3rd value of 1st row
+     * @param initialM14 defines 4th value of 1st row
+     * @param initialM21 defines 1st value of 2nd row
+     * @param initialM22 defines 2nd value of 2nd row
+     * @param initialM23 defines 3rd value of 2nd row
+     * @param initialM24 defines 4th value of 2nd row
+     * @param initialM31 defines 1st value of 3rd row
+     * @param initialM32 defines 2nd value of 3rd row
+     * @param initialM33 defines 3rd value of 3rd row
+     * @param initialM34 defines 4th value of 3rd row
+     * @param initialM41 defines 1st value of 4th row
+     * @param initialM42 defines 2nd value of 4th row
+     * @param initialM43 defines 3rd value of 4th row
+     * @param initialM44 defines 4th value of 4th row
+     * @param result defines the target matrix
+     */
+    static FromValuesToRef(initialM11: any, initialM12: any, initialM13: any, initialM14: any, initialM21: any, initialM22: any, initialM23: any, initialM24: any, initialM31: any, initialM32: any, initialM33: any, initialM34: any, initialM41: any, initialM42: any, initialM43: any, initialM44: any, result: any): void;
+    /**
+     * Creates new matrix from a list of values (16)
+     * @param initialM11 defines 1st value of 1st row
+     * @param initialM12 defines 2nd value of 1st row
+     * @param initialM13 defines 3rd value of 1st row
+     * @param initialM14 defines 4th value of 1st row
+     * @param initialM21 defines 1st value of 2nd row
+     * @param initialM22 defines 2nd value of 2nd row
+     * @param initialM23 defines 3rd value of 2nd row
+     * @param initialM24 defines 4th value of 2nd row
+     * @param initialM31 defines 1st value of 3rd row
+     * @param initialM32 defines 2nd value of 3rd row
+     * @param initialM33 defines 3rd value of 3rd row
+     * @param initialM34 defines 4th value of 3rd row
+     * @param initialM41 defines 1st value of 4th row
+     * @param initialM42 defines 2nd value of 4th row
+     * @param initialM43 defines 3rd value of 4th row
+     * @param initialM44 defines 4th value of 4th row
+     * @returns the new matrix
+     */
+    static FromValues(initialM11: any, initialM12: any, initialM13: any, initialM14: any, initialM21: any, initialM22: any, initialM23: any, initialM24: any, initialM31: any, initialM32: any, initialM33: any, initialM34: any, initialM41: any, initialM42: any, initialM43: any, initialM44: any): Matrix;
+    /**
+     * Creates a new matrix composed by merging scale (vector3), rotation (quaternion) and translation (vector3)
+     * @param scale defines the scale vector3
+     * @param rotation defines the rotation quaternion
+     * @param translation defines the translation vector3
+     * @returns a new matrix
+     */
+    static Compose(scale: any, rotation: any, translation: any): Matrix;
+    /**
+     * Sets a matrix to a value composed by merging scale (vector3), rotation (quaternion) and translation (vector3)
+     * @param scale defines the scale vector3
+     * @param rotation defines the rotation quaternion
+     * @param translation defines the translation vector3
+     * @param result defines the target matrix
+     */
+    static ComposeToRef(scale: any, rotation: any, translation: any, result: any): void;
+    /**
+     * Creates a new identity matrix
+     * @returns a new identity matrix
+     */
+    static Identity(): Matrix;
+    /**
+     * Creates a new identity matrix and stores the result in a given matrix
+     * @param result defines the target matrix
+     */
+    static IdentityToRef(result: any): void;
+    /**
+     * Creates a new zero matrix
+     * @returns a new zero matrix
+     */
+    static Zero(): Matrix;
+    /**
+     * Creates a new rotation matrix for "angle" radians around the X axis
+     * @param angle defines the angle (in radians) to use
+     * @returns the new matrix
+     */
+    static RotationX(angle: any): Matrix;
+    /**
+     * Creates a new matrix as the invert of a given matrix
+     * @param source defines the source matrix
+     * @returns the new matrix
+     */
+    static Invert(source: any): Matrix;
+    /**
+     * Creates a new rotation matrix for "angle" radians around the X axis and stores it in a given matrix
+     * @param angle defines the angle (in radians) to use
+     * @param result defines the target matrix
+     */
+    static RotationXToRef(angle: any, result: any): void;
+    /**
+     * Creates a new rotation matrix for "angle" radians around the Y axis
+     * @param angle defines the angle (in radians) to use
+     * @returns the new matrix
+     */
+    static RotationY(angle: any): Matrix;
+    /**
+     * Creates a new rotation matrix for "angle" radians around the Y axis and stores it in a given matrix
+     * @param angle defines the angle (in radians) to use
+     * @param result defines the target matrix
+     */
+    static RotationYToRef(angle: any, result: any): void;
+    /**
+     * Creates a new rotation matrix for "angle" radians around the Z axis
+     * @param angle defines the angle (in radians) to use
+     * @returns the new matrix
+     */
+    static RotationZ(angle: any): Matrix;
+    /**
+     * Creates a new rotation matrix for "angle" radians around the Z axis and stores it in a given matrix
+     * @param angle defines the angle (in radians) to use
+     * @param result defines the target matrix
+     */
+    static RotationZToRef(angle: any, result: any): void;
+    /**
+     * Creates a new rotation matrix for "angle" radians around the given axis
+     * @param axis defines the axis to use
+     * @param angle defines the angle (in radians) to use
+     * @returns the new matrix
+     */
+    static RotationAxis(axis: any, angle: any): Matrix;
+    /**
+     * Creates a new rotation matrix for "angle" radians around the given axis and stores it in a given matrix
+     * @param axis defines the axis to use
+     * @param angle defines the angle (in radians) to use
+     * @param result defines the target matrix
+     */
+    static RotationAxisToRef(axis: any, angle: any, result: any): void;
+    /**
+     * Takes normalised vectors and returns a rotation matrix to align "from" with "to".
+     * Taken from http://www.iquilezles.org/www/articles/noacos/noacos.htm
+     * @param from defines the vector to align
+     * @param to defines the vector to align to
+     * @param result defines the target matrix
+     */
+    static RotationAlignToRef(from: any, to: any, result: any): void;
+    /**
+     * Creates a rotation matrix
+     * @param yaw defines the yaw angle in radians (Y axis)
+     * @param pitch defines the pitch angle in radians (X axis)
+     * @param roll defines the roll angle in radians (Z axis)
+     * @returns the new rotation matrix
+     */
+    static RotationYawPitchRoll(yaw: any, pitch: any, roll: any): Matrix;
+    /**
+     * Creates a rotation matrix and stores it in a given matrix
+     * @param yaw defines the yaw angle in radians (Y axis)
+     * @param pitch defines the pitch angle in radians (X axis)
+     * @param roll defines the roll angle in radians (Z axis)
+     * @param result defines the target matrix
+     */
+    static RotationYawPitchRollToRef(yaw: any, pitch: any, roll: any, result: any): void;
+    /**
+     * Creates a scaling matrix
+     * @param x defines the scale factor on X axis
+     * @param y defines the scale factor on Y axis
+     * @param z defines the scale factor on Z axis
+     * @returns the new matrix
+     */
+    static Scaling(x: any, y: any, z: any): Matrix;
+    /**
+     * Creates a scaling matrix and stores it in a given matrix
+     * @param x defines the scale factor on X axis
+     * @param y defines the scale factor on Y axis
+     * @param z defines the scale factor on Z axis
+     * @param result defines the target matrix
+     */
+    static ScalingToRef(x: any, y: any, z: any, result: any): void;
+    /**
+     * Creates a translation matrix
+     * @param x defines the translation on X axis
+     * @param y defines the translation on Y axis
+     * @param z defines the translationon Z axis
+     * @returns the new matrix
+     */
+    static Translation(x: any, y: any, z: any): Matrix;
+    /**
+     * Creates a translation matrix and stores it in a given matrix
+     * @param x defines the translation on X axis
+     * @param y defines the translation on Y axis
+     * @param z defines the translationon Z axis
+     * @param result defines the target matrix
+     */
+    static TranslationToRef(x: any, y: any, z: any, result: any): void;
+    /**
+     * Returns a new Matrix whose values are the interpolated values for "gradient" (float) between the ones of the matrices "startValue" and "endValue".
+     * @param startValue defines the start value
+     * @param endValue defines the end value
+     * @param gradient defines the gradient factor
+     * @returns the new matrix
+     */
+    static Lerp(startValue: any, endValue: any, gradient: any): Matrix;
+    /**
+     * Set the given matrix "result" as the interpolated values for "gradient" (float) between the ones of the matrices "startValue" and "endValue".
+     * @param startValue defines the start value
+     * @param endValue defines the end value
+     * @param gradient defines the gradient factor
+     * @param result defines the Matrix object where to store data
+     */
+    static LerpToRef(startValue: any, endValue: any, gradient: any, result: any): void;
+    /**
+     * Builds a new matrix whose values are computed by:
+     * * decomposing the the "startValue" and "endValue" matrices into their respective scale, rotation and translation matrices
+     * * interpolating for "gradient" (float) the values between each of these decomposed matrices between the start and the end
+     * * recomposing a new matrix from these 3 interpolated scale, rotation and translation matrices
+     * @param startValue defines the first matrix
+     * @param endValue defines the second matrix
+     * @param gradient defines the gradient between the two matrices
+     * @returns the new matrix
+     */
+    static DecomposeLerp(startValue: any, endValue: any, gradient: any): Matrix;
+    /**
+     * Update a matrix to values which are computed by:
+     * * decomposing the the "startValue" and "endValue" matrices into their respective scale, rotation and translation matrices
+     * * interpolating for "gradient" (float) the values between each of these decomposed matrices between the start and the end
+     * * recomposing a new matrix from these 3 interpolated scale, rotation and translation matrices
+     * @param startValue defines the first matrix
+     * @param endValue defines the second matrix
+     * @param gradient defines the gradient between the two matrices
+     * @param result defines the target matrix
+     */
+    static DecomposeLerpToRef(startValue: any, endValue: any, gradient: any, result: any): void;
+    /**
+     * Gets a new rotation matrix used to rotate an entity so as it looks at the target vector3, from the eye vector3 position, the up vector3 being oriented like "up"
+     * This function works in left handed mode
+     * @param eye defines the final position of the entity
+     * @param target defines where the entity should look at
+     * @param up defines the up vector for the entity
+     * @returns the new matrix
+     */
+    static LookAtLH(eye: any, target: any, up: any): Matrix;
+    /**
+     * Sets the given "result" Matrix to a rotation matrix used to rotate an entity so that it looks at the target vector3, from the eye vector3 position, the up vector3 being oriented like "up".
+     * This function works in left handed mode
+     * @param eye defines the final position of the entity
+     * @param target defines where the entity should look at
+     * @param up defines the up vector for the entity
+     * @param result defines the target matrix
+     */
+    static LookAtLHToRef(eye: any, target: any, up: any, result: any): void;
+    /**
+     * Gets a new rotation matrix used to rotate an entity so as it looks at the target vector3, from the eye vector3 position, the up vector3 being oriented like "up"
+     * This function works in right handed mode
+     * @param eye defines the final position of the entity
+     * @param target defines where the entity should look at
+     * @param up defines the up vector for the entity
+     * @returns the new matrix
+     */
+    static LookAtRH(eye: any, target: any, up: any): Matrix;
+    /**
+     * Sets the given "result" Matrix to a rotation matrix used to rotate an entity so that it looks at the target vector3, from the eye vector3 position, the up vector3 being oriented like "up".
+     * This function works in right handed mode
+     * @param eye defines the final position of the entity
+     * @param target defines where the entity should look at
+     * @param up defines the up vector for the entity
+     * @param result defines the target matrix
+     */
+    static LookAtRHToRef(eye: any, target: any, up: any, result: any): void;
+    /**
+     * Gets a new rotation matrix used to rotate an entity so as it looks in the direction specified by forward from the eye position, the up direction being oriented like "up".
+     * This function works in left handed mode
+     * @param forward defines the forward direction - Must be normalized and orthogonal to up.
+     * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
+     * @returns the new matrix
+     */
+    static LookDirectionLH(forward: any, up: any): Matrix;
+    /**
+     * Sets the given "result" Matrix to a rotation matrix used to rotate an entity so that it looks in the direction of forward, the up direction being oriented like "up".
+     * This function works in left handed mode
+     * @param forward defines the forward direction - Must be normalized and orthogonal to up.
+     * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
+     * @param result defines the target matrix
+     */
+    static LookDirectionLHToRef(forward: any, up: any, result: any): void;
+    /**
+     * Gets a new rotation matrix used to rotate an entity so as it looks in the direction specified by forward from the eye position, the up Vector3 being oriented like "up".
+     * This function works in right handed mode
+     * @param forward defines the forward direction - Must be normalized and orthogonal to up.
+     * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
+     * @returns the new matrix
+     */
+    static LookDirectionRH(forward: any, up: any): Matrix;
+    /**
+     * Sets the given "result" Matrix to a rotation matrix used to rotate an entity so that it looks in the direction of forward, the up vector3 being oriented like "up".
+     * This function works in right handed mode
+     * @param forward defines the forward direction - Must be normalized and orthogonal to up.
+     * @param up defines the up vector for the entity - Must be normalized and orthogonal to forward.
+     * @param result defines the target matrix
+     */
+    static LookDirectionRHToRef(forward: any, up: any, result: any): void;
+    /**
+     * Create a left-handed orthographic projection matrix
+     * @param width defines the viewport width
+     * @param height defines the viewport height
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @returns a new matrix as a left-handed orthographic projection matrix
+     */
+    static OrthoLH(width: any, height: any, znear: any, zfar: any, halfZRange: any): Matrix;
+    /**
+     * Store a left-handed orthographic projection to a given matrix
+     * @param width defines the viewport width
+     * @param height defines the viewport height
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane
+     * @param result defines the target matrix
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     */
+    static OrthoLHToRef(width: any, height: any, znear: any, zfar: any, result: any, halfZRange: any): void;
+    /**
+     * Create a left-handed orthographic projection matrix
+     * @param left defines the viewport left coordinate
+     * @param right defines the viewport right coordinate
+     * @param bottom defines the viewport bottom coordinate
+     * @param top defines the viewport top coordinate
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @returns a new matrix as a left-handed orthographic projection matrix
+     */
+    static OrthoOffCenterLH(left: any, right: any, bottom: any, top: any, znear: any, zfar: any, halfZRange: any): Matrix;
+    /**
+     * Stores a left-handed orthographic projection into a given matrix
+     * @param left defines the viewport left coordinate
+     * @param right defines the viewport right coordinate
+     * @param bottom defines the viewport bottom coordinate
+     * @param top defines the viewport top coordinate
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane
+     * @param result defines the target matrix
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     */
+    static OrthoOffCenterLHToRef(left: any, right: any, bottom: any, top: any, znear: any, zfar: any, result: any, halfZRange: any): void;
+    /**
+     * Creates a right-handed orthographic projection matrix
+     * @param left defines the viewport left coordinate
+     * @param right defines the viewport right coordinate
+     * @param bottom defines the viewport bottom coordinate
+     * @param top defines the viewport top coordinate
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @returns a new matrix as a right-handed orthographic projection matrix
+     */
+    static OrthoOffCenterRH(left: any, right: any, bottom: any, top: any, znear: any, zfar: any, halfZRange: any): Matrix;
+    /**
+     * Stores a right-handed orthographic projection into a given matrix
+     * @param left defines the viewport left coordinate
+     * @param right defines the viewport right coordinate
+     * @param bottom defines the viewport bottom coordinate
+     * @param top defines the viewport top coordinate
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane
+     * @param result defines the target matrix
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     */
+    static OrthoOffCenterRHToRef(left: any, right: any, bottom: any, top: any, znear: any, zfar: any, result: any, halfZRange: any): void;
+    /**
+     * Creates a left-handed perspective projection matrix
+     * @param width defines the viewport width
+     * @param height defines the viewport height
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     * @returns a new matrix as a left-handed perspective projection matrix
+     */
+    static PerspectiveLH(width: any, height: any, znear: any, zfar: any, halfZRange: any, projectionPlaneTilt?: number): Matrix;
+    /**
+     * Creates a left-handed perspective projection matrix
+     * @param fov defines the horizontal field of view
+     * @param aspect defines the aspect ratio
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane. If 0, assume we are in "infinite zfar" mode
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     * @param reverseDepthBufferMode true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
+     * @returns a new matrix as a left-handed perspective projection matrix
+     */
+    static PerspectiveFovLH(fov: any, aspect: any, znear: any, zfar: any, halfZRange: any, projectionPlaneTilt?: number, reverseDepthBufferMode?: boolean): Matrix;
+    /**
+     * Stores a left-handed perspective projection into a given matrix
+     * @param fov defines the horizontal field of view
+     * @param aspect defines the aspect ratio
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane. If 0, assume we are in "infinite zfar" mode
+     * @param result defines the target matrix
+     * @param isVerticalFovFixed defines it the fov is vertically fixed (default) or horizontally
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     * @param reverseDepthBufferMode true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
+     */
+    static PerspectiveFovLHToRef(fov: any, aspect: any, znear: any, zfar: any, result: any, isVerticalFovFixed: boolean | undefined, halfZRange: any, projectionPlaneTilt?: number, reverseDepthBufferMode?: boolean): void;
+    /**
+     * Stores a left-handed perspective projection into a given matrix with depth reversed
+     * @param fov defines the horizontal field of view
+     * @param aspect defines the aspect ratio
+     * @param znear defines the near clip plane
+     * @param zfar not used as infinity is used as far clip
+     * @param result defines the target matrix
+     * @param isVerticalFovFixed defines it the fov is vertically fixed (default) or horizontally
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     */
+    static PerspectiveFovReverseLHToRef(fov: any, aspect: any, znear: any, zfar: any, result: any, isVerticalFovFixed: boolean | undefined, halfZRange: any, projectionPlaneTilt?: number): void;
+    /**
+     * Creates a right-handed perspective projection matrix
+     * @param fov defines the horizontal field of view
+     * @param aspect defines the aspect ratio
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane. If 0, assume we are in "infinite zfar" mode
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     * @param reverseDepthBufferMode true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
+     * @returns a new matrix as a right-handed perspective projection matrix
+     */
+    static PerspectiveFovRH(fov: any, aspect: any, znear: any, zfar: any, halfZRange: any, projectionPlaneTilt?: number, reverseDepthBufferMode?: boolean): Matrix;
+    /**
+     * Stores a right-handed perspective projection into a given matrix
+     * @param fov defines the horizontal field of view
+     * @param aspect defines the aspect ratio
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane. If 0, assume we are in "infinite zfar" mode
+     * @param result defines the target matrix
+     * @param isVerticalFovFixed defines it the fov is vertically fixed (default) or horizontally
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     * @param reverseDepthBufferMode true to indicate that we are in a reverse depth buffer mode (meaning znear and zfar have been inverted when calling the function)
+     */
+    static PerspectiveFovRHToRef(fov: any, aspect: any, znear: any, zfar: any, result: any, isVerticalFovFixed: boolean | undefined, halfZRange: any, projectionPlaneTilt?: number, reverseDepthBufferMode?: boolean): void;
+    /**
+     * Stores a right-handed perspective projection into a given matrix
+     * @param fov defines the horizontal field of view
+     * @param aspect defines the aspect ratio
+     * @param znear defines the near clip plane
+     * @param zfar not used as infinity is used as far clip
+     * @param result defines the target matrix
+     * @param isVerticalFovFixed defines it the fov is vertically fixed (default) or horizontally
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     */
+    static PerspectiveFovReverseRHToRef(fov: any, aspect: any, znear: any, zfar: any, result: any, isVerticalFovFixed: boolean | undefined, halfZRange: any, projectionPlaneTilt?: number): void;
+    /**
+     * Stores a perspective projection for WebVR info a given matrix
+     * @param fov defines the field of view
+     * @param fov.upDegrees
+     * @param fov.downDegrees
+     * @param fov.leftDegrees
+     * @param fov.rightDegrees
+     * @param znear defines the near clip plane
+     * @param zfar defines the far clip plane
+     * @param result defines the target matrix
+     * @param rightHanded defines if the matrix must be in right-handed mode (false by default)
+     * @param halfZRange true to generate NDC coordinates between 0 and 1 instead of -1 and 1 (default: false)
+     * @param projectionPlaneTilt optional tilt angle of the projection plane around the X axis (horizontal)
+     */
+    static PerspectiveFovWebVRToRef(fov: any, znear: any, zfar: any, result: any, rightHanded: boolean | undefined, halfZRange: any, projectionPlaneTilt?: number): void;
+    /**
+     * Computes a complete transformation matrix
+     * @param viewport defines the viewport to use
+     * @param world defines the world matrix
+     * @param view defines the view matrix
+     * @param projection defines the projection matrix
+     * @param zmin defines the near clip plane
+     * @param zmax defines the far clip plane
+     * @returns the transformation matrix
+     */
+    static GetFinalMatrix(viewport: any, world: any, view: any, projection: any, zmin: any, zmax: any): Matrix;
+    /**
+     * Extracts a 2x2 matrix from a given matrix and store the result in a Float32Array
+     * @param matrix defines the matrix to use
+     * @returns a new Float32Array array with 4 elements : the 2x2 matrix extracted from the given matrix
+     */
+    static GetAsMatrix2x2(matrix: any): any[] | Float32Array;
+    /**
+     * Extracts a 3x3 matrix from a given matrix and store the result in a Float32Array
+     * @param matrix defines the matrix to use
+     * @returns a new Float32Array array with 9 elements : the 3x3 matrix extracted from the given matrix
+     */
+    static GetAsMatrix3x3(matrix: any): any[] | Float32Array;
+    /**
+     * Compute the transpose of a given matrix
+     * @param matrix defines the matrix to transpose
+     * @returns the new matrix
+     */
+    static Transpose(matrix: any): Matrix;
+    /**
+     * Compute the transpose of a matrix and store it in a target matrix
+     * @param matrix defines the matrix to transpose
+     * @param result defines the target matrix
+     */
+    static TransposeToRef(matrix: any, result: any): void;
+    /**
+     * Computes a reflection matrix from a plane
+     * @param plane defines the reflection plane
+     * @returns a new matrix
+     */
+    static Reflection(plane: any): Matrix;
+    /**
+     * Computes a reflection matrix from a plane
+     * @param plane defines the reflection plane
+     * @param result defines the target matrix
+     */
+    static ReflectionToRef(plane: any, result: any): void;
+    /**
+     * Sets the given matrix as a rotation matrix composed from the 3 left handed axes
+     * @param xaxis defines the value of the 1st axis
+     * @param yaxis defines the value of the 2nd axis
+     * @param zaxis defines the value of the 3rd axis
+     * @param result defines the target matrix
+     */
+    static FromXYZAxesToRef(xaxis: any, yaxis: any, zaxis: any, result: any): void;
+    /**
+     * Creates a rotation matrix from a quaternion and stores it in a target matrix
+     * @param quat defines the quaternion to use
+     * @param result defines the target matrix
+     */
+    static FromQuaternionToRef(quat: any, result: any): void;
+    _isIdentity: boolean;
+    _isIdentityDirty: boolean;
+    _isIdentity3x2: boolean;
+    _isIdentity3x2Dirty: boolean;
+    /**
+     * Gets the update flag of the matrix which is an unique number for the matrix.
+     * It will be incremented every time the matrix data change.
+     * You can use it to speed the comparison between two versions of the same matrix.
+     */
+    updateFlag: number;
+    _m: any;
+    /**
+     * Gets the internal data of the matrix
+     */
+    get m(): any;
+    /**
+     * Update the updateFlag to indicate that the matrix has been updated
+     */
+    markAsUpdated(): void;
+    _updateIdentityStatus(isIdentity: any, isIdentityDirty?: boolean, isIdentity3x2?: boolean, isIdentity3x2Dirty?: boolean): void;
+    /**
+     * Check if the current matrix is identity
+     * @returns true is the matrix is the identity matrix
+     */
+    isIdentity(): boolean;
+    /**
+     * Check if the current matrix is identity as a texture matrix (3x2 store in 4x4)
+     * @returns true is the matrix is the identity matrix
+     */
+    isIdentityAs3x2(): boolean;
+    /**
+     * Gets the determinant of the matrix
+     * @returns the matrix determinant
+     */
+    determinant(): number;
+    /**
+     * Returns the matrix as a Float32Array or Array<number>
+     * @returns the matrix underlying array
+     */
+    toArray(): any;
+    /**
+     * Returns the matrix as a Float32Array or Array<number>
+     * @returns the matrix underlying array.
+     */
+    asArray(): any;
+    /**
+     * Inverts the current matrix in place
+     * @returns the current inverted matrix
+     */
+    invert(): Matrix;
+    /**
+     * Sets all the matrix elements to zero
+     * @returns the current matrix
+     */
+    reset(): Matrix;
+    /**
+     * Adds the current matrix with a second one
+     * @param other defines the matrix to add
+     * @returns a new matrix as the addition of the current matrix and the given one
+     */
+    add(other: any): Matrix;
+    /**
+     * Sets the given matrix "result" to the addition of the current matrix and the given one
+     * @param other defines the matrix to add
+     * @param result defines the target matrix
+     * @returns the current matrix
+     */
+    addToRef(other: any, result: any): Matrix;
+    /**
+     * Adds in place the given matrix to the current matrix
+     * @param other defines the second operand
+     * @returns the current updated matrix
+     */
+    addToSelf(other: any): Matrix;
+    /**
+     * Sets the given matrix to the current inverted Matrix
+     * @param other defines the target matrix
+     * @returns the unmodified current matrix
+     */
+    invertToRef(other: any): Matrix;
+    /**
+     * add a value at the specified position in the current Matrix
+     * @param index the index of the value within the matrix. between 0 and 15.
+     * @param value the value to be added
+     * @returns the current updated matrix
+     */
+    addAtIndex(index: any, value: any): Matrix;
+    /**
+     * mutiply the specified position in the current Matrix by a value
+     * @param index the index of the value within the matrix. between 0 and 15.
+     * @param value the value to be added
+     * @returns the current updated matrix
+     */
+    multiplyAtIndex(index: any, value: any): Matrix;
+    /**
+     * Inserts the translation vector (using 3 floats) in the current matrix
+     * @param x defines the 1st component of the translation
+     * @param y defines the 2nd component of the translation
+     * @param z defines the 3rd component of the translation
+     * @returns the current updated matrix
+     */
+    setTranslationFromFloats(x: any, y: any, z: any): Matrix;
+    /**
+     * Adds the translation vector (using 3 floats) in the current matrix
+     * @param x defines the 1st component of the translation
+     * @param y defines the 2nd component of the translation
+     * @param z defines the 3rd component of the translation
+     * @returns the current updated matrix
+     */
+    addTranslationFromFloats(x: any, y: any, z: any): Matrix;
+    /**
+     * Inserts the translation vector in the current matrix
+     * @param vector3 defines the translation to insert
+     * @returns the current updated matrix
+     */
+    setTranslation(vector3: any): Matrix;
+    /**
+     * Gets the translation value of the current matrix
+     * @returns a new Vector3 as the extracted translation from the matrix
+     */
+    getTranslation(): Vector3;
+    /**
+     * Fill a Vector3 with the extracted translation from the matrix
+     * @param result defines the Vector3 where to store the translation
+     * @returns the current matrix
+     */
+    getTranslationToRef(result: any): Matrix;
+    /**
+     * Remove rotation and scaling part from the matrix
+     * @returns the updated matrix
+     */
+    removeRotationAndScaling(): Matrix;
+    /**
+     * Multiply two matrices
+     * @param other defines the second operand
+     * @returns a new matrix set with the multiplication result of the current Matrix and the given one
+     */
+    multiply(other: any): Matrix;
+    /**
+     * Copy the current matrix from the given one
+     * @param other defines the source matrix
+     * @returns the current updated matrix
+     */
+    copyFrom(other: any): Matrix;
+    /**
+     * Populates the given array from the starting index with the current matrix values
+     * @param array defines the target array
+     * @param offset defines the offset in the target array where to start storing values
+     * @returns the current matrix
+     */
+    copyToArray(array: any, offset?: number): Matrix;
+    /**
+     * Sets the given matrix "result" with the multiplication result of the current Matrix and the given one
+     * @param other defines the second operand
+     * @param result defines the matrix where to store the multiplication
+     * @returns the current matrix
+     */
+    multiplyToRef(other: any, result: any): Matrix;
+    /**
+     * Sets the Float32Array "result" from the given index "offset" with the multiplication of the current matrix and the given one
+     * @param other defines the second operand
+     * @param result defines the array where to store the multiplication
+     * @param offset defines the offset in the target array where to start storing values
+     * @returns the current matrix
+     */
+    multiplyToArray(other: any, result: any, offset: any): Matrix;
+    /**
+     * Check equality between this matrix and a second one
+     * @param value defines the second matrix to compare
+     * @returns true is the current matrix and the given one values are strictly equal
+     */
+    equals(value: any): any;
+    /**
+     * Clone the current matrix
+     * @returns a new matrix from the current matrix
+     */
+    clone(): Matrix;
+    /**
+     * Returns the name of the current matrix class
+     * @returns the string "Matrix"
+     */
+    getClassName(): string;
+    /**
+     * Gets the hash code of the current matrix
+     * @returns the hash code
+     */
+    getHashCode(): number;
+    /**
+     * Decomposes the current Matrix into a translation, rotation and scaling components of the provided node
+     * @param node the node to decompose the matrix to
+     * @returns true if operation was successful
+     */
+    decomposeToTransformNode(node: any): boolean;
+    /**
+     * Decomposes the current Matrix into a translation, rotation and scaling components
+     * @param scale defines the scale vector3 given as a reference to update
+     * @param rotation defines the rotation quaternion given as a reference to update
+     * @param translation defines the translation vector3 given as a reference to update
+     * @param preserveScalingNode Use scaling sign coming from this node. Otherwise scaling sign might change.
+     * @returns true if operation was successful
+     */
+    decompose(scale: any, rotation: any, translation: any, preserveScalingNode: any): boolean;
+    /**
+     * Gets specific row of the matrix
+     * @param index defines the number of the row to get
+     * @returns the index-th row of the current matrix as a new Vector4
+     */
+    getRow(index: any): Vector4 | null;
+    /**
+     * Gets specific row of the matrix to ref
+     * @param index defines the number of the row to get
+     * @param rowVector vector to store the index-th row of the current matrix
+     * @returns the current matrix
+     */
+    getRowToRef(index: any, rowVector: any): Matrix;
+    /**
+     * Sets the index-th row of the current matrix to the vector4 values
+     * @param index defines the number of the row to set
+     * @param row defines the target vector4
+     * @returns the updated current matrix
+     */
+    setRow(index: any, row: any): Matrix;
+    /**
+     * Compute the transpose of the matrix
+     * @returns the new transposed matrix
+     */
+    transpose(): Matrix;
+    /**
+     * Compute the transpose of the matrix and store it in a given matrix
+     * @param result defines the target matrix
+     * @returns the current matrix
+     */
+    transposeToRef(result: any): Matrix;
+    /**
+     * Sets the index-th row of the current matrix with the given 4 x float values
+     * @param index defines the row index
+     * @param x defines the x component to set
+     * @param y defines the y component to set
+     * @param z defines the z component to set
+     * @param w defines the w component to set
+     * @returns the updated current matrix
+     */
+    setRowFromFloats(index: any, x: any, y: any, z: any, w: any): Matrix;
+    /**
+     * Compute a new matrix set with the current matrix values multiplied by scale (float)
+     * @param scale defines the scale factor
+     * @returns a new matrix
+     */
+    scale(scale: any): Matrix;
+    /**
+     * Scale the current matrix values by a factor to a given result matrix
+     * @param scale defines the scale factor
+     * @param result defines the matrix to store the result
+     * @returns the current matrix
+     */
+    scaleToRef(scale: any, result: any): Matrix;
+    /**
+     * Scale the current matrix values by a factor and add the result to a given matrix
+     * @param scale defines the scale factor
+     * @param result defines the Matrix to store the result
+     * @returns the current matrix
+     */
+    scaleAndAddToRef(scale: any, result: any): Matrix;
+    /**
+     * Writes to the given matrix a normal matrix, computed from this one (using values from identity matrix for fourth row and column).
+     * @param ref matrix to store the result
+     */
+    toNormalMatrix(ref: any): void;
+    /**
+     * Gets only rotation part of the current matrix
+     * @returns a new matrix sets to the extracted rotation matrix from the current one
+     */
+    getRotationMatrix(): Matrix;
+    /**
+     * Extracts the rotation matrix from the current one and sets it as the given "result"
+     * @param result defines the target matrix to store data to
+     * @returns the current matrix
+     */
+    getRotationMatrixToRef(result: any): Matrix;
+    /**
+     * Toggles model matrix from being right handed to left handed in place and vice versa
+     */
+    toggleModelMatrixHandInPlace(): void;
+    /**
+     * Toggles projection matrix from being right handed to left handed in place and vice versa
+     */
+    toggleProjectionMatrixHandInPlace(): void;
+}
+export namespace Matrix {
+    const _UpdateFlagSeed: number;
+    const _IdentityReadOnly: Matrix;
+}
+/**
+ * @internal
+ */
+export class TmpVectors {
+}
+export namespace TmpVectors {
+    const Vector2: [Vector2, Vector2, Vector2];
+    const Vector3: [Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3, Vector3];
+    const Vector4: [Vector4, Vector4, Vector4];
+    const Quaternion: [Quaternion, Quaternion];
+    const Matrix: [Matrix, Matrix, Matrix, Matrix, Matrix, Matrix, Matrix, Matrix];
+}