@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Color.ts

@@ -1,7 +1,7 @@
 // Auto-generated from extension_api.json - DO NOT EDIT
 // Generated by dev/codegen.ts
 
-import { GodotVar, _C, _R, _get, _set } from '../../src/runtime.ts';
+import { _V } from '../../src/runtime.ts';
 import type { GodotArray, GodotDictionary, PackedColorArray, Variant } from '../heap-types/index.ts';
 
 /**
@@ -13,270 +13,400 @@ import type { GodotArray, GodotDictionary, PackedColorArray, Variant } from '../
  * **Note:** In a boolean context, a Color will evaluate to `false` if it is equal to `Color(0, 0, 0, 1)` (opaque black). Otherwise, a Color will always evaluate to `true`.
  * **Note:** In C#, color constants are defined in the `Colors` static class instead of {@link code skip-lint}Color. Additionally, named colors use `PascalCase` syntax instead of `UPPER_SNAKE_CASE`. For example, {@link code skip-lint}Color.ALICE_BLUE in GDScript is {@link code skip-lint}Colors.AliceBlue in C#.
  */
-export class Color extends GodotVar {
-    /**
-     * The color's red component, typically on the range of 0 to 1.
-     */
-    get r(): number { return _get(this, 9700) as number; }
-    set r(v: number) { _set(this, 9700, v); }
-
-    /**
-     * The color's green component, typically on the range of 0 to 1.
-     */
-    get g(): number { return _get(this, 3624) as number; }
-    set g(v: number) { _set(this, 3624, v); }
-
-    /**
-     * The color's blue component, typically on the range of 0 to 1.
-     */
-    get b(): number { return _get(this, 1686) as number; }
-    set b(v: number) { _set(this, 1686, v); }
-
-    /**
-     * The color's alpha component, typically on the range of 0 to 1. A value of 0 means that the color is fully transparent. A value of 1 means that the color is fully opaque.
-     * **Note:** The alpha channel is always stored with linear encoding, regardless of the encoding of the other color channels. The {@link linearToSrgb} and {@link srgbToLinear} methods do not affect the alpha channel.
-     */
-    get a(): number { return _get(this, 1048) as number; }
-    set a(v: number) { _set(this, 1048, v); }
-
-    constructor();
-    constructor(from: Color);
-    constructor(from: Color, alpha: number);
-    constructor(r: number, g: number, b: number);
-    constructor(r: number, g: number, b: number, a: number);
-    constructor(code: string);
-    constructor(code: string, alpha: number);
-    constructor(...args: any[]) { super(20, ...args); }
-
-    /**
-     * Returns the color converted to a 32-bit integer in ARGB format (each component is 8 bits). ARGB is more compatible with DirectX.
-     *
-     *
-     * ```gdscript
-     *
-     * var color = Color(1, 0.5, 0.2)
-     * print(color.to_argb32()) # Prints 4294934323
-     *
-     * ```
-     */
-    toArgb32(): number { return _C(this, 14286) as number; }
-
-    /**
-     * Returns the color converted to a 32-bit integer in ABGR format (each component is 8 bits). ABGR is the reversed version of the default RGBA format.
-     *
-     *
-     * ```gdscript
-     *
-     * var color = Color(1, 0.5, 0.2)
-     * print(color.to_abgr32()) # Prints 4281565439
-     *
-     * ```
-     */
-    toAbgr32(): number { return _C(this, 14284) as number; }
-
-    /**
-     * Returns the color converted to a 32-bit integer in RGBA format (each component is 8 bits). RGBA is Godot's default format. This method is the inverse of {@link hex}.
-     *
-     *
-     * ```gdscript
-     *
-     * var color = Color(1, 0.5, 0.2)
-     * print(color.to_rgba32()) # Prints 4286526463
-     *
-     * ```
-     */
-    toRgba32(): number { return _C(this, 14309) as number; }
-
-    /**
-     * Returns the color converted to a 64-bit integer in ARGB format (each component is 16 bits). ARGB is more compatible with DirectX.
-     *
-     *
-     * ```gdscript
-     *
-     * var color = Color(1, 0.5, 0.2)
-     * print(color.to_argb64()) # Prints -2147470541
-     *
-     * ```
-     */
-    toArgb64(): number { return _C(this, 14287) as number; }
-
-    /**
-     * Returns the color converted to a 64-bit integer in ABGR format (each component is 16 bits). ABGR is the reversed version of the default RGBA format.
-     *
-     *
-     * ```gdscript
-     *
-     * var color = Color(1, 0.5, 0.2)
-     * print(color.to_abgr64()) # Prints -225178692812801
-     *
-     * ```
-     */
-    toAbgr64(): number { return _C(this, 14285) as number; }
-
-    /**
-     * Returns the color converted to a 64-bit integer in RGBA format (each component is 16 bits). RGBA is Godot's default format. This method is the inverse of {@link hex64}.
-     *
-     *
-     * ```gdscript
-     *
-     * var color = Color(1, 0.5, 0.2)
-     * print(color.to_rgba64()) # Prints -140736629309441
-     *
-     * ```
-     */
-    toRgba64(): number { return _C(this, 14310) as number; }
-
-    /**
-     * Returns the color converted to an HTML hexadecimal color {@link String} in RGBA format, without the hash (`#`) prefix.
-     * Setting `withAlpha` to `false`, excludes alpha from the hexadecimal string, using RGB format instead of RGBA format.
-     *
-     *
-     * ```gdscript
-     *
-     * var white = Color(1, 1, 1, 0.5)
-     * var with_alpha = white.to_html() # Returns "ffffff7f"
-     * var without_alpha = white.to_html(false) # Returns "ffffff"
-     *
-     * ```
-     */
-    toHtml(withAlpha?: boolean /* = true */): string { return _C(this, 14297, withAlpha) as string; }
-
-    /**
-     * Returns a new color with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
-     */
-    clamp(min?: Color /* = Color(0, 0, 0, 0) */, max?: Color /* = Color(1, 1, 1, 1) */): Color { return _C(this, 2202, min, max) as Color; }
-
-    /**
-     * Returns the color with its {@link r}, {@link g}, and {@link b} components inverted (`(1 - r, 1 - g, 1 - b, a)`).
-     *
-     *
-     * ```gdscript
-     *
-     * var black = Color.WHITE.inverted()
-     * var color = Color(0.3, 0.4, 0.9)
-     * var inverted_color = color.inverted() # Equivalent to `Color(0.7, 0.6, 0.1)`
-     *
-     * ```
-     */
-    inverted(): Color { return _C(this, 7723) as Color; }
-
-    /**
-     * Returns the linear interpolation between this color's components and `to`'s components. The interpolation factor `weight` should be between 0.0 and 1.0 (inclusive). See also {@link lerp}.
-     *
-     *
-     * ```gdscript
-     *
-     * var red = Color(1.0, 0.0, 0.0)
-     * var aqua = Color(0.0, 1.0, 0.8)
-     *
-     * red.lerp(aqua, 0.2) # Returns Color(0.8, 0.2, 0.16)
-     * red.lerp(aqua, 0.5) # Returns Color(0.5, 0.5, 0.4)
-     * red.lerp(aqua, 1.0) # Returns Color(0.0, 1.0, 0.8)
-     *
-     * ```
-     */
-    lerp(to: Color, weight: number): Color { return _C(this, 8548, to, weight) as Color; }
-
-    /**
-     * Returns a new color resulting from making this color lighter by the specified `amount`, which should be a ratio from 0.0 to 1.0. See also {@link darkened}.
-     *
-     *
-     * ```gdscript
-     *
-     * var green = Color(0.0, 1.0, 0.0)
-     * var light_green = green.lightened(0.2) # 20% lighter than regular green
-     *
-     * ```
-     */
-    lightened(amount: number): Color { return _C(this, 8592, amount) as Color; }
-
-    /**
-     * Returns a new color resulting from making this color darker by the specified `amount` (ratio from 0.0 to 1.0). See also {@link lightened}.
-     *
-     *
-     * ```gdscript
-     *
-     * var green = Color(0.0, 1.0, 0.0)
-     * var darkgreen = green.darkened(0.2) # 20% darker than regular green
-     *
-     * ```
-     */
-    darkened(amount: number): Color { return _C(this, 2651, amount) as Color; }
-
-    /**
-     * Returns a new color resulting from overlaying this color over the given color. In a painting program, you can imagine it as the `over` color painted over this color (including alpha).
-     *
-     *
-     * ```gdscript
-     *
-     * var bg = Color(0.0, 1.0, 0.0, 0.5) # Green with alpha of 50%
-     * var fg = Color(1.0, 0.0, 0.0, 0.5) # Red with alpha of 50%
-     * var blended_color = bg.blend(fg) # Brown with alpha of 75%
-     *
-     * ```
-     */
-    blend(over: Color): Color { return _C(this, 1787, over) as Color; }
-
-    /**
-     * Returns the light intensity of the color, as a value between 0.0 and 1.0 (inclusive). This is useful when determining light or dark color. Colors with a luminance smaller than 0.5 can be generally considered dark.
-     * **Note:** {@link getLuminance} relies on the color using linear encoding to return an accurate relative luminance value. If the color uses the default nonlinear sRGB encoding, use {@link srgbToLinear} to convert it to linear encoding first.
-     */
-    getLuminance(): number { return _C(this, 5427) as number; }
-
-    /**
-     * Returns a copy of the color that uses linear encoding. This method requires the original color to be encoded using the [nonlinear sRGB transfer function](https://en.wikipedia.org/wiki/SRGB). See also {@link linearToSrgb} which performs the opposite operation.
-     * **Note:** The color's alpha channel ({@link a}) is not affected. The alpha channel is always stored with linear encoding, regardless of the color space of the other color channels.
-     */
-    srgbToLinear(): Color { return _C(this, 13806) as Color; }
-
-    /**
-     * Returns a copy of the color that is encoded using the [nonlinear sRGB transfer function](https://en.wikipedia.org/wiki/SRGB). This method requires the original color to use linear encoding. See also {@link srgbToLinear} which performs the opposite operation.
-     * **Note:** The color's alpha channel ({@link a}) is not affected. The alpha channel is always stored with linear encoding, regardless of the color space of the other color channels.
-     */
-    linearToSrgb(): Color { return _C(this, 8634) as Color; }
-
-    /**
-     * Returns `true` if this color and `to` are approximately equal, by running {@link isEqualApprox} on each component.
-     */
-    isEqualApprox(to: Color): boolean { return _C(this, 7938, to) as boolean; }
-
-    equals(other: Variant | Color): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Color): boolean { return _C(this, -2, other) as boolean; }
-
-    /**
-     * Inverts the given color. This is equivalent to `Color.WHITE - c` or `Color(1 - c.r, 1 - c.g, 1 - c.b, 1 - c.a)`. Unlike with {@link inverted}, the {@link a} component is inverted, too.
-     */
-    neg(): Color { return _C(this, -11, undefined) as Color; }
-
-    /**
-     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
-     */
-    pos(): Color { return _C(this, -12, undefined) as Color; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Multiplies each component of the {@link Color} by the given {@link int}.
-     */
-    mul(other: number | Color): Color { return _C(this, -9, other) as Color; }
-
-    /**
-     * Divides each component of the {@link Color} by the given {@link int}.
-     */
-    div(other: number | Color): Color { return _C(this, -10, other) as Color; }
-
-    /**
-     * Adds each component of the {@link Color} with the components of the given {@link Color}.
-     */
-    add(other: Color): Color { return _C(this, -7, other) as Color; }
-
-    /**
-     * Subtracts each component of the {@link Color} by the components of the given {@link Color}.
-     */
-    sub(other: Color): Color { return _C(this, -8, other) as Color; }
-
-    contains(other: GodotDictionary | GodotArray | PackedColorArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(20, Color);
-}
+export type Color = [r: number, g: number, b: number, a?: number];
+
+/**
+ * Returns the color converted to a 32-bit integer in ARGB format (each component is 8 bits). ARGB is more compatible with DirectX.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color(1, 0.5, 0.2)
+ * print(color.to_argb32()) # Prints 4294934323
+ *
+ * ```
+ */
+export function toArgb32(self: Color): number { return _V(20, 14286, self) as number; }
+
+/**
+ * Returns the color converted to a 32-bit integer in ABGR format (each component is 8 bits). ABGR is the reversed version of the default RGBA format.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color(1, 0.5, 0.2)
+ * print(color.to_abgr32()) # Prints 4281565439
+ *
+ * ```
+ */
+export function toAbgr32(self: Color): number { return _V(20, 14284, self) as number; }
+
+/**
+ * Returns the color converted to a 32-bit integer in RGBA format (each component is 8 bits). RGBA is Godot's default format. This method is the inverse of {@link hex}.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color(1, 0.5, 0.2)
+ * print(color.to_rgba32()) # Prints 4286526463
+ *
+ * ```
+ */
+export function toRgba32(self: Color): number { return _V(20, 14309, self) as number; }
+
+/**
+ * Returns the color converted to a 64-bit integer in ARGB format (each component is 16 bits). ARGB is more compatible with DirectX.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color(1, 0.5, 0.2)
+ * print(color.to_argb64()) # Prints -2147470541
+ *
+ * ```
+ */
+export function toArgb64(self: Color): number { return _V(20, 14287, self) as number; }
+
+/**
+ * Returns the color converted to a 64-bit integer in ABGR format (each component is 16 bits). ABGR is the reversed version of the default RGBA format.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color(1, 0.5, 0.2)
+ * print(color.to_abgr64()) # Prints -225178692812801
+ *
+ * ```
+ */
+export function toAbgr64(self: Color): number { return _V(20, 14285, self) as number; }
+
+/**
+ * Returns the color converted to a 64-bit integer in RGBA format (each component is 16 bits). RGBA is Godot's default format. This method is the inverse of {@link hex64}.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color(1, 0.5, 0.2)
+ * print(color.to_rgba64()) # Prints -140736629309441
+ *
+ * ```
+ */
+export function toRgba64(self: Color): number { return _V(20, 14310, self) as number; }
+
+/**
+ * Returns the color converted to an HTML hexadecimal color {@link String} in RGBA format, without the hash (`#`) prefix.
+ * Setting `withAlpha` to `false`, excludes alpha from the hexadecimal string, using RGB format instead of RGBA format.
+ *
+ *
+ * ```gdscript
+ *
+ * var white = Color(1, 1, 1, 0.5)
+ * var with_alpha = white.to_html() # Returns "ffffff7f"
+ * var without_alpha = white.to_html(false) # Returns "ffffff"
+ *
+ * ```
+ */
+export function toHtml(self: Color, withAlpha?: boolean /* = true */): string { return _V(20, 14297, self, withAlpha) as string; }
+
+/**
+ * Returns a new color with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
+ */
+export function clamp(self: Color, min?: Color /* = Color(0, 0, 0, 0) */, max?: Color /* = Color(1, 1, 1, 1) */): Color { return _V(20, 2202, self, min, max) as Color; }
+
+/**
+ * Returns the color with its {@link r}, {@link g}, and {@link b} components inverted (`(1 - r, 1 - g, 1 - b, a)`).
+ *
+ *
+ * ```gdscript
+ *
+ * var black = Color.WHITE.inverted()
+ * var color = Color(0.3, 0.4, 0.9)
+ * var inverted_color = color.inverted() # Equivalent to `Color(0.7, 0.6, 0.1)`
+ *
+ * ```
+ */
+export function inverted(self: Color): Color { return _V(20, 7723, self) as Color; }
+
+/**
+ * Returns the linear interpolation between this color's components and `to`'s components. The interpolation factor `weight` should be between 0.0 and 1.0 (inclusive). See also {@link lerp}.
+ *
+ *
+ * ```gdscript
+ *
+ * var red = Color(1.0, 0.0, 0.0)
+ * var aqua = Color(0.0, 1.0, 0.8)
+ *
+ * red.lerp(aqua, 0.2) # Returns Color(0.8, 0.2, 0.16)
+ * red.lerp(aqua, 0.5) # Returns Color(0.5, 0.5, 0.4)
+ * red.lerp(aqua, 1.0) # Returns Color(0.0, 1.0, 0.8)
+ *
+ * ```
+ */
+export function lerp(self: Color, to: Color, weight: number): Color { return _V(20, 8548, self, to, weight) as Color; }
+
+/**
+ * Returns a new color resulting from making this color lighter by the specified `amount`, which should be a ratio from 0.0 to 1.0. See also {@link darkened}.
+ *
+ *
+ * ```gdscript
+ *
+ * var green = Color(0.0, 1.0, 0.0)
+ * var light_green = green.lightened(0.2) # 20% lighter than regular green
+ *
+ * ```
+ */
+export function lightened(self: Color, amount: number): Color { return _V(20, 8592, self, amount) as Color; }
+
+/**
+ * Returns a new color resulting from making this color darker by the specified `amount` (ratio from 0.0 to 1.0). See also {@link lightened}.
+ *
+ *
+ * ```gdscript
+ *
+ * var green = Color(0.0, 1.0, 0.0)
+ * var darkgreen = green.darkened(0.2) # 20% darker than regular green
+ *
+ * ```
+ */
+export function darkened(self: Color, amount: number): Color { return _V(20, 2651, self, amount) as Color; }
+
+/**
+ * Returns a new color resulting from overlaying this color over the given color. In a painting program, you can imagine it as the `over` color painted over this color (including alpha).
+ *
+ *
+ * ```gdscript
+ *
+ * var bg = Color(0.0, 1.0, 0.0, 0.5) # Green with alpha of 50%
+ * var fg = Color(1.0, 0.0, 0.0, 0.5) # Red with alpha of 50%
+ * var blended_color = bg.blend(fg) # Brown with alpha of 75%
+ *
+ * ```
+ */
+export function blend(self: Color, over: Color): Color { return _V(20, 1787, self, over) as Color; }
+
+/**
+ * Returns the light intensity of the color, as a value between 0.0 and 1.0 (inclusive). This is useful when determining light or dark color. Colors with a luminance smaller than 0.5 can be generally considered dark.
+ * **Note:** {@link getLuminance} relies on the color using linear encoding to return an accurate relative luminance value. If the color uses the default nonlinear sRGB encoding, use {@link srgbToLinear} to convert it to linear encoding first.
+ */
+export function getLuminance(self: Color): number { return _V(20, 5427, self) as number; }
+
+/**
+ * Returns a copy of the color that uses linear encoding. This method requires the original color to be encoded using the [nonlinear sRGB transfer function](https://en.wikipedia.org/wiki/SRGB). See also {@link linearToSrgb} which performs the opposite operation.
+ * **Note:** The color's alpha channel ({@link a}) is not affected. The alpha channel is always stored with linear encoding, regardless of the color space of the other color channels.
+ */
+export function srgbToLinear(self: Color): Color { return _V(20, 13806, self) as Color; }
+
+/**
+ * Returns a copy of the color that is encoded using the [nonlinear sRGB transfer function](https://en.wikipedia.org/wiki/SRGB). This method requires the original color to use linear encoding. See also {@link srgbToLinear} which performs the opposite operation.
+ * **Note:** The color's alpha channel ({@link a}) is not affected. The alpha channel is always stored with linear encoding, regardless of the color space of the other color channels.
+ */
+export function linearToSrgb(self: Color): Color { return _V(20, 8634, self) as Color; }
+
+/**
+ * Returns `true` if this color and `to` are approximately equal, by running {@link isEqualApprox} on each component.
+ */
+export function isEqualApprox(self: Color, to: Color): boolean { return _V(20, 7938, self, to) as boolean; }
+
+/**
+ * Returns the {@link Color} associated with the provided `hex` integer in 32-bit RGBA format (8 bits per channel). This method is the inverse of {@link toRgba32}.
+ * In GDScript and C#, the {@link int} is best visualized with hexadecimal notation (`"0x"` prefix, making it `"0xRRGGBBAA"`).
+ *
+ *
+ * ```gdscript
+ *
+ * var red = Color.hex(0xff0000ff)
+ * var dark_cyan = Color.hex(0x008b8bff)
+ * var my_color = Color.hex(0xbbefd2a4)
+ *
+ * ```
+ *
+ *
+ *
+ * If you want to use hex notation in a constant expression, use the equivalent constructor instead (i.e. `Color(0xRRGGBBAA)`).
+ */
+export function hex(hex: number): Color { return _V(20, 7504, undefined, hex) as Color; }
+
+/**
+ * Returns the {@link Color} associated with the provided `hex` integer in 64-bit RGBA format (16 bits per channel). This method is the inverse of {@link toRgba64}.
+ * In GDScript and C#, the {@link int} is best visualized with hexadecimal notation (`"0x"` prefix, making it `"0xRRRRGGGGBBBBAAAA"`).
+ */
+export function hex64(hex: number): Color { return _V(20, 7505, undefined, hex) as Color; }
+
+/**
+ * Returns a new color from `rgba`, an HTML hexadecimal color string. `rgba` is not case-sensitive, and may be prefixed by a hash sign (`#`).
+ * `rgba` must be a valid three-digit or six-digit hexadecimal color string, and may contain an alpha channel value. If `rgba` does not contain an alpha channel value, an alpha channel value of 1.0 is applied. If `rgba` is invalid, returns an empty color.
+ *
+ *
+ * ```gdscript
+ *
+ * var blue = Color.html("#0000ff") # blue is Color(0.0, 0.0, 1.0, 1.0)
+ * var green = Color.html("#0F0")   # green is Color(0.0, 1.0, 0.0, 1.0)
+ * var col = Color.html("663399cc") # col is Color(0.4, 0.2, 0.6, 0.8)
+ *
+ * ```
+ */
+export function html(rgba: string): Color { return _V(20, 7542, undefined, rgba) as Color; }
+
+/**
+ * Returns `true` if `color` is a valid HTML hexadecimal color string. The string must be a hexadecimal value (case-insensitive) of either 3, 4, 6 or 8 digits, and may be prefixed by a hash sign (`#`). This method is identical to {@link String.isValidHtmlColor}.
+ *
+ *
+ * ```gdscript
+ *
+ * Color.html_is_valid("#55aaFF")   # Returns true
+ * Color.html_is_valid("#55AAFF20") # Returns true
+ * Color.html_is_valid("55AAFF")    # Returns true
+ * Color.html_is_valid("#F2C")      # Returns true
+ *
+ * Color.html_is_valid("#AABBC")    # Returns false
+ * Color.html_is_valid("#55aaFF5")  # Returns false
+ *
+ * ```
+ */
+export function htmlIsValid(color: string): boolean { return _V(20, 7543, undefined, color) as boolean; }
+
+/**
+ * Creates a {@link Color} from the given string, which can be either an HTML color code or a named color (case-insensitive). Returns `default` if the color cannot be inferred from the string.
+ * If you want to create a color from String in a constant expression, use the equivalent constructor instead (i.e. `Color("color string")`).
+ */
+export function fromString(str: string, _default: Color): Color { return _V(20, 3605, undefined, str, _default) as Color; }
+
+/**
+ * Constructs a color from an [HSV profile](https://en.wikipedia.org/wiki/HSL_and_HSV). The hue (`h`), saturation (`s`), and value (`v`) are typically between 0.0 and 1.0.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color.from_hsv(0.58, 0.5, 0.79, 0.8)
+ *
+ * ```
+ */
+export function fromHsv(h: number, s: number, v: number, alpha?: number /* = 1.0 */): Color { return _V(20, 3596, undefined, h, s, v, alpha) as Color; }
+
+/**
+ * Constructs a color from an [OK HSL profile](https://bottosson.github.io/posts/colorpicker/). The hue (`h`), saturation (`s`), and lightness (`l`) are typically between 0.0 and 1.0.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color.from_ok_hsl(0.58, 0.5, 0.79, 0.8)
+ *
+ * ```
+ */
+export function fromOkHsl(h: number, s: number, l: number, alpha?: number /* = 1.0 */): Color { return _V(20, 3600, undefined, h, s, l, alpha) as Color; }
+
+/**
+ * Decodes a {@link Color} from an RGBE9995 format integer. See {@link Image.FORMAT_RGBE9995}.
+ */
+export function fromRgbe9995(rgbe: number): Color { return _V(20, 3603, undefined, rgbe) as Color; }
+
+/**
+ * Returns a {@link Color} constructed from red (`r8`), green (`g8`), blue (`b8`), and optionally alpha (`a8`) integer channels, each divided by `255.0` for their final value.
+ *
+ * ```text
+ *
+ * var red = Color.from_rgba8(255, 0, 0)             # Same as Color(1, 0, 0).
+ * var dark_blue = Color.from_rgba8(0, 0, 51)        # Same as Color(0, 0, 0.2).
+ * var my_color = Color.from_rgba8(306, 255, 0, 102) # Same as Color(1.2, 1, 0, 0.4).
+ *
+ * ```
+ *
+ * **Note:** Due to the lower precision of {@link fromRgba8} compared to the standard {@link Color} constructor, a color created with {@link fromRgba8} will generally not be equal to the same color created with the standard {@link Color} constructor. Use {@link isEqualApprox} for comparisons to avoid issues with floating-point precision error.
+ */
+export function fromRgba8(r8: number, g8: number, b8: number, a8?: number /* = 255 */): Color { return _V(20, 3602, undefined, r8, g8, b8, a8) as Color; }
+
+export function equals(a: Color, b: Variant | Color): boolean { return _V(20, -1, a, b) as boolean; }
+
+export function notEquals(a: Color, b: Variant | Color): boolean { return _V(20, -2, a, b) as boolean; }
+
+/**
+ * Inverts the given color. This is equivalent to `Color.WHITE - c` or `Color(1 - c.r, 1 - c.g, 1 - c.b, 1 - c.a)`. Unlike with {@link inverted}, the {@link a} component is inverted, too.
+ */
+export function neg(self: Color): Color { return _V(20, -11, self, undefined) as Color; }
+
+/**
+ * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
+ */
+export function pos(self: Color): Color { return _V(20, -12, self, undefined) as Color; }
+
+export function not(self: Color): boolean { return _V(20, -24, self, undefined) as boolean; }
+
+/**
+ * Multiplies each component of the {@link Color} by the given {@link int}.
+ */
+export function mul(a: Color, b: number | Color): Color { return _V(20, -9, a, b) as Color; }
+
+/**
+ * Divides each component of the {@link Color} by the given {@link int}.
+ */
+export function div(a: Color, b: number | Color): Color { return _V(20, -10, a, b) as Color; }
+
+/**
+ * Adds each component of the {@link Color} with the components of the given {@link Color}.
+ */
+export function add(a: Color, b: Color): Color { return _V(20, -7, a, b) as Color; }
+
+/**
+ * Subtracts each component of the {@link Color} by the components of the given {@link Color}.
+ */
+export function sub(a: Color, b: Color): Color { return _V(20, -8, a, b) as Color; }
+
+export function contains(a: Color, b: GodotDictionary | GodotArray | PackedColorArray): boolean { return _V(20, -25, a, b) as boolean; }
+
+/**
+ * Constructs a default {@link Color} from opaque black. This is the same as {@link BLACK}.
+ * **Note:** In C#, this constructs a {@link Color} with all of its components set to `0.0` (transparent black).
+ */
+export function create(): Color { return _V(20, -4096, 0) as Color; }
+
+/**
+ * Constructs a {@link Color} as a copy of the given {@link Color}.
+ */
+export function fromColor(from: Color): Color { return _V(20, -4096, 1, from) as Color; }
+
+/**
+ * Constructs a {@link Color} from the existing color, with {@link a} set to the given `alpha` value.
+ *
+ *
+ * ```gdscript
+ *
+ * var red = Color(Color.RED, 0.2) # 20% opaque red.
+ *
+ * ```
+ */
+export function fromAlpha(from: Color, alpha: number): Color { return _V(20, -4096, 2, from, alpha) as Color; }
+
+/**
+ * Constructs a {@link Color} from RGB values, typically between 0.0 and 1.0. {@link a} is set to 1.0.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color(0.2, 1.0, 0.7) # Similar to `Color.from_rgba8(51, 255, 178, 255)`
+ *
+ * ```
+ */
+export function fromRGB(r: number, g: number, b: number): Color { return _V(20, -4096, 3, r, g, b) as Color; }
+
+/**
+ * Constructs a {@link Color} from RGBA values, typically between 0.0 and 1.0.
+ *
+ *
+ * ```gdscript
+ *
+ * var color = Color(0.2, 1.0, 0.7, 0.8) # Similar to `Color.from_rgba8(51, 255, 178, 204)`
+ *
+ * ```
+ */
+export function fromRGBA(r: number, g: number, b: number, a: number): Color { return _V(20, -4096, 4, r, g, b, a) as Color; }
+
+/**
+ * Constructs a {@link Color} either from an HTML color code or from a standardized color name. The supported color names are the same as the constants.
+ */
+export function fromCode(code: string): Color { return _V(20, -4096, 5, code) as Color; }
+
+/**
+ * Constructs a {@link Color} either from an HTML color code or from a standardized color name, with `alpha` on the range of 0.0 to 1.0. The supported color names are the same as the constants.
+ */
+export function fromCodeAlpha(code: string, alpha: number): Color { return _V(20, -4096, 6, code, alpha) as Color; }
+