@babylonjs/core 7.5.0 → 7.6.1

package/Maths/math.vector.d.ts

@@ -2,12 +2,12 @@ import type { Viewport } from "./math.viewport";
 import type { DeepImmutable, Nullable, FloatArray, float, Tuple } from "../types";
 import type { Plane } from "./math.plane";
 import type { TransformNode } from "../Meshes/transformNode";
-import type { Dimension, Tensor, TensorStatic } from "./tensor";
+import type { Dimension, Tensor, TensorLike, TensorStatic } from "./tensor";
 import type { IVector2Like, IVector3Like, IVector4Like, IQuaternionLike, IMatrixLike, IPlaneLike } from "./math.like";
 /**
  * Represents a vector of any dimension
  */
-export interface Vector<N extends number[] = number[]> extends Tensor<N> {
+export interface Vector<N extends number[], I> extends Tensor<N, I> {
     /**
      * @see Tensor.dimension
      */
@@ -42,25 +42,25 @@ export interface Vector<N extends number[] = number[]> extends Tensor<N> {
      * Normalize the current Vector to a new vector
      * @returns the new Vector
      */
-    normalizeToNew(): this;
+    normalizeToNew(): Vector<N, I>;
     /**
      * Normalize the current Vector to the reference
      * @param reference define the Vector to update
      * @returns the updated Vector
      */
-    normalizeToRef(reference: this): this;
+    normalizeToRef<T extends I>(reference: T): T;
 }
 /**
  * Static side of Vector
  */
-export interface VectorStatic<T extends Vector> extends TensorStatic<T> {
+export interface VectorStatic<T extends Vector<any[], _I>, _I = TensorLike<T>> extends TensorStatic<T, _I> {
     /**
      * Checks if a given vector is inside a specific range
-     * @param v defines the vector to test
+     * @param value defines the vector to test
      * @param min defines the minimum range
      * @param max defines the maximum range
      */
-    CheckExtends(v: T, min: T, max: T): void;
+    CheckExtends(value: _I, min: _I, max: _I): void;
     /**
      * Returns a new Vector equal to the normalized given vector
      * @param vector defines the vector to normalize
@@ -79,7 +79,7 @@ export interface VectorStatic<T extends Vector> extends TensorStatic<T> {
  * Class representing a vector containing 2 coordinates
  * Example Playground - Overview -  https://playground.babylonjs.com/#QYBWV4#9
  */
-export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
+export declare class Vector2 implements Vector<Tuple<number, 2>, IVector2Like>, IVector2Like {
     /** defines the first coordinate */
     x: number;
     /** defines the second coordinate */
@@ -146,7 +146,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param source defines the source Vector2
      * @returns the current updated Vector2
      */
-    copyFrom(source: DeepImmutable<this>): this;
+    copyFrom(source: DeepImmutable<IVector2Like>): this;
     /**
      * Sets the Vector2 coordinates with the given floats
      * Example Playground https://playground.babylonjs.com/#QYBWV4#25
@@ -175,7 +175,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @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: DeepImmutable<this>): this;
+    add(otherVector: DeepImmutable<IVector2Like>): 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
@@ -183,14 +183,14 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the target vector
      * @returns result input
      */
-    addToRef<T extends this>(otherVector: DeepImmutable<this>, result: T): T;
+    addToRef<T extends IVector2Like>(otherVector: DeepImmutable<IVector2Like>, result: T): T;
     /**
      * 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: DeepImmutable<this>): this;
+    addInPlace(otherVector: DeepImmutable<IVector2Like>): this;
     /**
      * Adds the given coordinates to the current Vector2
      * @param x defines the x coordinate of the operand
@@ -204,14 +204,14 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param otherVector defines the other vector
      * @returns a new Vector2
      */
-    addVector3(otherVector: Vector3): this;
+    addVector3(otherVector: IVector3Like): 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: DeepImmutable<this>): this;
+    subtract(otherVector: DeepImmutable<IVector2Like>): 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
@@ -219,28 +219,28 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the target vector
      * @returns result input
      */
-    subtractToRef<T extends this>(otherVector: DeepImmutable<this>, result: T): T;
+    subtractToRef<T extends IVector2Like>(otherVector: DeepImmutable<IVector2Like>, result: T): T;
     /**
      * 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: DeepImmutable<this>): this;
+    subtractInPlace(otherVector: DeepImmutable<IVector2Like>): this;
     /**
      * 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: DeepImmutable<this>): this;
+    multiplyInPlace(otherVector: DeepImmutable<IVector2Like>): this;
     /**
      * 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: DeepImmutable<this>): this;
+    multiply(otherVector: DeepImmutable<IVector2Like>): Vector2;
     /**
      * Sets "result" coordinates with the multiplication of the current Vector2 and the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#44
@@ -248,7 +248,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the target vector
      * @returns result input
      */
-    multiplyToRef<T extends this>(otherVector: DeepImmutable<this>, result: T): T;
+    multiplyToRef<T extends IVector2Like>(otherVector: DeepImmutable<IVector2Like>, result: T): T;
     /**
      * Gets a new Vector2 set with the Vector2 coordinates multiplied by the given floats
      * Example Playground https://playground.babylonjs.com/#QYBWV4#89
@@ -256,14 +256,14 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param y defines the second coordinate
      * @returns a new Vector2
      */
-    multiplyByFloats(x: number, y: number): this;
+    multiplyByFloats(x: number, y: number): 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: DeepImmutable<this>): this;
+    divide(otherVector: DeepImmutable<IVector2Like>): Vector2;
     /**
      * Sets the "result" coordinates with the Vector2 divided by the given one coordinates
      * Example Playground https://playground.babylonjs.com/#QYBWV4#30
@@ -271,26 +271,26 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the target vector
      * @returns result input
      */
-    divideToRef<T extends this>(otherVector: DeepImmutable<this>, result: T): T;
+    divideToRef<T extends IVector2Like>(otherVector: DeepImmutable<IVector2Like>, result: T): T;
     /**
      * 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: DeepImmutable<this>): this;
+    divideInPlace(otherVector: DeepImmutable<IVector2Like>): this;
     /**
      * Updates the current Vector2 with the minimal coordinate values between its and the given vector ones
      * @param other defines the second operand
      * @returns the current updated Vector2
      */
-    minimizeInPlace(other: DeepImmutable<this>): this;
+    minimizeInPlace(other: DeepImmutable<IVector2Like>): this;
     /**
      * Updates the current Vector2 with the maximal coordinate values between its and the given vector ones.
      * @param other defines the second operand
      * @returns the current updated Vector2
      */
-    maximizeInPlace(other: DeepImmutable<this>): this;
+    maximizeInPlace(other: DeepImmutable<IVector2Like>): this;
     /**
      * Updates the current Vector2 with the minimal coordinate values between its and the given coordinates
      * @param x defines the x coordinate of the operand
@@ -311,7 +311,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param y defines the y coordinate of the operand
      * @returns the resulting Vector2
      */
-    subtractFromFloats(x: number, y: number): this;
+    subtractFromFloats(x: number, y: number): Vector2;
     /**
      * Subtracts the given floats from the current Vector2 coordinates and set the given vector "result" with this result
      * @param x defines the x coordinate of the operand
@@ -319,12 +319,12 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the Vector2 object where to store the result
      * @returns the result
      */
-    subtractFromFloatsToRef<T extends this>(x: number, y: number, result: T): T;
+    subtractFromFloatsToRef<T extends IVector2Like>(x: number, y: number, result: T): T;
     /**
      * Gets a new Vector2 with current Vector2 negated coordinates
      * @returns a new Vector2
      */
-    negate(): this;
+    negate(): Vector2;
     /**
      * Negate this vector in place
      * Example Playground https://playground.babylonjs.com/#QYBWV4#23
@@ -337,7 +337,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    negateToRef<T extends this>(result: T): T;
+    negateToRef<T extends IVector2Like>(result: T): T;
     /**
      * Multiply the Vector2 coordinates by
      * Example Playground https://playground.babylonjs.com/#QYBWV4#59
@@ -351,7 +351,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param scale defines the scaling factor
      * @returns a new Vector2
      */
-    scale(scale: number): this;
+    scale(scale: number): Vector2;
     /**
      * Scale the current Vector2 values by a factor to a given Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#57
@@ -359,7 +359,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the Vector2 object where to store the result
      * @returns result input
      */
-    scaleToRef<T extends this>(scale: number, result: T): T;
+    scaleToRef<T extends IVector2Like>(scale: number, result: T): T;
     /**
      * Scale the current Vector2 values by a factor and add the result to a given Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#58
@@ -367,14 +367,14 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the Vector2 object where to store the result
      * @returns result input
      */
-    scaleAndAddToRef<T extends this>(scale: number, result: T): T;
+    scaleAndAddToRef<T extends IVector2Like>(scale: number, result: T): T;
     /**
      * 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: DeepImmutable<this>): boolean;
+    equals(otherVector: DeepImmutable<IVector2Like>): boolean;
     /**
      * Gets a boolean if two vectors are equals (using an epsilon value)
      * Example Playground https://playground.babylonjs.com/#QYBWV4#32
@@ -382,7 +382,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @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: DeepImmutable<this>, epsilon?: number): boolean;
+    equalsWithEpsilon(otherVector: DeepImmutable<IVector2Like>, epsilon?: number): boolean;
     /**
      * Returns true if the current Vector2 coordinates equals the given floats
      * @param x defines the x coordinate of the operand
@@ -396,26 +396,26 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * eg (1.2, 2.31) returns (1, 2)
      * @returns a new Vector2
      */
-    floor(): this;
+    floor(): Vector2;
     /**
      * Gets the current Vector2's floored values and stores them in result
      * @param result the Vector2 to store the result in
      * @returns the result Vector2
      */
-    floorToRef<T extends this>(result: T): T;
+    floorToRef<T extends IVector2Like>(result: T): T;
     /**
      * 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(): this;
+    fract(): Vector2;
     /**
      * Gets the current Vector2's fractional values and stores them in result
      * @param result the Vector2 to store the result in
      * @returns the result Vector2
      */
-    fractToRef<T extends this>(result: T): T;
+    fractToRef<T extends IVector2Like>(result: T): T;
     /**
      * Rotate the current vector into a given result vector
      * Example Playground https://playground.babylonjs.com/#QYBWV4#49
@@ -423,7 +423,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the result vector where to store the rotated vector
      * @returns result input
      */
-    rotateToRef<T extends this>(angle: number, result: T): T;
+    rotateToRef<T extends IVector2Like>(angle: number, result: T): T;
     /**
      * Gets the length of the vector
      * @returns the vector length (float)
@@ -451,25 +451,25 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * Normalize the current Vector2 to a new vector
      * @returns the new Vector2
      */
-    normalizeToNew(): this;
+    normalizeToNew(): Vector2;
     /**
      * Normalize the current Vector2 to the reference
-     * @param reference define the Vector to update
+     * @param result define the Vector to update
      * @returns the updated Vector2
      */
-    normalizeToRef<T extends this>(reference: T): T;
+    normalizeToRef<T extends IVector2Like>(result: T): T;
     /**
      * Gets a new Vector2 copied from the Vector2
      * Example Playground https://playground.babylonjs.com/#QYBWV4#20
      * @returns a new Vector2
      */
-    clone(): this;
+    clone(): Vector2;
     /**
      * Gets the dot product of the current vector and the vector "otherVector"
      * @param otherVector defines second vector
      * @returns the dot product (float)
      */
-    dot(otherVector: DeepImmutable<this>): number;
+    dot(otherVector: DeepImmutable<IVector2Like>): number;
     /**
      * Gets a new Vector2(0, 0)
      * @returns a new Vector2
@@ -534,7 +534,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param amount defines the interpolation factor
      * @returns a new Vector2
      */
-    static CatmullRom<T extends Vector2>(value1: DeepImmutable<T>, value2: DeepImmutable<Vector2>, value3: DeepImmutable<Vector2>, value4: DeepImmutable<Vector2>, amount: number): T;
+    static CatmullRom(value1: DeepImmutable<IVector2Like>, value2: DeepImmutable<IVector2Like>, value3: DeepImmutable<IVector2Like>, value4: DeepImmutable<IVector2Like>, amount: number): Vector2;
     /**
      * Sets reference 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.
@@ -545,7 +545,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param ref the reference
      * @returns the reference
      */
-    static ClampToRef<T extends Vector2>(value: DeepImmutable<T>, min: DeepImmutable<Vector2>, max: DeepImmutable<Vector2>, ref: T): T;
+    static ClampToRef<T extends Vector2>(value: DeepImmutable<IVector2Like>, min: DeepImmutable<IVector2Like>, max: DeepImmutable<IVector2Like>, ref: T): T;
     /**
      * 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.
@@ -556,7 +556,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param max defines the upper limit
      * @returns a new Vector2
      */
-    static Clamp<T extends Vector2>(value: DeepImmutable<T>, min: DeepImmutable<Vector2>, max: DeepImmutable<Vector2>): T;
+    static Clamp(value: DeepImmutable<IVector2Like>, min: DeepImmutable<IVector2Like>, max: DeepImmutable<IVector2Like>): 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
@@ -567,7 +567,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param amount defines the interpolation factor
      * @returns a new Vector2
      */
-    static Hermite<T extends Vector2>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, tangent2: DeepImmutable<Vector2>, amount: number): T;
+    static Hermite(value1: DeepImmutable<IVector2Like>, tangent1: DeepImmutable<IVector2Like>, value2: DeepImmutable<IVector2Like>, tangent2: DeepImmutable<IVector2Like>, amount: number): 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
@@ -578,7 +578,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param time define where the derivative must be done
      * @returns 1st derivative
      */
-    static Hermite1stDerivative<T extends Vector2>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, tangent2: DeepImmutable<Vector2>, time: number): T;
+    static Hermite1stDerivative(value1: DeepImmutable<IVector2Like>, tangent1: DeepImmutable<IVector2Like>, value2: DeepImmutable<IVector2Like>, tangent2: DeepImmutable<IVector2Like>, time: number): 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
@@ -590,7 +590,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result define where the derivative will be stored
      * @returns result input
      */
-    static Hermite1stDerivativeToRef<T extends Vector2>(value1: DeepImmutable<Vector2>, tangent1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, tangent2: DeepImmutable<Vector2>, time: number, result: T): T;
+    static Hermite1stDerivativeToRef<T extends Vector2>(value1: DeepImmutable<IVector2Like>, tangent1: DeepImmutable<IVector2Like>, value2: DeepImmutable<IVector2Like>, tangent2: DeepImmutable<IVector2Like>, time: number, result: T): T;
     /**
      * 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
@@ -599,7 +599,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param amount defines the interpolation factor
      * @returns a new Vector2
      */
-    static Lerp<T extends Vector2>(start: DeepImmutable<T>, end: DeepImmutable<Vector2>, amount: number): Vector2;
+    static Lerp(start: DeepImmutable<IVector2Like>, end: DeepImmutable<IVector2Like>, amount: number): Vector2;
     /**
      * Gets the dot product of the vector "left" and the vector "right"
      * Example Playground https://playground.babylonjs.com/#QYBWV4#90
@@ -607,14 +607,14 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param right defines second vector
      * @returns the dot product (float)
      */
-    static Dot(left: DeepImmutable<Vector2>, right: DeepImmutable<Vector2>): number;
+    static Dot(left: DeepImmutable<IVector2Like>, right: DeepImmutable<IVector2Like>): 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<T extends Vector2>(vector: DeepImmutable<T>): T;
+    static Normalize(vector: DeepImmutable<Vector2>): Vector2;
     /**
      * Normalize a given vector into a second one
      * Example Playground https://playground.babylonjs.com/#QYBWV4#50
@@ -630,7 +630,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param right defines 2nd vector
      * @returns a new Vector2
      */
-    static Minimize<T extends Vector2>(left: DeepImmutable<T>, right: DeepImmutable<Vector2>): T;
+    static Minimize(left: DeepImmutable<IVector2Like>, right: DeepImmutable<IVector2Like>): 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
@@ -638,7 +638,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param right defines 2nd vector
      * @returns a new Vector2
      */
-    static Maximize<T extends Vector2>(left: DeepImmutable<T>, right: DeepImmutable<Vector2>): T;
+    static Maximize(left: DeepImmutable<IVector2Like>, right: DeepImmutable<IVector2Like>): 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
@@ -646,7 +646,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param transformation defines the matrix to apply
      * @returns a new Vector2
      */
-    static Transform<T extends Vector2>(vector: DeepImmutable<T>, transformation: DeepImmutable<Matrix>): T;
+    static Transform(vector: DeepImmutable<IVector2Like>, transformation: DeepImmutable<Matrix>): 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
@@ -655,7 +655,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param result defines the target vector
      * @returns result input
      */
-    static TransformToRef<T extends Vector2>(vector: DeepImmutable<Vector2>, transformation: DeepImmutable<Matrix>, result: T): T;
+    static TransformToRef<T extends Vector2>(vector: DeepImmutable<IVector2Like>, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Determines if a given vector is included in a triangle
      * Example Playground https://playground.babylonjs.com/#QYBWV4#87
@@ -665,7 +665,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @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: DeepImmutable<Vector2>, p0: DeepImmutable<Vector2>, p1: DeepImmutable<Vector2>, p2: DeepImmutable<Vector2>): boolean;
+    static PointInTriangle(p: DeepImmutable<IVector2Like>, p0: DeepImmutable<IVector2Like>, p1: DeepImmutable<IVector2Like>, p2: DeepImmutable<IVector2Like>): boolean;
     /**
      * Gets the distance between the vectors "value1" and "value2"
      * Example Playground https://playground.babylonjs.com/#QYBWV4#71
@@ -673,7 +673,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param value2 defines second vector
      * @returns the distance between vectors
      */
-    static Distance(value1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>): number;
+    static Distance(value1: DeepImmutable<IVector2Like>, value2: DeepImmutable<IVector2Like>): number;
     /**
      * Returns the squared distance between the vectors "value1" and "value2"
      * Example Playground https://playground.babylonjs.com/#QYBWV4#72
@@ -681,7 +681,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param value2 defines second vector
      * @returns the squared distance between vectors
      */
-    static DistanceSquared(value1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>): number;
+    static DistanceSquared(value1: DeepImmutable<IVector2Like>, value2: DeepImmutable<IVector2Like>): number;
     /**
      * Gets a new Vector2 located at the center of the vectors "value1" and "value2"
      * Example Playground https://playground.babylonjs.com/#QYBWV4#86
@@ -690,7 +690,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param value2 defines second vector
      * @returns a new Vector2
      */
-    static Center<T extends Vector2>(value1: DeepImmutable<T>, value2: DeepImmutable<Vector2>): T;
+    static Center(value1: DeepImmutable<IVector2Like>, value2: DeepImmutable<IVector2Like>): Vector2;
     /**
      * 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
@@ -699,7 +699,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
      * @param ref defines third vector
      * @returns ref
      */
-    static CenterToRef<T extends Vector2>(value1: DeepImmutable<Vector2>, value2: DeepImmutable<Vector2>, ref: T): T;
+    static CenterToRef<T extends Vector2>(value1: DeepImmutable<IVector2Like>, value2: DeepImmutable<IVector2Like>, ref: T): T;
     /**
      * 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
@@ -717,7 +717,7 @@ export declare class Vector2 implements Vector<Tuple<number, 2>>, IVector2Like {
  * Reminder: js uses a left handed forward facing system
  * Example Playground - Overview - https://playground.babylonjs.com/#R1F8YU
  */
-export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
+export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3>, IVector3Like {
     private static _UpReadOnly;
     private static _DownReadOnly;
     private static _LeftHandedForwardReadOnly;
@@ -826,7 +826,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param otherVector defines the second operand
      * @returns the resulting Vector3
      */
-    add(otherVector: DeepImmutable<Vector3>): this;
+    add(otherVector: DeepImmutable<Vector3>): 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
@@ -848,7 +848,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param otherVector defines the second operand
      * @returns the resulting Vector3
      */
-    subtract(otherVector: DeepImmutable<Vector3>): this;
+    subtract(otherVector: DeepImmutable<Vector3>): 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
@@ -865,7 +865,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param z defines the z coordinate of the operand
      * @returns the resulting Vector3
      */
-    subtractFromFloats(x: number, y: number, z: number): this;
+    subtractFromFloats(x: number, y: number, z: number): 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
@@ -881,7 +881,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * Example Playground https://playground.babylonjs.com/#R1F8YU#35
      * @returns a new Vector3
      */
-    negate(): this;
+    negate(): Vector3;
     /**
      * Negate this vector in place
      * Example Playground https://playground.babylonjs.com/#R1F8YU#36
@@ -908,7 +908,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param scale defines the multiplier factor
      * @returns a new Vector3
      */
-    scale(scale: number): this;
+    scale(scale: number): 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
@@ -950,7 +950,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param q the unit quaternion representing the rotation
      * @returns a new Vector3
      */
-    applyRotationQuaternion(q: Quaternion): this;
+    applyRotationQuaternion(q: Quaternion): Vector3;
     /**
      * Scale the current Vector3 values by a factor and add the result to a given Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#55
@@ -966,7 +966,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param origin defines the origin of the projection ray
      * @returns the projected vector3
      */
-    projectOnPlane<T extends Vector3>(plane: Plane, origin: Vector3): T;
+    projectOnPlane(plane: Plane, origin: Vector3): 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
@@ -1013,7 +1013,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param otherVector defines the second operand
      * @returns the new Vector3
      */
-    multiply(otherVector: DeepImmutable<Vector3>): this;
+    multiply(otherVector: DeepImmutable<Vector3>): 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
@@ -1030,14 +1030,14 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param z defines the z coordinate of the operand
      * @returns the new Vector3
      */
-    multiplyByFloats(x: number, y: number, z: number): this;
+    multiplyByFloats(x: number, y: number, z: number): 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: DeepImmutable<Vector3>): this;
+    divide(otherVector: DeepImmutable<Vector3>): 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
@@ -1101,25 +1101,25 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param result the vector to store the result in
      * @returns the result vector
      */
-    floorToRef<T extends this>(result: T): T;
+    floorToRef<T extends Vector3>(result: T): T;
     /**
      * Gets a new Vector3 from current Vector3 floored values
      * Example Playground https://playground.babylonjs.com/#R1F8YU#22
      * @returns a new Vector3
      */
-    floor(): this;
+    floor(): Vector3;
     /**
      * Gets the current Vector3's fractional values and stores them in result
      * @param result the vector to store the result in
      * @returns the result vector
      */
-    fractToRef<T extends this>(result: T): T;
+    fractToRef<T extends Vector3>(result: T): T;
     /**
      * Gets a new Vector3 from current Vector3 fractional values
      * Example Playground https://playground.babylonjs.com/#R1F8YU#23
      * @returns a new Vector3
      */
-    fract(): this;
+    fract(): Vector3;
     /**
      * Gets the length of the Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#25
@@ -1175,7 +1175,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param other defines the right operand
      * @returns the cross product
      */
-    cross(other: Vector3): this;
+    cross(other: Vector3): Vector3;
     /**
      * Normalize the current Vector3 with the given input length.
      * Please note that this is an in place operation.
@@ -1189,7 +1189,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * Example Playground https://playground.babylonjs.com/#R1F8YU#124
      * @returns the new Vector3
      */
-    normalizeToNew(): this;
+    normalizeToNew(): Vector3;
     /**
      * Normalize the current Vector3 to the reference
      * Example Playground https://playground.babylonjs.com/#R1F8YU#125
@@ -1202,7 +1202,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * Example Playground https://playground.babylonjs.com/#R1F8YU#11
      * @returns the new Vector3
      */
-    clone(): this;
+    clone(): Vector3;
     /**
      * Copies the given vector coordinates to the current Vector3 ones
      * Example Playground https://playground.babylonjs.com/#R1F8YU#12
@@ -1524,7 +1524,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param amount defines the amount on the spline to use
      * @returns the new Vector3
      */
-    static CatmullRom<T extends Vector3>(value1: DeepImmutable<T>, value2: DeepImmutable<Vector3>, value3: DeepImmutable<Vector3>, value4: DeepImmutable<Vector3>, amount: number): T;
+    static CatmullRom(value1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, value3: DeepImmutable<Vector3>, value4: DeepImmutable<Vector3>, amount: number): 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
@@ -1535,7 +1535,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param max defines the upper range value
      * @returns the new Vector3
      */
-    static Clamp<T extends Vector3>(value: DeepImmutable<T>, min: DeepImmutable<Vector3>, max: DeepImmutable<Vector3>): T;
+    static Clamp(value: DeepImmutable<Vector3>, min: DeepImmutable<Vector3>, max: DeepImmutable<Vector3>): 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
@@ -1566,7 +1566,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param amount defines the amount on the interpolation spline (between 0 and 1)
      * @returns the new Vector3
      */
-    static Hermite<T extends Vector3>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, amount: number): T;
+    static Hermite(value1: DeepImmutable<Vector3>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, amount: number): 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
@@ -1577,7 +1577,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param time define where the derivative must be done
      * @returns 1st derivative
      */
