@babylonjs/core 7.4.0 → 7.6.0

package/Maths/math.color.d.ts

@@ -1,10 +1,10 @@
 import type { DeepImmutable, FloatArray, Tuple } from "../types";
-import type { Tensor } from "./tensor";
 import type { IColor3Like, IColor4Like } from "./math.like";
+import type { Tensor } from "./tensor";
 /**
  * Class used to hold a RGB color
  */
-export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
+export declare class Color3 implements Tensor<Tuple<number, 3>, IColor3Like>, IColor3Like {
     /**
      * Defines the red component (between 0 and 1, default is 0)
      */
@@ -94,20 +94,20 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @param otherColor defines the second operand
      * @returns the new Color3 object
      */
-    multiply(otherColor: DeepImmutable<this>): this;
+    multiply(otherColor: DeepImmutable<IColor3Like>): Color3;
     /**
      * Multiply the rgb values of the Color3 and the given Color3 and stores the result in the object "result"
      * @param otherColor defines the second operand
      * @param result defines the Color3 object where to store the result
      * @returns the result Color3
      */
-    multiplyToRef<T extends this>(otherColor: DeepImmutable<this>, result: T): T;
+    multiplyToRef<T extends IColor3Like>(otherColor: DeepImmutable<IColor3Like>, result: T): T;
     /**
      * Multiplies the current Color3 coordinates by the given ones
      * @param otherColor defines the second operand
      * @returns the current updated Color3
      */
-    multiplyInPlace(otherColor: DeepImmutable<Color3>): this;
+    multiplyInPlace(otherColor: DeepImmutable<IColor3Like>): this;
     /**
      * Returns a new Color3 set with the result of the multiplication of the current Color3 coordinates by the given floats
      * @param r defines the r coordinate of the operand
@@ -115,34 +115,34 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @param b defines the b coordinate of the operand
      * @returns the new Color3
      */
-    multiplyByFloats(r: number, g: number, b: number): this;
+    multiplyByFloats(r: number, g: number, b: number): Color3;
     /**
      * @internal
      * Do not use
      */
-    divide(_other: DeepImmutable<this>): this;
+    divide(_other: DeepImmutable<IColor3Like>): never;
     /**
      * @internal
      * Do not use
      */
-    divideToRef<T extends this>(_other: DeepImmutable<this>, _result: T): T;
+    divideToRef(_other: DeepImmutable<IColor3Like>, _result: IColor3Like): never;
     /**
      * @internal
      * Do not use
      */
-    divideInPlace(_other: DeepImmutable<this>): this;
+    divideInPlace(_other: DeepImmutable<IColor3Like>): never;
     /**
      * Updates the current Color3 with the minimal coordinate values between its and the given color ones
      * @param other defines the second operand
      * @returns the current updated Color3
      */
-    minimizeInPlace(other: DeepImmutable<this>): this;
+    minimizeInPlace(other: DeepImmutable<IColor3Like>): this;
     /**
      * Updates the current Color3 with the maximal coordinate values between its and the given color ones.
      * @param other defines the second operand
      * @returns the current updated Color3
      */
-    maximizeInPlace(other: DeepImmutable<this>): this;
+    maximizeInPlace(other: DeepImmutable<IColor3Like>): this;
     /**
      * Updates the current Color3 with the minimal coordinate values between its and the given coordinates
      * @param r defines the r coordinate of the operand
@@ -163,28 +163,28 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @internal
      * Do not use
      */
-    floorToRef<T extends this>(_result: T): T;
+    floorToRef(_result: IColor3Like): never;
     /**
      * @internal
      * Do not use
      */
-    floor(): this;
+    floor(): never;
     /**
      * @internal
      * Do not use
      */
-    fractToRef<T extends this>(_result: T): T;
+    fractToRef(_result: IColor3Like): never;
     /**
      * @internal
      * Do not use
      */
-    fract(): this;
+    fract(): never;
     /**
      * Determines equality between Color3 objects
      * @param otherColor defines the second operand
      * @returns true if the rgb values are equal to the given ones
      */
-    equals(otherColor: DeepImmutable<this>): boolean;
+    equals(otherColor: DeepImmutable<IColor3Like>): boolean;
     /**
      * Alias for equalsToFloats
      * @param r red color component
@@ -207,28 +207,28 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @param epsilon defines the minimal distance to define values as equals
      * @returns true if both colors are distant less than epsilon
      */
-    equalsWithEpsilon(otherColor: DeepImmutable<this>, epsilon?: number): boolean;
+    equalsWithEpsilon(otherColor: DeepImmutable<IColor3Like>, epsilon?: number): boolean;
     /**
      * @internal
      * Do not use
      */
-    negate(): this;
+    negate(): never;
     /**
      * @internal
      * Do not use
      */
-    negateInPlace(): this;
+    negateInPlace(): never;
     /**
      * @internal
      * Do not use
      */
-    negateToRef<T extends this>(_result: T): T;
+    negateToRef(_result: IColor3Like): never;
     /**
      * Creates a new Color3 with the current Color3 values multiplied by scale
      * @param scale defines the scaling factor to apply
      * @returns a new Color3 object
      */
-    scale(scale: number): this;
+    scale(scale: number): Color3;
     /**
      * Multiplies the Color3 values by the float "scale"
      * @param scale defines the scaling factor to apply
@@ -241,14 +241,14 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @param result defines the Color3 object where to store the result
      * @returns the result Color3
      */
-    scaleToRef<T extends this>(scale: number, result: T): T;
+    scaleToRef<T extends IColor3Like>(scale: number, result: T): T;
     /**
      * Scale the current Color3 values by a factor and add the result to a given Color3
      * @param scale defines the scale factor
      * @param result defines color to store the result into
      * @returns the result Color3
      */
-    scaleAndAddToRef<T extends this>(scale: number, result: T): T;
+    scaleAndAddToRef<T extends IColor3Like>(scale: number, result: T): T;
     /**
      * Clamps the rgb values by the min and max values and stores the result into "result"
      * @param min defines minimum clamping value (default is 0)
@@ -256,19 +256,19 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @param result defines color to store the result into
      * @returns the result Color3
      */
-    clampToRef<T extends this>(min: number | undefined, max: number | undefined, result: T): T;
+    clampToRef<T extends IColor3Like>(min: number | undefined, max: number | undefined, result: T): T;
     /**
      * Creates a new Color3 set with the added values of the current Color3 and of the given one
      * @param otherColor defines the second operand
      * @returns the new Color3
      */
-    add(otherColor: DeepImmutable<this>): this;
+    add(otherColor: DeepImmutable<IColor3Like>): Color3;
     /**
      * Adds the given color to the current Color3
      * @param otherColor defines the second operand
      * @returns the current updated Color3
      */
-    addInPlace(otherColor: DeepImmutable<this>): this;
+    addInPlace(otherColor: DeepImmutable<IColor3Like>): this;
     /**
      * Adds the given coordinates to the current Color3
      * @param r defines the r coordinate of the operand
@@ -283,26 +283,26 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @param result defines Color3 object to store the result into
      * @returns the unmodified current Color3
      */
-    addToRef<T extends this>(otherColor: DeepImmutable<this>, result: T): T;
+    addToRef<T extends IColor3Like>(otherColor: DeepImmutable<IColor3Like>, result: T): T;
     /**
      * Returns a new Color3 set with the subtracted values of the given one from the current Color3
      * @param otherColor defines the second operand
      * @returns the new Color3
      */
-    subtract(otherColor: DeepImmutable<this>): this;
+    subtract(otherColor: DeepImmutable<IColor3Like>): Color3;
     /**
      * Stores the result of the subtraction of given one from the current Color3 rgb values into "result"
      * @param otherColor defines the second operand
      * @param result defines Color3 object to store the result into
      * @returns the unmodified current Color3
      */
-    subtractToRef<T extends this>(otherColor: DeepImmutable<this>, result: T): T;
+    subtractToRef<T extends IColor3Like>(otherColor: DeepImmutable<IColor3Like>, result: T): T;
     /**
      * Subtract the given color from the current Color3
      * @param otherColor defines the second operand
      * @returns the current updated Color3
      */
-    subtractInPlace(otherColor: DeepImmutable<this>): this;
+    subtractInPlace(otherColor: DeepImmutable<IColor3Like>): this;
     /**
      * Returns a new Color3 set with the subtraction of the given floats from the current Color3 coordinates
      * @param r defines the r coordinate of the operand
@@ -310,7 +310,7 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @param b defines the b coordinate of the operand
      * @returns the resulting Color3
      */
-    subtractFromFloats(r: number, g: number, b: number): this;
+    subtractFromFloats(r: number, g: number, b: number): Color3;
     /**
      * Subtracts the given floats from the current Color3 coordinates and set the given color "result" with this result
      * @param r defines the r coordinate of the operand
@@ -319,18 +319,18 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @param result defines the Color3 object where to store the result
      * @returns the result
      */
-    subtractFromFloatsToRef<T extends Color3>(r: number, g: number, b: number, result: T): T;
+    subtractFromFloatsToRef<T extends IColor3Like>(r: number, g: number, b: number, result: T): T;
     /**
      * Copy the current object
      * @returns a new Color3 copied the current one
      */
-    clone(): this;
+    clone(): Color3;
     /**
      * Copies the rgb values from the source in the current Color3
      * @param source defines the source Color3 object
      * @returns the updated Color3 object
      */
-    copyFrom(source: DeepImmutable<this>): this;
+    copyFrom(source: DeepImmutable<IColor3Like>): this;
     /**
      * Updates the Color3 rgb values from the given floats
      * @param r defines the red component to read from
@@ -362,38 +362,39 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * Converts current color in rgb space to HSV values
      * @returns a new color3 representing the HSV values
      */
-    toHSV(): this;
+    toHSV(): Color3;
     /**
      * Converts current color in rgb space to HSV values
      * @param result defines the Color3 where to store the HSV values
+     * @returns the updated result
      */
-    toHSVToRef(result: this): void;
+    toHSVToRef<T extends IColor3Like>(result: T): T;
     /**
      * Computes a new Color3 converted from the current one to linear space
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns a new Color3 object
      */
-    toLinearSpace(exact?: boolean): this;
+    toLinearSpace(exact?: boolean): Color3;
     /**
      * Converts the Color3 values to linear space and stores the result in "convertedColor"
      * @param convertedColor defines the Color3 object where to store the linear space version
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns the unmodified Color3
      */
-    toLinearSpaceToRef(convertedColor: this, exact?: boolean): this;
+    toLinearSpaceToRef(convertedColor: IColor3Like, exact?: boolean): this;
     /**
      * Computes a new Color3 converted from the current one to gamma space
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns a new Color3 object
      */
-    toGammaSpace(exact?: boolean): this;
+    toGammaSpace(exact?: boolean): Color3;
     /**
      * Converts the Color3 values to gamma space and stores the result in "convertedColor"
      * @param convertedColor defines the Color3 object where to store the gamma space version
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns the unmodified Color3
      */
-    toGammaSpaceToRef(convertedColor: this, exact?: boolean): this;
+    toGammaSpaceToRef(convertedColor: IColor3Like, exact?: boolean): this;
     private static _BlackReadOnly;
     /**
      * Converts Hue, saturation and value to a Color3 (RGB)
@@ -401,8 +402,9 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
      * @param saturation defines the saturation (value between 0 and 1)
      * @param value defines the value (value between 0 and 1)
      * @param result defines the Color3 where to store the RGB values
+     * @returns the updated result
      */
-    static HSVtoRGBToRef(hue: number, saturation: number, value: number, result: Color3): void;
+    static HSVtoRGBToRef<T extends IColor3Like>(hue: number, saturation: number, value: number, result: T): T;
     /**
      * Converts Hue, saturation and value to a new Color3 (RGB)
      * @param hue defines the hue (value between 0 and 360)
@@ -548,7 +550,7 @@ export declare class Color3 implements Tensor<Tuple<number, 3>>, IColor3Like {
 /**
  * Class used to hold a RBGA color
  */
-export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
+export declare class Color4 implements Tensor<Tuple<number, 4>, IColor4Like>, IColor4Like {
     /**
      * Defines the red component (between 0 and 1, default is 0)
      */
@@ -621,26 +623,26 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param otherColor defines the second operand
      * @returns true if the rgba values are equal to the given ones
      */
-    equals(otherColor: DeepImmutable<this>): boolean;
+    equals(otherColor: DeepImmutable<IColor4Like>): boolean;
     /**
      * Creates a new Color4 set with the added values of the current Color4 and of the given one
      * @param otherColor defines the second operand
      * @returns a new Color4 object
      */
-    add(otherColor: DeepImmutable<this>): this;
+    add(otherColor: DeepImmutable<IColor4Like>): Color4;
     /**
      * Updates the given color "result" with the result of the addition of the current Color4 and the given one.
      * @param otherColor the color to add
      * @param result the color to store the result
      * @returns result input
      */
-    addToRef<T extends Color4>(otherColor: DeepImmutable<this>, result: T): T;
+    addToRef<T extends IColor4Like>(otherColor: DeepImmutable<IColor4Like>, result: T): T;
     /**
      * Adds in place the given Color4 values to the current Color4 object
      * @param otherColor defines the second operand
      * @returns the current updated Color4 object
      */
-    addInPlace(otherColor: DeepImmutable<this>): this;
+    addInPlace(otherColor: DeepImmutable<IColor4Like>): this;
     /**
      * Adds the given coordinates to the current Color4
      * @param r defines the r coordinate of the operand
@@ -655,20 +657,20 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param otherColor defines the second operand
      * @returns a new Color4 object
      */
-    subtract(otherColor: DeepImmutable<this>): this;
+    subtract(otherColor: DeepImmutable<IColor4Like>): Color4;
     /**
      * Subtracts the given ones from the current Color4 values and stores the results in "result"
      * @param otherColor defines the second operand
      * @param result defines the Color4 object where to store the result
      * @returns the result Color4 object
      */
-    subtractToRef<T extends this>(otherColor: DeepImmutable<this>, result: T): T;
+    subtractToRef<T extends IColor4Like>(otherColor: DeepImmutable<IColor4Like>, result: T): T;
     /**
      * Subtract in place the given color from the current Color4.
      * @param otherColor the color to subtract
      * @returns the updated Color4.
      */
-    subtractInPlace(otherColor: DeepImmutable<Color4>): this;
+    subtractInPlace(otherColor: DeepImmutable<IColor4Like>): this;
     /**
      * Returns a new Color4 set with the result of the subtraction of the given floats from the current Color4 coordinates.
      * @param r value to subtract
@@ -677,7 +679,7 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param a value to subtract
      * @returns new color containing the result
      */
-    subtractFromFloats(r: number, g: number, b: number, a: number): this;
+    subtractFromFloats(r: number, g: number, b: number, a: number): Color4;
     /**
      * Sets the given color "result" set with the result of the subtraction of the given floats from the current Color4 coordinates.
      * @param r value to subtract
@@ -687,13 +689,13 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param result the color to store the result in
      * @returns result input
      */
-    subtractFromFloatsToRef<T extends Color4>(r: number, g: number, b: number, a: number, result: T): T;
+    subtractFromFloatsToRef<T extends IColor4Like>(r: number, g: number, b: number, a: number, result: T): T;
     /**
      * Creates a new Color4 with the current Color4 values multiplied by scale
      * @param scale defines the scaling factor to apply
      * @returns a new Color4 object
      */
-    scale(scale: number): this;
+    scale(scale: number): Color4;
     /**
      * Multiplies the Color4 values by the float "scale"
      * @param scale defines the scaling factor to apply
@@ -706,14 +708,14 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param result defines the Color4 object where to store the result
      * @returns the result Color4
      */
-    scaleToRef<T extends this>(scale: number, result: T): T;
+    scaleToRef<T extends IColor4Like>(scale: number, result: T): T;
     /**
      * Scale the current Color4 values by a factor and add the result to a given Color4
      * @param scale defines the scale factor
      * @param result defines the Color4 object where to store the result
      * @returns the result Color4
      */
-    scaleAndAddToRef<T extends this>(scale: number, result: T): T;
+    scaleAndAddToRef<T extends IColor4Like>(scale: number, result: T): T;
     /**
      * Clamps the rgb values by the min and max values and stores the result into "result"
      * @param min defines minimum clamping value (default is 0)
@@ -721,26 +723,26 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param result defines color to store the result into.
      * @returns the result Color4
      */
-    clampToRef<T extends this>(min: number | undefined, max: number | undefined, result: T): T;
+    clampToRef<T extends IColor4Like>(min: number | undefined, max: number | undefined, result: T): T;
     /**
      * Multiply an Color4 value by another and return a new Color4 object
      * @param color defines the Color4 value to multiply by
      * @returns a new Color4 object
      */
-    multiply(color: DeepImmutable<this>): this;
+    multiply(color: DeepImmutable<IColor4Like>): Color4;
     /**
      * Multiply a Color4 value by another and push the result in a reference value
      * @param color defines the Color4 value to multiply by
      * @param result defines the Color4 to fill the result in
      * @returns the result Color4
      */
-    multiplyToRef<T extends this>(color: DeepImmutable<this>, result: T): T;
+    multiplyToRef<T extends IColor4Like>(color: DeepImmutable<IColor4Like>, result: T): T;
     /**
      * Multiplies in place the current Color4 by the given one.
      * @param otherColor color to multiple with
      * @returns the updated Color4.
      */
-    multiplyInPlace(otherColor: DeepImmutable<Color4>): this;
+    multiplyInPlace(otherColor: DeepImmutable<IColor4Like>): this;
     /**
      * Returns a new Color4 set with the multiplication result of the given floats and the current Color4 coordinates.
      * @param r value multiply with
@@ -749,34 +751,34 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param a value multiply with
      * @returns resulting new color
      */
-    multiplyByFloats(r: number, g: number, b: number, a: number): this;
+    multiplyByFloats(r: number, g: number, b: number, a: number): Color4;
     /**
      * @internal
      * Do not use
      */
-    divide(_other: DeepImmutable<this>): this;
+    divide(_other: DeepImmutable<IColor4Like>): never;
     /**
      * @internal
      * Do not use
      */
-    divideToRef<T extends this>(_other: DeepImmutable<this>, _result: T): T;
+    divideToRef(_other: DeepImmutable<IColor4Like>, _result: IColor4Like): never;
     /**
      * @internal
      * Do not use
      */
-    divideInPlace(_other: DeepImmutable<this>): this;
+    divideInPlace(_other: DeepImmutable<IColor4Like>): never;
     /**
      * Updates the Color4 coordinates with the minimum values between its own and the given color ones
      * @param other defines the second operand
      * @returns the current updated Color4
      */
-    minimizeInPlace(other: DeepImmutable<Color4>): this;
+    minimizeInPlace(other: DeepImmutable<IColor4Like>): this;
     /**
      * Updates the Color4 coordinates with the maximum values between its own and the given color ones
      * @param other defines the second operand
      * @returns the current updated Color4
      */
-    maximizeInPlace(other: DeepImmutable<Color4>): this;
+    maximizeInPlace(other: DeepImmutable<IColor4Like>): this;
     /**
      * Updates the current Color4 with the minimal coordinate values between its and the given coordinates
      * @param r defines the r coordinate of the operand
@@ -799,44 +801,44 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @internal
      * Do not use
      */
-    floorToRef<T extends this>(_result: T): T;
+    floorToRef(_result: IColor4Like): never;
     /**
      * @internal
      * Do not use
      */
-    floor(): this;
+    floor(): never;
     /**
      * @internal
      * Do not use
      */
-    fractToRef<T extends this>(_result: T): T;
+    fractToRef(_result: IColor4Like): never;
     /**
      * @internal
      * Do not use
      */
-    fract(): this;
+    fract(): never;
     /**
      * @internal
      * Do not use
      */
-    negate(): this;
+    negate(): never;
     /**
      * @internal
      * Do not use
      */
-    negateInPlace(): this;
+    negateInPlace(): never;
     /**
      * @internal
      * Do not use
      */
-    negateToRef<T extends this>(_result: T): T;
+    negateToRef(_result: IColor4Like): never;
     /**
      * Boolean : True if the current Color4 coordinates are each beneath the distance "epsilon" from the given color ones.
      * @param otherColor color to compare against
      * @param epsilon (Default: very small number)
      * @returns true if they are equal
      */
-    equalsWithEpsilon(otherColor: DeepImmutable<Color4>, epsilon?: number): boolean;
+    equalsWithEpsilon(otherColor: DeepImmutable<IColor4Like>, epsilon?: number): boolean;
     /**
      * Boolean : True if the given floats are strictly equal to the current Color4 coordinates.
      * @param x x value to compare against
@@ -865,13 +867,13 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * Creates a new Color4 copied from the current one
      * @returns a new Color4 object
      */
-    clone(): this;
+    clone(): Color4;
     /**
      * Copies the given Color4 values into the current one
      * @param source defines the source Color4 object
      * @returns the current updated Color4 object
      */
-    copyFrom(source: DeepImmutable<Color4>): this;
+    copyFrom(source: DeepImmutable<IColor4Like>): this;
     /**
      * Copies the given float values into the current one
      * @param r defines the red component to read from
@@ -914,7 +916,7 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns the unmodified Color4
      */
-    toLinearSpaceToRef(convertedColor: Color4, exact?: boolean): Color4;
+    toLinearSpaceToRef(convertedColor: IColor4Like, exact?: boolean): this;
     /**
      * Computes a new Color4 converted from the current one to gamma space
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
@@ -927,7 +929,7 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param exact defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
      * @returns the unmodified Color4
      */
-    toGammaSpaceToRef(convertedColor: Color4, exact?: boolean): Color4;
+    toGammaSpaceToRef(convertedColor: IColor4Like, exact?: boolean): this;
     /**
      * Creates a new Color4 from the string containing valid hexadecimal values.
      *
@@ -950,15 +952,16 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param amount defines the gradient factor
      * @returns a new Color4 object
      */
-    static Lerp(left: DeepImmutable<Color4>, right: DeepImmutable<Color4>, amount: number): Color4;
+    static Lerp(left: DeepImmutable<IColor4Like>, right: DeepImmutable<IColor4Like>, amount: number): Color4;
     /**
      * Set the given "result" with the linearly interpolated values of "amount" between the left Color4 object and the right Color4 object
      * @param left defines the start value
      * @param right defines the end value
      * @param amount defines the gradient factor
      * @param result defines the Color4 object where to store data
+     * @returns the updated result
      */
-    static LerpToRef(left: DeepImmutable<Color4>, right: DeepImmutable<Color4>, amount: number, result: Color4): void;
+    static LerpToRef<T extends IColor4Like>(left: DeepImmutable<IColor4Like>, right: DeepImmutable<IColor4Like>, amount: number, result: T): T;
     /**
      * Interpolate between two Color4 using Hermite interpolation
      * @param value1 defines first Color4
@@ -968,7 +971,7 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param amount defines the target Color4
      * @returns the new interpolated Color4
      */
-    static Hermite(value1: DeepImmutable<Color4>, tangent1: DeepImmutable<Color4>, value2: DeepImmutable<Color4>, tangent2: DeepImmutable<Color4>, amount: number): Color4;
+    static Hermite(value1: DeepImmutable<IColor4Like>, tangent1: DeepImmutable<IColor4Like>, value2: DeepImmutable<IColor4Like>, tangent2: DeepImmutable<IColor4Like>, amount: number): Color4;
     /**
      * Returns a new Color4 which is the 1st derivative of the Hermite spline defined by the colors "value1", "value2", "tangent1", "tangent2".
      * @param value1 defines the first control point
@@ -978,7 +981,7 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param time define where the derivative must be done
      * @returns 1st derivative
      */
-    static Hermite1stDerivative(value1: DeepImmutable<Color4>, tangent1: DeepImmutable<Color4>, value2: DeepImmutable<Color4>, tangent2: DeepImmutable<Color4>, time: number): Color4;
+    static Hermite1stDerivative(value1: DeepImmutable<IColor4Like>, tangent1: DeepImmutable<IColor4Like>, value2: DeepImmutable<IColor4Like>, tangent2: DeepImmutable<IColor4Like>, time: number): Color4;
     /**
      * Update a Color4 with the 1st derivative of the Hermite spline defined by the colors "value1", "value2", "tangent1", "tangent2".
      * @param value1 defines the first control point
@@ -988,14 +991,14 @@ export declare class Color4 implements Tensor<Tuple<number, 4>>, IColor4Like {
      * @param time define where the derivative must be done
      * @param result define where to store the derivative
      */
-    static Hermite1stDerivativeToRef(value1: DeepImmutable<Color4>, tangent1: DeepImmutable<Color4>, value2: DeepImmutable<Color4>, tangent2: DeepImmutable<Color4>, time: number, result: Color4): void;
+    static Hermite1stDerivativeToRef(value1: DeepImmutable<IColor4Like>, tangent1: DeepImmutable<IColor4Like>, value2: DeepImmutable<IColor4Like>, tangent2: DeepImmutable<IColor4Like>, time: number, result: IColor4Like): void;
     /**
      * Creates a new Color4 from a Color3 and an alpha value
      * @param color3 defines the source Color3 to read from
      * @param alpha defines the alpha component (1.0 by default)
      * @returns a new Color4 object
      */
-    static FromColor3(color3: DeepImmutable<Color3>, alpha?: number): Color4;
+    static FromColor3(color3: DeepImmutable<IColor3Like>, alpha?: number): Color4;
     /**
      * Creates a new Color4 from the starting index element of the given array
      * @param array defines the source array to read from