-    static Hermite1stDerivative<T extends Vector3>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, time: number): T;
+    static Hermite1stDerivative(value1: DeepImmutable<Vector3>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, time: number): 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
@@ -1598,7 +1598,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param amount max defines amount between both (between 0 and 1)
      * @returns the new Vector3
      */
-    static Lerp<T extends Vector3>(start: DeepImmutable<T>, end: DeepImmutable<Vector3>, amount: number): T;
+    static Lerp(start: DeepImmutable<Vector3>, end: DeepImmutable<Vector3>, amount: number): 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
@@ -1622,7 +1622,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param otherVector defines the right operand
      * @returns the dot product
      */
-    dot(otherVector: DeepImmutable<this>): number;
+    dot(otherVector: DeepImmutable<Vector3>): 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"
@@ -1631,7 +1631,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param right defines the right operand
      * @returns the cross product
      */
-    static Cross<T extends Vector3>(left: DeepImmutable<T>, right: DeepImmutable<Vector3>): T;
+    static Cross(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): 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"
@@ -1666,7 +1666,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param viewport defines the screen viewport to use
      * @returns the new Vector3
      */
-    static Project<T extends Vector3>(vector: DeepImmutable<T>, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>, viewport: DeepImmutable<Viewport>): T;
+    static Project(vector: DeepImmutable<Vector3>, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>, viewport: DeepImmutable<Viewport>): Vector3;
     /**
      * Project a Vector3 onto screen space to reference
      * Example Playground https://playground.babylonjs.com/#R1F8YU#102
@@ -1707,7 +1707,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param transform defines the transform (view x projection) matrix to use
      * @returns the new Vector3
      */
-    static UnprojectFromTransform<T extends Vector3>(source: DeepImmutable<T>, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>): T;
+    static UnprojectFromTransform(source: DeepImmutable<Vector3>, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, transform: DeepImmutable<Matrix>): Vector3;
     /**
      * Unproject from screen space to object space
      * Example Playground https://playground.babylonjs.com/#R1F8YU#117
@@ -1719,7 +1719,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param projection defines the projection matrix to use
      * @returns the new Vector3
      */
-    static Unproject<T extends Vector3>(source: DeepImmutable<T>, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>): T;
+    static Unproject(source: DeepImmutable<Vector3>, viewportWidth: number, viewportHeight: number, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>): Vector3;
     /**
      * Unproject from screen space to object space
      * Example Playground https://playground.babylonjs.com/#R1F8YU#119
@@ -1755,7 +1755,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param right defines the second operand
      * @returns the new Vector3
      */
-    static Minimize<T extends Vector3>(left: DeepImmutable<T>, right: DeepImmutable<Vector3>): T;
+    static Minimize(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): Vector3;
     /**
      * Gets the maximal coordinate values between two Vector3
      * Example Playground https://playground.babylonjs.com/#R1F8YU#96
@@ -1763,7 +1763,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @param right defines the second operand
      * @returns the new Vector3
      */
-    static Maximize<T extends Vector3>(left: DeepImmutable<T>, right: DeepImmutable<Vector3>): T;
+    static Maximize(left: DeepImmutable<Vector3>, right: DeepImmutable<Vector3>): Vector3;
     /**
      * Returns the distance between the vectors "value1" and "value2"
      * Example Playground https://playground.babylonjs.com/#R1F8YU#81
@@ -1823,7 +1823,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
      * @returns a new Vector3
      * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/center_origin/target_align
      */
-    static RotationFromAxis<T extends Vector3>(axis1: DeepImmutable<T>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>): T;
+    static RotationFromAxis(axis1: DeepImmutable<Vector3>, axis2: DeepImmutable<Vector3>, axis3: DeepImmutable<Vector3>): 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
@@ -1838,7 +1838,7 @@ export declare class Vector3 implements Vector<Tuple<number, 3>>, IVector3Like {
 /**
  * Vector4 class created for EulerAngle class conversion to Quaternion
  */
-export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
+export declare class Vector4 implements Vector<Tuple<number, 4>, IVector4Like>, IVector4Like {
     /** x value of the vector */
     x: number;
     /** y value of the vector */
@@ -1926,33 +1926,33 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param otherVector the vector to add
      * @returns the resulting vector
      */
-    add(otherVector: DeepImmutable<Vector4>): this;
+    add(otherVector: DeepImmutable<IVector4Like>): 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 result input
      */
-    addToRef<T extends Vector4>(otherVector: DeepImmutable<Vector4>, result: T): T;
+    addToRef<T extends IVector4Like>(otherVector: DeepImmutable<IVector4Like>, result: T): T;
     /**
      * Subtract in place the given vector from the current Vector4.
      * @param otherVector the vector to subtract
      * @returns the updated Vector4.
      */
-    subtractInPlace(otherVector: DeepImmutable<Vector4>): this;
+    subtractInPlace(otherVector: DeepImmutable<IVector4Like>): this;
     /**
      * 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: DeepImmutable<Vector4>): this;
+    subtract(otherVector: DeepImmutable<IVector4Like>): 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 result input
      */
-    subtractToRef<T extends Vector4>(otherVector: DeepImmutable<Vector4>, result: T): T;
+    subtractToRef<T extends IVector4Like>(otherVector: DeepImmutable<IVector4Like>, result: T): T;
     /**
      * 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
@@ -1961,7 +1961,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param w value to subtract
      * @returns new vector containing the result
      */
-    subtractFromFloats(x: number, y: number, z: number, w: number): this;
+    subtractFromFloats(x: number, y: number, z: number, w: number): 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
@@ -1971,12 +1971,12 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result the vector to store the result in
      * @returns result input
      */
-    subtractFromFloatsToRef<T extends Vector4>(x: number, y: number, z: number, w: number, result: T): T;
+    subtractFromFloatsToRef<T extends IVector4Like>(x: number, y: number, z: number, w: number, result: T): T;
     /**
      * Returns a new Vector4 set with the current Vector4 negated coordinates.
      * @returns a new vector with the negated values
      */
-    negate(): this;
+    negate(): Vector4;
     /**
      * Negate this vector in place
      * @returns this
@@ -1987,7 +1987,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result defines the Vector3 object where to store the result
      * @returns the result
      */
-    negateToRef<T extends Vector4>(result: T): T;
+    negateToRef<T extends IVector4Like>(result: T): T;
     /**
      * Multiplies the current Vector4 coordinates by scale (float).
      * @param scale the number to scale with
@@ -1999,34 +1999,34 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param scale the number to scale with
      * @returns a new vector with the result
      */
-    scale(scale: number): this;
+    scale(scale: number): 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 result input
      */
-    scaleToRef<T extends Vector4>(scale: number, result: T): T;
+    scaleToRef<T extends IVector4Like>(scale: number, result: T): T;
     /**
      * 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 result input
      */
-    scaleAndAddToRef<T extends Vector4>(scale: number, result: T): T;
+    scaleAndAddToRef<T extends IVector4Like>(scale: number, result: T): T;
     /**
      * 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: DeepImmutable<Vector4>): boolean;
+    equals(otherVector: DeepImmutable<IVector4Like>): boolean;
     /**
      * 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: DeepImmutable<Vector4>, epsilon?: number): boolean;
+    equalsWithEpsilon(otherVector: DeepImmutable<IVector4Like>, epsilon?: number): boolean;
     /**
      * Boolean : True if the given floats are strictly equal to the current Vector4 coordinates.
      * @param x x value to compare against
@@ -2041,20 +2041,20 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param otherVector vector to multiple with
      * @returns the updated Vector4.
      */
-    multiplyInPlace(otherVector: DeepImmutable<Vector4>): this;
+    multiplyInPlace(otherVector: DeepImmutable<IVector4Like>): this;
     /**
      * 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: DeepImmutable<Vector4>): this;
+    multiply(otherVector: DeepImmutable<IVector4Like>): 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 result input
      */
-    multiplyToRef<T extends Vector4>(otherVector: DeepImmutable<Vector4>, result: T): T;
+    multiplyToRef<T extends IVector4Like>(otherVector: DeepImmutable<IVector4Like>, result: T): T;
     /**
      * Returns a new Vector4 set with the multiplication result of the given floats and the current Vector4 coordinates.
      * @param x x value multiply with
@@ -2063,38 +2063,38 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param w w value multiply with
      * @returns resulting new vector
      */
-    multiplyByFloats(x: number, y: number, z: number, w: number): this;
+    multiplyByFloats(x: number, y: number, z: number, w: number): 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: DeepImmutable<Vector4>): this;
+    divide(otherVector: DeepImmutable<IVector4Like>): 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 result input
      */
-    divideToRef<T extends Vector4>(otherVector: DeepImmutable<Vector4>, result: T): T;
+    divideToRef<T extends IVector4Like>(otherVector: DeepImmutable<IVector4Like>, result: T): T;
     /**
      * Divides the current Vector3 coordinates by the given ones.
      * @param otherVector vector to devide with
      * @returns the updated Vector3.
      */
-    divideInPlace(otherVector: DeepImmutable<Vector4>): this;
+    divideInPlace(otherVector: DeepImmutable<IVector4Like>): this;
     /**
      * 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: DeepImmutable<Vector4>): this;
+    minimizeInPlace(other: DeepImmutable<IVector4Like>): this;
     /**
      * 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: DeepImmutable<Vector4>): this;
+    maximizeInPlace(other: DeepImmutable<IVector4Like>): this;
     /**
      * Updates the current Vector4 with the minimal coordinate values between its and the given coordinates
      * @param x defines the x coordinate of the operand
@@ -2118,23 +2118,23 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result the vector to store the result in
      * @returns the result vector
      */
-    floorToRef<T extends this>(result: T): T;
+    floorToRef<T extends IVector4Like>(result: T): T;
     /**
      * Gets a new Vector4 from current Vector4 floored values
      * @returns a new Vector4
      */
-    floor(): this;
+    floor(): Vector4;
     /**
      * Gets the current Vector4's fractional values and stores them in result
      * @param result the vector to store the result in
      * @returns the result vector
      */
-    fractToRef<T extends this>(result: T): T;
+    fractToRef<T extends IVector4Like>(result: T): T;
     /**
      * Gets a new Vector4 from current Vector4 fractional values
      * @returns a new Vector4
      */
-    fract(): this;
+    fract(): Vector4;
     /**
      * Returns the Vector4 length (float).
      * @returns the length
@@ -2161,13 +2161,13 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * Normalize the current Vector4 to a new vector
      * @returns the new Vector4
      */
-    normalizeToNew(): this;
+    normalizeToNew(): Vector4;
     /**
      * Normalize the current Vector4 to the reference
      * @param reference define the Vector4 to update
      * @returns the updated Vector4
      */
-    normalizeToRef<T extends this>(reference: T): T;
+    normalizeToRef<T extends IVector4Like>(reference: T): T;
     /**
      * Returns a new Vector3 from the Vector4 (x, y, z) coordinates.
      * @returns this converted to a new vector3
@@ -2177,13 +2177,13 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * Returns a new Vector4 copied from the current one.
      * @returns the new cloned vector
      */
-    clone(): this;
+    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: DeepImmutable<Vector4>): this;
+    copyFrom(source: DeepImmutable<IVector4Like>): this;
     /**
      * Updates the current Vector4 coordinates with the given floats.
      * @param x float to copy from
@@ -2213,7 +2213,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param otherVector defines the right operand
      * @returns the dot product
      */
-    dot(otherVector: DeepImmutable<this>): number;
+    dot(otherVector: DeepImmutable<IVector4Like>): number;
     /**
      * Returns a new Vector4 set from the starting index of the given array.
      * @param array the array to pull values from
@@ -2228,7 +2228,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result the vector to store the result in
      * @returns result input
      */
-    static FromArrayToRef<T extends Vector4>(array: DeepImmutable<ArrayLike<number>>, offset: number, result: T): T;
+    static FromArrayToRef<T extends IVector4Like>(array: DeepImmutable<ArrayLike<number>>, offset: number, result: T): T;
     /**
      * Updates the given vector "result" from the starting index of the given Float32Array.
      * @param array the array to pull values from
@@ -2236,7 +2236,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result the vector to store the result in
      * @returns result input
      */
-    static FromFloatArrayToRef<T extends Vector4>(array: DeepImmutable<Float32Array>, offset: number, result: T): T;
+    static FromFloatArrayToRef<T extends IVector4Like>(array: DeepImmutable<Float32Array>, offset: number, result: T): T;
     /**
      * Updates the given vector "result" coordinates from the given floats.
      * @param x float to set from
@@ -2246,7 +2246,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result the vector to the floats in
      * @returns result input
      */
-    static FromFloatsToRef<T extends Vector4>(x: number, y: number, z: number, w: number, result: T): T;
+    static FromFloatsToRef<T extends IVector4Like>(x: number, y: number, z: number, w: number, result: T): T;
     /**
      * Returns a new Vector4 set to (0.0, 0.0, 0.0, 0.0)
      * @returns the new vector
@@ -2271,7 +2271,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param ref the ref to store the values in
      * @returns the ref with random values between min and max
      */
-    static RandomToRef<T extends Vector4>(min: number | undefined, max: number | undefined, ref: T): T;
+    static RandomToRef<T extends IVector4Like>(min: number | undefined, max: number | undefined, ref: T): T;
     /**
      * Returns a new Vector4 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
@@ -2281,7 +2281,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param max defines the upper range value
      * @returns the new Vector4
      */
-    static Clamp<T extends Vector4>(value: DeepImmutable<T>, min: DeepImmutable<Vector4>, max: DeepImmutable<Vector4>): T;
+    static Clamp(value: DeepImmutable<IVector4Like>, min: DeepImmutable<IVector4Like>, max: DeepImmutable<IVector4Like>): Vector4;
     /**
      * 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
@@ -2292,7 +2292,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result defines the Vector4 where to store the result
      * @returns result input
      */
-    static ClampToRef<T extends Vector4>(value: DeepImmutable<Vector4>, min: DeepImmutable<Vector4>, max: DeepImmutable<Vector4>, result: T): T;
+    static ClampToRef<T extends IVector4Like>(value: DeepImmutable<IVector4Like>, min: DeepImmutable<IVector4Like>, max: DeepImmutable<IVector4Like>, result: T): T;
     /**
      * Checks if a given vector is inside a specific range
      * Example Playground https://playground.babylonjs.com/#R1F8YU#75
@@ -2300,7 +2300,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param min defines the minimum range
      * @param max defines the maximum range
      */
-    static CheckExtends(v: Vector4, min: Vector4, max: Vector4): void;
+    static CheckExtends(v: IVector4Like, min: Vector4, max: Vector4): void;
     /**
      * Gets a zero Vector4 that must not be updated
      */
@@ -2317,42 +2317,42 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result the vector to store the result in
      * @returns result input
      */
-    static NormalizeToRef<T extends Vector4>(vector: DeepImmutable<Vector4>, result: T): T;
+    static NormalizeToRef<T extends IVector4Like>(vector: DeepImmutable<Vector4>, result: T): T;
     /**
      * 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<T extends Vector4>(left: DeepImmutable<T>, right: DeepImmutable<Vector4>): T;
+    static Minimize<T extends Vector4>(left: DeepImmutable<T>, right: DeepImmutable<Vector4>): Vector4;
     /**
      * 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<T extends Vector4>(left: DeepImmutable<T>, right: DeepImmutable<Vector4>): T;
+    static Maximize(left: DeepImmutable<IVector4Like>, right: DeepImmutable<IVector4Like>): Vector4;
     /**
      * 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: DeepImmutable<Vector4>, value2: DeepImmutable<Vector4>): number;
+    static Distance(value1: DeepImmutable<IVector4Like>, value2: DeepImmutable<IVector4Like>): 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: DeepImmutable<Vector4>, value2: DeepImmutable<Vector4>): number;
+    static DistanceSquared(value1: DeepImmutable<IVector4Like>, value2: DeepImmutable<IVector4Like>): 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: DeepImmutable<Vector4>, value2: DeepImmutable<Vector4>): Vector4;
+    static Center(value1: DeepImmutable<IVector4Like>, value2: DeepImmutable<IVector4Like>): Vector4;
     /**
      * Gets the center of the vectors "value1" and "value2" and stores the result in the vector "ref"
      * @param value1 defines first vector
@@ -2360,7 +2360,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param ref defines third vector
      * @returns ref
      */
-    static CenterToRef<T extends Vector4>(value1: DeepImmutable<Vector4>, value2: DeepImmutable<Vector4>, ref: T): T;
+    static CenterToRef<T extends IVector4Like>(value1: DeepImmutable<IVector4Like>, value2: DeepImmutable<IVector4Like>, ref: T): T;
     /**
      * 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)
@@ -2379,7 +2379,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result defines the Vector4 where to store the result
      * @returns result input
      */
-    static TransformCoordinatesToRef<T extends Vector4>(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>, result: T): T;
+    static TransformCoordinatesToRef<T extends IVector4Like>(vector: DeepImmutable<Vector3>, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * 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
@@ -2391,7 +2391,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result defines the Vector4 where to store the result
      * @returns result input
      */
-    static TransformCoordinatesFromFloatsToRef<T extends Vector4>(x: number, y: number, z: number, transformation: DeepImmutable<Matrix>, result: T): T;
+    static TransformCoordinatesFromFloatsToRef<T extends IVector4Like>(x: number, y: number, z: number, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * 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.
@@ -2399,7 +2399,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param transformation the transformation matrix to apply
      * @returns the new vector
      */
-    static TransformNormal<T extends Vector4>(vector: DeepImmutable<T>, transformation: DeepImmutable<Matrix>): T;
+    static TransformNormal(vector: DeepImmutable<IVector4Like>, transformation: DeepImmutable<Matrix>): 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.
@@ -2408,7 +2408,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result the vector to store the result in
      * @returns result input
      */
-    static TransformNormalToRef<T extends Vector4>(vector: DeepImmutable<Vector4>, transformation: DeepImmutable<Matrix>, result: T): T;
+    static TransformNormalToRef<T extends IVector4Like>(vector: DeepImmutable<IVector4Like>, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * 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.
@@ -2420,7 +2420,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param result the vector to store the results in
      * @returns result input
      */
-    static TransformNormalFromFloatsToRef<T extends Vector4>(x: number, y: number, z: number, w: number, transformation: DeepImmutable<Matrix>, result: T): T;
+    static TransformNormalFromFloatsToRef<T extends IVector4Like>(x: number, y: number, z: number, w: number, transformation: DeepImmutable<Matrix>, result: T): T;
     /**
      * Creates a new Vector4 from a Vector3
      * @param source defines the source data
@@ -2434,7 +2434,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
      * @param right defines the right operand
      * @returns the dot product
      */
-    static Dot(left: DeepImmutable<Vector4>, right: DeepImmutable<Vector4>): number;
+    static Dot(left: DeepImmutable<IVector4Like>, right: DeepImmutable<IVector4Like>): number;
 }
 /**
  * Class used to store quaternion data
@@ -2442,7 +2442,7 @@ export declare class Vector4 implements Vector<Tuple<number, 4>>, IVector4Like {
  * @see https://en.wikipedia.org/wiki/Quaternion
  * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms
  */
-export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternionLike {
+export declare class Quaternion implements Tensor<Tuple<number, 4>, Quaternion>, IQuaternionLike {
     /** @internal */
     _x: number;
     /** @internal */
@@ -2531,7 +2531,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * Example Playground https://playground.babylonjs.com/#L49EJ7#12
      * @returns a new quaternion copied from the current one
      */
-    clone(): this;
+    clone(): Quaternion;
     /**
      * Copy a quaternion to the current one
      * Example Playground https://playground.babylonjs.com/#L49EJ7#86
@@ -2566,7 +2566,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * @param other defines the second operand
      * @returns a new quaternion as the addition result of the given one and the current quaternion
      */
-    add(other: DeepImmutable<Quaternion>): this;
+    add(other: DeepImmutable<Quaternion>): Quaternion;
     /**
      * Add a quaternion to the current one
      * Example Playground https://playground.babylonjs.com/#L49EJ7#11
@@ -2574,18 +2574,18 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * @returns the current quaternion
      */
     addInPlace(other: DeepImmutable<Quaternion>): this;
-    addToRef<T extends this>(other: DeepImmutable<this>, result: T): T;
+    addToRef<T extends Quaternion>(other: DeepImmutable<this>, result: T): T;
     addInPlaceFromFloats(x: number, y: number, z: number, w: number): this;
-    subtractToRef<T extends this>(other: DeepImmutable<this>, result: T): T;
-    subtractFromFloats(x: number, y: number, z: number, w: number): this;
-    subtractFromFloatsToRef<T extends this>(x: number, y: number, z: number, w: number, result: T): T;
+    subtractToRef<T extends Quaternion>(other: DeepImmutable<this>, result: T): T;
+    subtractFromFloats(x: number, y: number, z: number, w: number): Quaternion;
+    subtractFromFloatsToRef<T extends Quaternion>(x: number, y: number, z: number, w: number, result: T): T;
     /**
      * Subtract two quaternions
      * Example Playground https://playground.babylonjs.com/#L49EJ7#57
      * @param other defines the second operand
      * @returns a new quaternion as the subtraction result of the given one from the current one
      */
-    subtract(other: DeepImmutable<this>): this;
+    subtract(other: DeepImmutable<this>): Quaternion;
     /**
      * Subtract a quaternion to the current one
      * Example Playground https://playground.babylonjs.com/#L49EJ7#58
@@ -2599,7 +2599,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * @param value defines the scale factor
      * @returns a new quaternion set by multiplying the current quaternion coordinates by the float "scale"
      */
-    scale(value: number): this;
+    scale(value: number): Quaternion;
     /**
      * Scale the current quaternion values by a factor and stores the result to a given quaternion
      * Example Playground https://playground.babylonjs.com/#L49EJ7#89
@@ -2629,7 +2629,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * @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: DeepImmutable<Quaternion>): this;
+    multiply(q1: DeepImmutable<Quaternion>): Quaternion;
     /**
      * Sets the given "result" as the multiplication result of the current one with the given one "q1"
      * Example Playground https://playground.babylonjs.com/#L49EJ7#45
@@ -2655,7 +2655,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * @internal
      * Do not use
      */
-    divideToRef<T extends this>(_other: DeepImmutable<this>, _result: T): T;
+    divideToRef<T extends Quaternion>(_other: DeepImmutable<this>, _result: T): T;
     /**
      * @internal
      * Do not use
@@ -2681,30 +2681,30 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * Do not use
      */
     maximizeInPlaceFromFloats(): this;
-    negate(): this;
+    negate(): Quaternion;
     negateInPlace(): this;
-    negateToRef<T extends this>(result: T): T;
+    negateToRef<T extends Quaternion>(result: T): T;
     equalsToFloats(x: number, y: number, z: number, w: number): boolean;
     /**
      * @internal
      * Do not use
      */
-    floorToRef<T extends this>(_result: T): T;
+    floorToRef<T extends Quaternion>(_result: T): T;
     /**
      * @internal
      * Do not use
      */
-    floor(): this;
+    floor(): Quaternion;
     /**
      * @internal
      * Do not use
      */
-    fractToRef<T extends this>(_result: T): T;
+    fractToRef<T extends Quaternion>(_result: T): T;
     /**
      * @internal
      * Do not use
      */
-    fract(): this;
+    fract(): Quaternion;
     /**
      * Conjugates the current quaternion and stores the result in the given quaternion
      * Example Playground https://playground.babylonjs.com/#L49EJ7#81
@@ -2723,13 +2723,13 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * Example Playground https://playground.babylonjs.com/#L49EJ7#83
      * @returns a new quaternion
      */
-    conjugate(): this;
+    conjugate(): Quaternion;
     /**
      * Returns the inverse of the current quaternion
      * Example Playground https://playground.babylonjs.com/#L49EJ7#84
      * @returns a new quaternion
      */
-    invert(): this;
+    invert(): Quaternion;
     /**
      * Invert in place the current quaternion
      * Example Playground https://playground.babylonjs.com/#L49EJ7#85
@@ -2766,7 +2766,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * Example Playground https://playground.babylonjs.com/#L49EJ7#55
      * @returns the normalized quaternion
      */
-    normalizeToNew(): this;
+    normalizeToNew(): Quaternion;
     /**
      * Normalize the current Quaternion to the reference
      * @param reference define the Quaternion to update
@@ -2862,7 +2862,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * @param q defines the source quaternion
      * @returns a new quaternion as the inverted current quaternion
      */
-    static Inverse<T extends Quaternion>(q: DeepImmutable<T>): T;
+    static Inverse(q: DeepImmutable<Quaternion>): Quaternion;
     /**
      * Inverse a given quaternion
      * Example Playground https://playground.babylonjs.com/#L49EJ7#104
@@ -3095,7 +3095,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * @param amount defines the target quaternion
      * @returns the new interpolated quaternion
      */
-    static Hermite<T extends Quaternion>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, amount: number): T;
+    static Hermite(value1: DeepImmutable<Quaternion>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, amount: number): Quaternion;
     /**
      * Returns a new Quaternion which is the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2".
      * Example Playground https://playground.babylonjs.com/#L49EJ7#48
@@ -3106,7 +3106,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * @param time define where the derivative must be done
      * @returns 1st derivative
      */
-    static Hermite1stDerivative<T extends Quaternion>(value1: DeepImmutable<T>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, time: number): T;
+    static Hermite1stDerivative(value1: DeepImmutable<Quaternion>, tangent1: DeepImmutable<Quaternion>, value2: DeepImmutable<Quaternion>, tangent2: DeepImmutable<Quaternion>, time: number): Quaternion;
     /**
      * Update a Quaternion with the 1st derivative of the Hermite spline defined by the quaternions "value1", "value2", "tangent1", "tangent2".
      * Example Playground https://playground.babylonjs.com/#L49EJ7#49
@@ -3141,7 +3141,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
      * @param max defines the upper range value
      * @returns the new Quaternion
      */
-    static Clamp<T extends Quaternion>(value: DeepImmutable<T>, min: DeepImmutable<Quaternion>, max: DeepImmutable<Quaternion>): T;
+    static Clamp(value: DeepImmutable<Quaternion>, min: DeepImmutable<Quaternion>, max: DeepImmutable<Quaternion>): Quaternion;
     /**
      * Sets the given quaternion "result" with the coordinates of "value", if the quaternion "value" is in the cube defined by the quaternions "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
@@ -3230,7 +3230,7 @@ export declare class Quaternion implements Tensor<Tuple<number, 4>>, IQuaternion
  * Example Playground - Overview Transformation - https://playground.babylonjs.com/#AV9X17#1
  * Example Playground - Overview Projection - https://playground.babylonjs.com/#AV9X17#2
  */
-export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatrixLike {
+export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>, Matrix>, IMatrixLike {
     /**
      * @see Tensor.dimension
      */
@@ -3330,7 +3330,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @param other defines the matrix to add
      * @returns a new matrix as the addition of the current matrix and the given one
      */
-    add(other: DeepImmutable<Matrix>): this;
+    add(other: DeepImmutable<Matrix>): Matrix;
     /**
      * Sets the given matrix "result" to the addition of the current matrix and the given one
      * Example Playground - https://playground.babylonjs.com/#AV9X17#45
@@ -3346,13 +3346,13 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @returns the current updated matrix
      */
     addToSelf(other: DeepImmutable<Matrix>): this;
-    addInPlace(other: DeepImmutable<this>): this;
+    addInPlace(other: DeepImmutable<Matrix>): this;
     addInPlaceFromFloats(...floats: Tuple<number, 16>): this;
-    subtract(other: DeepImmutable<this>): this;
-    subtractToRef<T extends this>(other: DeepImmutable<this>, result: T): T;
-    subtractInPlace(other: DeepImmutable<this>): this;
-    subtractFromFloats(...floats: Tuple<number, 16>): this;
-    subtractFromFloatsToRef<T extends this>(...args: [...Tuple<number, 16>, T]): T;
+    subtract(other: DeepImmutable<Matrix>): this;
+    subtractToRef<T extends Matrix>(other: DeepImmutable<Matrix>, result: T): T;
+    subtractInPlace(other: DeepImmutable<Matrix>): this;
+    subtractFromFloats(...floats: Tuple<number, 16>): Matrix;
+    subtractFromFloatsToRef<T extends Matrix>(...args: [...Tuple<number, 16>, T]): T;
     /**
      * Sets the given matrix to the current inverted Matrix
      * Example Playground - https://playground.babylonjs.com/#AV9X17#119
@@ -3440,14 +3440,14 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @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: DeepImmutable<Matrix>): this;
+    multiply(other: DeepImmutable<Matrix>): Matrix;
     /**
      * This method performs component-by-component in-place multiplication, rather than true matrix multiplication.
      * Use multiply or multiplyToRef for matrix multiplication.
      * @param other defines the second operand
      * @returns the current updated matrix
      */
-    multiplyInPlace(other: DeepImmutable<this>): this;
+    multiplyInPlace(other: DeepImmutable<Matrix>): this;
     /**
      * This method performs a component-by-component multiplication of the current matrix with the array of transmitted numbers.
      * Use multiply or multiplyToRef for matrix multiplication.
@@ -3460,7 +3460,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @param args The floats and ref
      * @returns The updated ref
      */
-    multiplyByFloatsToRef<T extends this>(...args: [...Tuple<number, 16>, T]): T;
+    multiplyByFloatsToRef<T extends Matrix>(...args: [...Tuple<number, 16>, T]): T;
     /**
      * Sets the given matrix "result" with the multiplication result of the current Matrix and the given one
      * A.multiplyToRef(B, R) means apply B to A and store in R and R = B x A
@@ -3478,34 +3478,34 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @returns the current matrix
      */
     multiplyToArray(other: DeepImmutable<Matrix>, result: Float32Array | Array<number>, offset: number): this;
-    divide(other: DeepImmutable<this>): this;
-    divideToRef<T extends this>(other: DeepImmutable<this>, result: T): T;
-    divideInPlace(other: DeepImmutable<this>): this;
-    minimizeInPlace(other: DeepImmutable<this>): this;
+    divide(other: DeepImmutable<Matrix>): Matrix;
+    divideToRef<T extends Matrix>(other: DeepImmutable<Matrix>, result: T): T;
+    divideInPlace(other: DeepImmutable<Matrix>): this;
+    minimizeInPlace(other: DeepImmutable<Matrix>): this;
     minimizeInPlaceFromFloats(...floats: Tuple<number, 16>): this;
-    maximizeInPlace(other: DeepImmutable<this>): this;
+    maximizeInPlace(other: DeepImmutable<Matrix>): this;
     maximizeInPlaceFromFloats(...floats: Tuple<number, 16>): this;
-    negate(): this;
+    negate(): Matrix;
     negateInPlace(): this;
-    negateToRef<T extends this>(result: T): T;
+    negateToRef<T extends Matrix>(result: T): T;
     /**
      * 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: DeepImmutable<Matrix>): boolean;
-    equalsWithEpsilon(other: DeepImmutable<this>, epsilon?: number): boolean;
+    equalsWithEpsilon(other: DeepImmutable<Matrix>, epsilon?: number): boolean;
     equalsToFloats(...floats: Tuple<number, 16>): boolean;
-    floor(): this;
-    floorToRef<T extends this>(result: T): T;
-    fract(): this;
-    fractToRef<T extends this>(result: T): T;
+    floor(): Matrix;
+    floorToRef<T extends Matrix>(result: T): T;
+    fract(): Matrix;
+    fractToRef<T extends Matrix>(result: T): T;
     /**
      * Clone the current matrix
      * Example Playground - https://playground.babylonjs.com/#AV9X17#18
      * @returns a new matrix from the current matrix
      */
-    clone(): this;
+    clone(): Matrix;
     /**
      * Returns the name of the current matrix class
      * @returns the string "Matrix"
@@ -3562,7 +3562,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * Example Playground - https://playground.babylonjs.com/#AV9X17#40
      * @returns the new transposed matrix
      */
-    transpose(): this;
+    transpose(): Matrix;
     /**
      * Compute the transpose of the matrix and store it in a given matrix
      * Example Playground - https://playground.babylonjs.com/#AV9X17#41
@@ -3586,7 +3586,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @param scale defines the scale factor
      * @returns a new matrix
      */
-    scale(scale: number): this;
+    scale(scale: number): Matrix;
     /**
      * Scale the current matrix values by a factor to a given result matrix
      * @param scale defines the scale factor
@@ -3613,7 +3613,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * Gets only rotation part of the current matrix
      * @returns a new matrix sets to the extracted rotation matrix from the current one
      */
-    getRotationMatrix(): this;
+    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
@@ -3751,7 +3751,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @param source defines the source matrix
      * @returns the new matrix
      */
-    static Invert<T extends Matrix>(source: DeepImmutable<T>): T;
+    static Invert(source: DeepImmutable<Matrix>): Matrix;
     /**
      * Creates a new rotation matrix for "angle" radians around the X axis and stores it in a given matrix
      * Example Playground - https://playground.babylonjs.com/#AV9X17#98
@@ -3884,7 +3884,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @param gradient defines the gradient factor
      * @returns the new matrix
      */
-    static Lerp<T extends Matrix>(startValue: DeepImmutable<T>, endValue: DeepImmutable<Matrix>, gradient: number): T;
+    static Lerp(startValue: DeepImmutable<Matrix>, endValue: DeepImmutable<Matrix>, gradient: number): Matrix;
     /**
      * Set the given matrix "result" as the interpolated values for "gradient" (float) between the ones of the matrices "startValue" and "endValue".
      * Example Playground - https://playground.babylonjs.com/#AV9X17#54
@@ -3907,7 +3907,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @param gradient defines the gradient between the two matrices
      * @returns the new matrix
      */
-    static DecomposeLerp<T extends Matrix>(startValue: DeepImmutable<T>, endValue: DeepImmutable<Matrix>, gradient: number): T;
+    static DecomposeLerp(startValue: DeepImmutable<Matrix>, endValue: DeepImmutable<Matrix>, gradient: number): Matrix;
     /**
      * Update a matrix to values which are computed by:
      * * decomposing the "startValue" and "endValue" matrices into their respective scale, rotation and translation matrices
@@ -4222,7 +4222,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @param zmax defines the far clip plane
      * @returns the transformation matrix
      */
-    static GetFinalMatrix<T extends Matrix>(viewport: DeepImmutable<Viewport>, world: DeepImmutable<T>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>, zmin: number, zmax: number): T;
+    static GetFinalMatrix(viewport: DeepImmutable<Viewport>, world: DeepImmutable<Matrix>, view: DeepImmutable<Matrix>, projection: DeepImmutable<Matrix>, zmin: number, zmax: number): Matrix;
     /**
      * Extracts a 2x2 matrix from a given matrix and store the result in a Float32Array
      * @param matrix defines the matrix to use
@@ -4241,7 +4241,7 @@ export declare class Matrix implements Tensor<Tuple<Tuple<number, 4>, 4>>, IMatr
      * @param matrix defines the matrix to transpose
      * @returns the new matrix
      */
-    static Transpose<T extends Matrix>(matrix: DeepImmutable<T>): T;
+    static Transpose(matrix: DeepImmutable<Matrix>): Matrix;
     /**
      * Compute the transpose of a matrix and store it in a target matrix
      * Example Playground - https://playground.babylonjs.com/#AV9X17#112