@ringozz/godot 0.1.0

package/gen/utility-functions.ts

@@ -0,0 +1,1457 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C } from '../src/runtime.ts';
+import type { Variant, PackedByteArray, PackedInt64Array, RID } from './heap-types/index.ts';
+
+/**
+ * Returns the sine of angle `angleRad` in radians.
+ *
+ * ```text
+ *
+ * sin(0.523599)       # Returns 0.5
+ * sin(deg_to_rad(90)) # Returns 1.0
+ *
+ * ```
+ */
+export function sin(angleRad: number): number { return _C(0x18617f8e90b3n, 13606, angleRad) as number; }
+
+/**
+ * Returns the cosine of angle `angleRad` in radians.
+ *
+ * ```text
+ *
+ * cos(PI * 2)         # Returns 1.0
+ * cos(PI)             # Returns -1.0
+ * cos(deg_to_rad(90)) # Returns 0.0
+ *
+ * ```
+ */
+export function cos(angleRad: number): number { return _C(0x18617f8e90b3n, 2500, angleRad) as number; }
+
+/**
+ * Returns the tangent of angle `angleRad` in radians.
+ *
+ * ```text
+ *
+ * tan(deg_to_rad(45)) # Returns 1
+ *
+ * ```
+ */
+export function tan(angleRad: number): number { return _C(0x18617f8e90b3n, 14117, angleRad) as number; }
+
+/**
+ * Returns the hyperbolic sine of `x`.
+ *
+ * ```text
+ *
+ * var a = log(2.0) # Returns 0.693147
+ * sinh(a) # Returns 0.75
+ *
+ * ```
+ */
+export function sinh(x: number): number { return _C(0x18617f8e90b3n, 13607, x) as number; }
+
+/**
+ * Returns the hyperbolic cosine of `x` in radians.
+ *
+ * ```text
+ *
+ * print(cosh(1)) # Prints 1.543081
+ *
+ * ```
+ */
+export function cosh(x: number): number { return _C(0x18617f8e90b3n, 2501, x) as number; }
+
+/**
+ * Returns the hyperbolic tangent of `x`.
+ *
+ * ```text
+ *
+ * var a = log(2.0) # Returns 0.693147
+ * tanh(a)          # Returns 0.6
+ *
+ * ```
+ */
+export function tanh(x: number): number { return _C(0x18617f8e90b3n, 14122, x) as number; }
+
+/**
+ * Returns the arc sine of `x` in radians. Use to get the angle of sine `x`. `x` will be clamped between `-1.0` and `1.0` (inclusive), in order to prevent {@link asin} from returning `NAN`.
+ *
+ * ```text
+ *
+ * # s is 0.523599 or 30 degrees if converted with rad_to_deg(s)
+ * var s = asin(0.5)
+ *
+ * ```
+ */
+export function asin(x: number): number { return _C(0x18617f8e90b3n, 1600, x) as number; }
+
+/**
+ * Returns the arc cosine of `x` in radians. Use to get the angle of cosine `x`. `x` will be clamped between `-1.0` and `1.0` (inclusive), in order to prevent {@link acos} from returning `NAN`.
+ *
+ * ```text
+ *
+ * # c is 0.523599 or 30 degrees if converted with rad_to_deg(c)
+ * var c = acos(0.866025)
+ *
+ * ```
+ */
+export function acos(x: number): number { return _C(0x18617f8e90b3n, 1152, x) as number; }
+
+/**
+ * Returns the arc tangent of `x` in radians. Use it to get the angle from an angle's tangent in trigonometry.
+ * The method cannot know in which quadrant the angle should fall. See {@link atan2} if you have both `y` and {@link code skip-lint}x.
+ *
+ * ```text
+ *
+ * var a = atan(0.5) # a is 0.463648
+ *
+ * ```
+ *
+ * If `x` is between `-PI / 2` and `PI / 2` (inclusive), `atan(tan(x))` is equal to `x`.
+ */
+export function atan(x: number): number { return _C(0x18617f8e90b3n, 1606, x) as number; }
+
+/**
+ * Returns the arc tangent of `y/x` in radians. Use to get the angle of tangent `y/x`. To compute the value, the method takes into account the sign of both arguments in order to determine the quadrant.
+ * Important note: The Y coordinate comes first, by convention.
+ *
+ * ```text
+ *
+ * var a = atan2(0, -1) # a is 3.141593
+ *
+ * ```
+ */
+export function atan2(y: number, x: number): number { return _C(0x61862058054can, 1607, y, x) as number; }
+
+/**
+ * Returns the hyperbolic arc (also called inverse) sine of `x`, returning a value in radians. Use it to get the angle from an angle's sine in hyperbolic space.
+ *
+ * ```text
+ *
+ * var a = asinh(0.9) # Returns 0.8088669356527824
+ * sinh(a) # Returns 0.9
+ *
+ * ```
+ */
+export function asinh(x: number): number { return _C(0x18617f8e90b3n, 1601, x) as number; }
+
+/**
+ * Returns the hyperbolic arc (also called inverse) cosine of `x`, returning a value in radians. Use it to get the angle from an angle's cosine in hyperbolic space if `x` is larger or equal to 1. For values of `x` lower than 1, it will return 0, in order to prevent {@link acosh} from returning `NAN`.
+ *
+ * ```text
+ *
+ * var a = acosh(2) # Returns 1.31695789692482
+ * cosh(a) # Returns 2
+ *
+ * var b = acosh(-1) # Returns 0
+ *
+ * ```
+ */
+export function acosh(x: number): number { return _C(0x18617f8e90b3n, 1153, x) as number; }
+
+/**
+ * Returns the hyperbolic arc (also called inverse) tangent of `x`, returning a value in radians. Use it to get the angle from an angle's tangent in hyperbolic space if `x` is between -1 and 1 (non-inclusive).
+ * In mathematics, the inverse hyperbolic tangent is only defined for -1 < `x` < 1 in the real set, so values equal or lower to -1 for `x` return negative `INF` and values equal or higher than 1 return positive `INF` in order to prevent {@link atanh} from returning `NAN`.
+ *
+ * ```text
+ *
+ * var a = atanh(0.9) # Returns 1.47221948958322
+ * tanh(a) # Returns 0.9
+ *
+ * var b = atanh(-2) # Returns -inf
+ * tanh(b) # Returns -1
+ *
+ * ```
+ */
+export function atanh(x: number): number { return _C(0x18617f8e90b3n, 1608, x) as number; }
+
+/**
+ * Returns the square root of `x`, where `x` is a non-negative number.
+ *
+ * ```text
+ *
+ * sqrt(9)     # Returns 3
+ * sqrt(10.24) # Returns 3.2
+ * sqrt(-1)    # Returns NaN
+ *
+ * ```
+ *
+ * **Note:** Negative values of `x` return NaN ("Not a Number"). In C#, if you need negative inputs, use `System.Numerics.Complex`.
+ */
+export function sqrt(x: number): number { return _C(0x18617f8e90b3n, 13799, x) as number; }
+
+/**
+ * Returns the floating-point remainder of `x` divided by `y`, keeping the sign of `x`.
+ *
+ * ```text
+ *
+ * var remainder = fmod(7, 5.5) # remainder is 1.5
+ *
+ * ```
+ *
+ * For the integer remainder operation, use the `%` operator.
+ */
+export function fmod(x: number, y: number): number { return _C(0x61862058054can, 3345, x, y) as number; }
+
+/**
+ * Returns the floating-point modulus of `x` divided by `y`, wrapping equally in positive and negative.
+ *
+ * ```text
+ *
+ * print(" (x)  (fmod(x, 1.5))   (fposmod(x, 1.5))")
+ * for i in 7:
+ * 	var x = i * 0.5 - 1.5
+ * 	print("%4.1f           %4.1f  | %4.1f" % [x, fmod(x, 1.5), fposmod(x, 1.5)])
+ *
+ * ```
+ *
+ * Prints:
+ *
+ * ```text
+ *
+ *  (x)  (fmod(x, 1.5))   (fposmod(x, 1.5))
+ * -1.5           -0.0  |  0.0
+ * -1.0           -1.0  |  0.5
+ * -0.5           -0.5  |  1.0
+ *  0.0            0.0  |  0.0
+ *  0.5            0.5  |  0.5
+ *  1.0            1.0  |  1.0
+ *  1.5            0.0  |  0.0
+ *
+ * ```
+ */
+export function fposmod(x: number, y: number): number { return _C(0x61862058054can, 3555, x, y) as number; }
+
+/**
+ * Returns the integer modulus of `x` divided by `y` that wraps equally in positive and negative.
+ *
+ * ```text
+ *
+ * print("#(i)  (i % 3)   (posmod(i, 3))")
+ * for i in range(-3, 4):
+ * 	print("%2d       %2d  | %2d" % [i, i % 3, posmod(i, 3)])
+ *
+ * ```
+ *
+ * Prints:
+ *
+ * ```text
+ *
+ * (i)  (i % 3)   (posmod(i, 3))
+ * -3        0  |  0
+ * -2       -2  |  1
+ * -1       -1  |  2
+ *  0        0  |  0
+ *  1        1  |  1
+ *  2        2  |  2
+ *  3        0  |  0
+ *
+ * ```
+ */
+export function posmod(x: number, y: number): number { return _C(0x41042bac4b5fan, 9518, x, y) as number; }
+
+/**
+ * Rounds `x` downward (towards negative infinity), returning the largest whole number that is not more than `x`. Supported types: {@link int}, {@link float}, {@link Vector2}, {@link Vector2i}, {@link Vector3}, {@link Vector3i}, {@link Vector4}, {@link Vector4i}.
+ *
+ * ```text
+ *
+ * var a = floor(2.99) # a is 2.0
+ * a = floor(-2.99)    # a is -3.0
+ *
+ * ```
+ *
+ * See also {@link ceil}, {@link round}, and {@link snapped}.
+ * **Note:** For better type safety, use {@link floorf}, {@link floori}, {@link Vector2.floor}, {@link Vector3.floor}, or {@link Vector4.floor}.
+ */
+export function floor(x: Variant): Variant { return _C(0x1ffe10048e204n, 3335, x) as Variant; }
+
+/**
+ * Rounds `x` downward (towards negative infinity), returning the largest whole number that is not more than `x`.
+ * A type-safe version of {@link floor}, returning a {@link float}.
+ */
+export function floorf(x: number): number { return _C(0x18617f8e90b3n, 3341, x) as number; }
+
+/**
+ * Rounds `x` downward (towards negative infinity), returning the largest whole number that is not more than `x`.
+ * A type-safe version of {@link floor}, returning an {@link int}.
+ * **Note:** This function is *not* the same as `int(x)`, which rounds towards 0.
+ */
+export function floori(x: number): number { return _C(0x1841a5b9ecaan, 3342, x) as number; }
+
+/**
+ * Rounds `x` upward (towards positive infinity), returning the smallest whole number that is not less than `x`. Supported types: {@link int}, {@link float}, {@link Vector2}, {@link Vector2i}, {@link Vector3}, {@link Vector3i}, {@link Vector4}, {@link Vector4i}.
+ *
+ * ```text
+ *
+ * var i = ceil(1.45) # i is 2.0
+ * i = ceil(1.001)    # i is 2.0
+ *
+ * ```
+ *
+ * See also {@link floor}, {@link round}, and {@link snapped}.
+ * **Note:** For better type safety, use {@link ceilf}, {@link ceili}, {@link Vector2.ceil}, {@link Vector3.ceil}, or {@link Vector4.ceil}.
+ */
+export function ceil(x: Variant): Variant { return _C(0x1ffe10048e204n, 2156, x) as Variant; }
+
+/**
+ * Rounds `x` upward (towards positive infinity), returning the smallest whole number that is not less than `x`.
+ * A type-safe version of {@link ceil}, returning a {@link float}.
+ */
+export function ceilf(x: number): number { return _C(0x18617f8e90b3n, 2157, x) as number; }
+
+/**
+ * Rounds `x` upward (towards positive infinity), returning the smallest whole number that is not less than `x`.
+ * A type-safe version of {@link ceil}, returning an {@link int}.
+ */
+export function ceili(x: number): number { return _C(0x1841a5b9ecaan, 2158, x) as number; }
+
+/**
+ * Rounds `x` to the nearest whole number, with halfway cases rounded away from 0. Supported types: {@link int}, {@link float}, {@link Vector2}, {@link Vector2i}, {@link Vector3}, {@link Vector3i}, {@link Vector4}, {@link Vector4i}.
+ *
+ * ```text
+ *
+ * round(2.4) # Returns 2
+ * round(2.5) # Returns 3
+ * round(2.6) # Returns 3
+ *
+ * ```
+ *
+ * See also {@link floor}, {@link ceil}, and {@link snapped}.
+ * **Note:** For better type safety, use {@link roundf}, {@link roundi}, {@link Vector2.round}, {@link Vector3.round}, or {@link Vector4.round}.
+ */
+export function round(x: Variant): Variant { return _C(0x1ffe10048e204n, 10166, x) as Variant; }
+
+/**
+ * Rounds `x` to the nearest whole number, with halfway cases rounded away from 0.
+ * A type-safe version of {@link round}, returning a {@link float}.
+ */
+export function roundf(x: number): number { return _C(0x18617f8e90b3n, 10169, x) as number; }
+
+/**
+ * Rounds `x` to the nearest whole number, with halfway cases rounded away from 0.
+ * A type-safe version of {@link round}, returning an {@link int}.
+ */
+export function roundi(x: number): number { return _C(0x1841a5b9ecaan, 10170, x) as number; }
+
+/**
+ * Returns the absolute value of a {@link Variant} parameter `x` (i.e. non-negative value). Supported types: {@link int}, {@link float}, {@link Vector2}, {@link Vector2i}, {@link Vector3}, {@link Vector3i}, {@link Vector4}, {@link Vector4i}.
+ *
+ * ```text
+ *
+ * var a = abs(-1)
+ * # a is 1
+ *
+ * var b = abs(-1.2)
+ * # b is 1.2
+ *
+ * var c = abs(Vector2(-3.5, -4))
+ * # c is (3.5, 4)
+ *
+ * var d = abs(Vector2i(-5, -6))
+ * # d is (5, 6)
+ *
+ * var e = abs(Vector3(-7, 8.5, -3.8))
+ * # e is (7, 8.5, 3.8)
+ *
+ * var f = abs(Vector3i(-7, -8, -9))
+ * # f is (7, 8, 9)
+ *
+ * ```
+ *
+ * **Note:** For better type safety, use {@link absf}, {@link absi}, {@link Vector2.abs}, {@link Vector2i.abs}, {@link Vector3.abs}, {@link Vector3i.abs}, {@link Vector4.abs}, or {@link Vector4i.abs}.
+ */
+export function abs(x: Variant): Variant { return _C(0x1ffe10048e204n, 1053, x) as Variant; }
+
+/**
+ * Returns the absolute value of float parameter `x` (i.e. positive value).
+ *
+ * ```text
+ *
+ * # a is 1.2
+ * var a = absf(-1.2)
+ *
+ * ```
+ */
+export function absf(x: number): number { return _C(0x18617f8e90b3n, 1054, x) as number; }
+
+/**
+ * Returns the absolute value of int parameter `x` (i.e. positive value).
+ *
+ * ```text
+ *
+ * # a is 1
+ * var a = absi(-1)
+ *
+ * ```
+ */
+export function absi(x: number): number { return _C(0x1041809616d0n, 1055, x) as number; }
+
+/**
+ * Returns the same type of {@link Variant} as `x`, with `-1` for negative values, `1` for positive values, and `0` for zeros. For `nan` values it returns 0.
+ * Supported types: {@link int}, {@link float}, {@link Vector2}, {@link Vector2i}, {@link Vector3}, {@link Vector3i}, {@link Vector4}, {@link Vector4i}.
+ *
+ * ```text
+ *
+ * sign(-6.0) # Returns -1
+ * sign(0.0)  # Returns 0
+ * sign(6.0)  # Returns 1
+ * sign(NAN)  # Returns 0
+ *
+ * sign(Vector3(-6.0, 0.0, 6.0)) # Returns (-1, 0, 1)
+ *
+ * ```
+ *
+ * **Note:** For better type safety, use {@link signf}, {@link signi}, {@link Vector2.sign}, {@link Vector2i.sign}, {@link Vector3.sign}, {@link Vector3i.sign}, {@link Vector4.sign}, or {@link Vector4i.sign}.
+ */
+export function sign(x: Variant): Variant { return _C(0x1ffe10048e204n, 13597, x) as Variant; }
+
+/**
+ * Returns `-1.0` if `x` is negative, `1.0` if `x` is positive, and `0.0` if `x` is zero. For `nan` values of `x` it returns 0.0.
+ *
+ * ```text
+ *
+ * signf(-6.5) # Returns -1.0
+ * signf(0.0)  # Returns 0.0
+ * signf(6.5)  # Returns 1.0
+ * signf(NAN)  # Returns 0.0
+ *
+ * ```
+ */
+export function signf(x: number): number { return _C(0x18617f8e90b3n, 13599, x) as number; }
+
+/**
+ * Returns `-1` if `x` is negative, `1` if `x` is positive, and `0` if `x` is zero.
+ *
+ * ```text
+ *
+ * signi(-6) # Returns -1
+ * signi(0)  # Returns 0
+ * signi(6)  # Returns 1
+ *
+ * ```
+ */
+export function signi(x: number): number { return _C(0x1041809616d0n, 13600, x) as number; }
+
+/**
+ * Returns the multiple of `step` that is the closest to `x`. This can also be used to round a floating-point number to an arbitrary number of decimals.
+ * The returned value is the same type of {@link Variant} as `step`. Supported types: {@link int}, {@link float}, {@link Vector2}, {@link Vector2i}, {@link Vector3}, {@link Vector3i}, {@link Vector4}, {@link Vector4i}.
+ *
+ * ```text
+ *
+ * snapped(100, 32)  # Returns 96
+ * snapped(3.14159, 0.01)  # Returns 3.14
+ *
+ * snapped(Vector2(34, 70), Vector2(8, 8))  # Returns (32, 72)
+ *
+ * ```
+ *
+ * See also {@link ceil}, {@link floor}, and {@link round}.
+ * **Note:** For better type safety, use {@link snappedf}, {@link snappedi}, {@link Vector2.snapped}, {@link Vector2i.snapped}, {@link Vector3.snapped}, {@link Vector3i.snapped}, {@link Vector4.snapped}, or {@link Vector4i.snapped}.
+ */
+export function snapped(x: Variant, step: Variant): Variant { return _C(0x7fffe21b69bdd0n, 13674, x, step) as Variant; }
+
+/**
+ * Returns the multiple of `step` that is the closest to `x`. This can also be used to round a floating-point number to an arbitrary number of decimals.
+ * A type-safe version of {@link snapped}, returning a {@link float}.
+ *
+ * ```text
+ *
+ * snappedf(32.0, 2.5)  # Returns 32.5
+ * snappedf(3.14159, 0.01)  # Returns 3.14
+ *
+ * ```
+ */
+export function snappedf(x: number, step: number): number { return _C(0x61862058054can, 13675, x, step) as number; }
+
+/**
+ * Returns the multiple of `step` that is the closest to `x`.
+ * A type-safe version of {@link snapped}, returning an {@link int}.
+ *
+ * ```text
+ *
+ * snappedi(53, 16)  # Returns 48
+ * snappedi(4096, 100)  # Returns 4100
+ *
+ * ```
+ */
+export function snappedi(x: number, step: number): number { return _C(0x41842d4d572f9n, 13676, x, step) as number; }
+
+/**
+ * Returns the result of `base` raised to the power of `exp`.
+ * In GDScript, this is the equivalent of the `**` operator.
+ *
+ * ```text
+ *
+ * pow(2, 5)   # Returns 32.0
+ * pow(4, 1.5) # Returns 8.0
+ *
+ * ```
+ */
+export function pow(base: number, exp: number): number { return _C(0x61862058054can, 9522, base, exp) as number; }
+
+/**
+ * Returns the [natural logarithm](https://en.wikipedia.org/wiki/Natural_logarithm) of `x` (base [e](https://en.wikipedia.org/wiki/E_(mathematical_constant)), with *e* being approximately 2.71828). This is the amount of time needed to reach a certain level of continuous growth.
+ * **Note:** This is not the same as the "log" function on most calculators, which uses a base 10 logarithm. To use base 10 logarithm, use `log(x) / log(10)`.
+ *
+ * ```text
+ *
+ * log(10) # Returns 2.302585
+ *
+ * ```
+ *
+ * **Note:** The logarithm of `0` returns `-inf`, while negative values return `-nan`.
+ */
+export function log(x: number): number { return _C(0x18617f8e90b3n, 8704, x) as number; }
+
+/**
+ * The natural exponential function. It raises the mathematical constant *e* to the power of `x` and returns it.
+ * *e* has an approximate value of 2.71828, and can be obtained with `exp(1)`.
+ * For exponents to other bases use the method {@link pow}.
+ *
+ * ```text
+ *
+ * var a = exp(2) # Approximately 7.39
+ *
+ * ```
+ */
+export function exp(x: number): number { return _C(0x18617f8e90b3n, 3185, x) as number; }
+
+/**
+ * Returns `true` if `x` is a NaN ("Not a Number" or invalid) value. This method is needed as `NAN` is not equal to itself, which means `x == NAN` can't be used to check whether a value is a NaN.
+ */
+export function isNan(x: number): boolean { return _C(0x1821d4bde6edn, 8125, x) as boolean; }
+
+/**
+ * Returns `true` if `x` is either positive infinity or negative infinity. See also {@link isFinite} and {@link isNan}.
+ */
+export function isInf(x: number): boolean { return _C(0x1821d4bde6edn, 8023, x) as boolean; }
+
+/**
+ * Returns `true` if `a` and `b` are approximately equal to each other.
+ * Here, "approximately equal" means that `a` and `b` are within a small internal epsilon of each other, which scales with the magnitude of the numbers.
+ * Infinity values of the same sign are considered equal.
+ */
+export function isEqualApprox(a: number, b: number): boolean { return _C(0x61822537e5a81n, 7938, a, b) as boolean; }
+
+/**
+ * Returns `true` if `x` is zero or almost zero. The comparison is done using a tolerance calculation with a small internal epsilon.
+ * This function is faster than using {@link isEqualApprox} with one value as zero.
+ */
+export function isZeroApprox(x: number): boolean { return _C(0x1821d4bde6edn, 8459, x) as boolean; }
+
+/**
+ * Returns whether `x` is a finite value, i.e. it is not `NAN`, positive infinity, or negative infinity. See also {@link isInf} and {@link isNan}.
+ */
+export function isFinite(x: number): boolean { return _C(0x1821d4bde6edn, 7951, x) as boolean; }
+
+/**
+ * Returns an "eased" value of `x` based on an easing function defined with `curve`. This easing function is based on an exponent. The `curve` can be any floating-point number, with specific values leading to the following behaviors:
+ *
+ * ```text
+ *
+ * - Lower than -1.0 (exclusive): Ease in-out
+ * - -1.0: Linear
+ * - Between -1.0 and 0.0 (exclusive): Ease out-in
+ * - 0.0: Constant
+ * - Between 0.0 to 1.0 (exclusive): Ease out
+ * - 1.0: Linear
+ * - Greater than 1.0 (exclusive): Ease in
+ *
+ * ```
+ *
+ * [ease() curve values cheatsheet](https://raw.githubusercontent.com/godotengine/godot-docs/master/img/ease_cheatsheet.png)
+ * See also {@link smoothstep}. If you need to perform more advanced transitions, use {@link Tween.interpolateValue}.
+ */
+export function ease(x: number, curve: number): number { return _C(0x61862058054can, 2988, x, curve) as number; }
+
+/**
+ * Returns the position of the first non-zero digit, after the decimal point. Note that the maximum return value is 10, which is a design decision in the implementation.
+ *
+ * ```text
+ *
+ * var n = step_decimals(5)       # n is 0
+ * n = step_decimals(1.0005)      # n is 4
+ * n = step_decimals(0.000000005) # n is 9
+ *
+ * ```
+ */
+export function stepDecimals(x: number): number { return _C(0x1841a5b9ecaan, 13862, x) as number; }
+
+/**
+ * Linearly interpolates between two values by the factor defined in `weight`. To perform interpolation, `weight` should be between `0.0` and `1.0` (inclusive). However, values outside this range are allowed and can be used to perform *extrapolation*. If this is not desired, use {@link clampf} to limit `weight`.
+ * Both `from` and `to` must be the same type. Supported types: {@link int}, {@link float}, {@link Vector2}, {@link Vector3}, {@link Vector4}, {@link Color}, {@link Quaternion}, {@link Basis}, {@link Transform2D}, {@link Transform3D}.
+ *
+ * ```text
+ *
+ * lerp(0, 4, 0.75) # Returns 3.0
+ *
+ * ```
+ *
+ * See also {@link inverseLerp} which performs the reverse of this operation. To perform eased interpolation with {@link lerp}, combine it with {@link ease} or {@link smoothstep}. See also {@link remap} to map a continuous series of values to another.
+ * **Note:** For better type safety, use {@link lerpf}, {@link Vector2.lerp}, {@link Vector3.lerp}, {@link Vector4.lerp}, {@link Color.lerp}, {@link Quaternion.slerp}, {@link Basis.slerp}, {@link Transform2D.interpolateWith}, or {@link Transform3D.interpolateWith}.
+ */
+export function lerp(from: Variant, to: Variant, weight: Variant): Variant { return _C(0x1fffffe3ca0d616en, 8548, from, to, weight) as Variant; }
+
+/**
+ * Linearly interpolates between two values by the factor defined in `weight`. To perform interpolation, `weight` should be between `0.0` and `1.0` (inclusive). However, values outside this range are allowed and can be used to perform *extrapolation*. If this is not desired, use {@link clampf} on the result of this function.
+ *
+ * ```text
+ *
+ * lerpf(0, 4, 0.75) # Returns 3.0
+ *
+ * ```
+ *
+ * See also {@link inverseLerp} which performs the reverse of this operation. To perform eased interpolation with {@link lerp}, combine it with {@link ease} or {@link smoothstep}.
+ */
+export function lerpf(from: number, to: number, weight: number): number { return _C(0x18618633b8a0538n, 8550, from, to, weight) as number; }
+
+/**
+ * Cubic interpolates between two values by the factor defined in `weight` with `pre` and `post` values.
+ */
+export function cubicInterpolate(from: number, to: number, pre: number, post: number, weight: number): number { return _C(0x18618618654106d11fn /* 65+ bits */, 2590, from, to, pre, post, weight) as number; }
+
+/**
+ * Cubic interpolates between two rotation values with shortest path by the factor defined in `weight` with `pre` and `post` values. See also {@link lerpAngle}.
+ */
+export function cubicInterpolateAngle(from: number, to: number, pre: number, post: number, weight: number): number { return _C(0x18618618654106d11fn /* 65+ bits */, 2591, from, to, pre, post, weight) as number; }
+
+/**
+ * Cubic interpolates between two values by the factor defined in `weight` with `pre` and `post` values.
+ * It can perform smoother interpolation than {@link cubicInterpolate} by the time values.
+ */
+export function cubicInterpolateInTime(from: number, to: number, pre: number, post: number, weight: number, toT: number, preT: number, postT: number): number { return _C(0x61861861861868172241ccn /* 65+ bits */, 2593, from, to, pre, post, weight, toT, preT, postT) as number; }
+
+/**
+ * Cubic interpolates between two rotation values with shortest path by the factor defined in `weight` with `pre` and `post` values. See also {@link lerpAngle}.
+ * It can perform smoother interpolation than {@link cubicInterpolate} by the time values.
+ */
+export function cubicInterpolateAngleInTime(from: number, to: number, pre: number, post: number, weight: number, toT: number, preT: number, postT: number): number { return _C(0x61861861861868172241ccn /* 65+ bits */, 2592, from, to, pre, post, weight, toT, preT, postT) as number; }
+
+/**
+ * Returns the point at the given `t` on a one-dimensional [Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) defined by the given `control1`, `control2`, and `end` points.
+ */
+export function bezierInterpolate(start: number, control1: number, control2: number, end: number, t: number): number { return _C(0x18618618654106d11fn /* 65+ bits */, 1757, start, control1, control2, end, t) as number; }
+
+/**
+ * Returns the derivative at the given `t` on a one-dimensional [Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) defined by the given `control1`, `control2`, and `end` points.
+ */
+export function bezierDerivative(start: number, control1: number, control2: number, end: number, t: number): number { return _C(0x18618618654106d11fn /* 65+ bits */, 1756, start, control1, control2, end, t) as number; }
+
+/**
+ * Returns the difference between the two angles (in radians), in the range of `[-PI, +PI]`. When `from` and `to` are opposite, returns `-PI` if `from` is smaller than `to`, or `PI` otherwise.
+ */
+export function angleDifference(from: number, to: number): number { return _C(0x61862058054can, 1450, from, to) as number; }
+
+/**
+ * Linearly interpolates between two angles (in radians) by a `weight` value between 0.0 and 1.0.
+ * Similar to {@link lerp}, but interpolates correctly when the angles wrap around `TAU`. To perform eased interpolation with {@link lerpAngle}, combine it with {@link ease} or {@link smoothstep}.
+ *
+ * ```text
+ *
+ * extends Sprite
+ * var elapsed = 0.0
+ * func _process(delta):
+ * 	var min_angle = deg_to_rad(0.0)
+ * 	var max_angle = deg_to_rad(90.0)
+ * 	rotation = lerp_angle(min_angle, max_angle, elapsed)
+ * 	elapsed += delta
+ *
+ * ```
+ *
+ * **Note:** This function lerps through the shortest path between `from` and `to`. However, when these two angles are approximately `PI + k * TAU` apart for any integer `k`, it's not obvious which way they lerp due to floating-point precision errors. For example, `lerp_angle(0, PI, weight)` lerps counter-clockwise, while `lerp_angle(0, PI + 5 * TAU, weight)` lerps clockwise.
+ */
+export function lerpAngle(from: number, to: number, weight: number): number { return _C(0x18618633b8a0538n, 8549, from, to, weight) as number; }
+
+/**
+ * Returns an interpolation or extrapolation factor considering the range specified in `from` and `to`, and the interpolated value specified in `weight`. The returned value will be between `0.0` and `1.0` if `weight` is between `from` and `to` (inclusive). If `weight` is located outside this range, then an extrapolation factor will be returned (return value lower than `0.0` or greater than `1.0`). Use {@link clamp} on the result of {@link inverseLerp} if this is not desired.
+ *
+ * ```text
+ *
+ * # The interpolation ratio in the `lerp()` call below is 0.75.
+ * var middle = lerp(20, 30, 0.75)
+ * # middle is now 27.5.
+ *
+ * # Now, we pretend to have forgotten the original ratio and want to get it back.
+ * var ratio = inverse_lerp(20, 30, 27.5)
+ * # ratio is now 0.75.
+ *
+ * ```
+ *
+ * See also {@link lerp}, which performs the reverse of this operation, and {@link remap} to map a continuous series of values to another.
+ */
+export function inverseLerp(from: number, to: number, weight: number): number { return _C(0x18618633b8a0538n, 7718, from, to, weight) as number; }
+
+/**
+ * Maps a `value` from range `[istart, istop]` to `[ostart, ostop]`. See also {@link lerp} and {@link inverseLerp}. If `value` is outside `[istart, istop]`, then the resulting value will also be outside `[ostart, ostop]`. If this is not desired, use {@link clamp} on the result of this function.
+ *
+ * ```text
+ *
+ * remap(75, 0, 100, -1, 1) # Returns 0.5
+ *
+ * ```
+ *
+ * For complex use cases where multiple ranges are needed, consider using {@link Curve} or {@link Gradient} instead.
+ * **Note:** If `istart == istop`, the return value is undefined (most likely NaN, INF, or -INF).
+ */
+export function remap(value: number, istart: number, istop: number, ostart: number, ostop: number): number { return _C(0x18618618654106d11fn /* 65+ bits */, 9875, value, istart, istop, ostart, ostop) as number; }
+
+/**
+ * Returns a smooth cubic Hermite interpolation between `0` and `1`.
+ * For positive ranges (when `from <= to`) the return value is `0` when `x <= from`, and `1` when `x >= to`. If `x` lies between `from` and `to`, the return value follows an S-shaped curve that smoothly transitions from `0` to `1`.
+ * For negative ranges (when `from > to`) the function is mirrored and returns `1` when `x <= to` and `0` when `x >= from`.
+ * This S-shaped curve is the cubic Hermite interpolator, given by `f(y) = 3*y^2 - 2*y^3` where `y = (x-from) / (to-from)`.
+ *
+ * ```text
+ *
+ * smoothstep(0, 2, -5.0) # Returns 0.0
+ * smoothstep(0, 2, 0.5) # Returns 0.15625
+ * smoothstep(0, 2, 1.0) # Returns 0.5
+ * smoothstep(0, 2, 2.0) # Returns 1.0
+ *
+ * ```
+ *
+ * Compared to {@link ease} with a curve value of `-1.6521`, {@link smoothstep} returns the smoothest possible curve with no sudden changes in the derivative. If you need to perform more advanced transitions, use {@link Tween} or {@link AnimationPlayer}.
+ * [Comparison between smoothstep() and ease(x, -1.6521) return values](https://raw.githubusercontent.com/godotengine/godot-docs/master/img/smoothstep_ease_comparison.png)
+ * [Smoothstep() return values with positive, zero, and negative ranges](https://raw.githubusercontent.com/godotengine/godot-docs/master/img/smoothstep_range.webp)
+ */
+export function smoothstep(from: number, to: number, x: number): number { return _C(0x18618633b8a0538n, 13670, from, to, x) as number; }
+
+/**
+ * Moves `from` toward `to` by the `delta` amount. Will not go past `to`.
+ * Use a negative `delta` value to move away.
+ *
+ * ```text
+ *
+ * move_toward(5, 10, 4)    # Returns 9
+ * move_toward(10, 5, 4)    # Returns 6
+ * move_toward(5, 10, 9)    # Returns 10
+ * move_toward(10, 5, -1.5) # Returns 11.5
+ *
+ * ```
+ */
+export function moveToward(from: number, to: number, delta: number): number { return _C(0x18618633b8a0538n, 9004, from, to, delta) as number; }
+
+/**
+ * Rotates `from` toward `to` by the `delta` amount. Will not go past `to`.
+ * Similar to {@link moveToward}, but interpolates correctly when the angles wrap around `TAU`.
+ * If `delta` is negative, this function will rotate away from `to`, toward the opposite angle, and will not go past the opposite angle.
+ */
+export function rotateToward(from: number, to: number, delta: number): number { return _C(0x18618633b8a0538n, 10140, from, to, delta) as number; }
+
+/**
+ * Converts an angle expressed in degrees to radians.
+ *
+ * ```text
+ *
+ * var r = deg_to_rad(180) # r is 3.141593
+ *
+ * ```
+ */
+export function degToRad(deg: number): number { return _C(0x18617f8e90b3n, 2715, deg) as number; }
+
+/**
+ * Converts an angle expressed in radians to degrees.
+ *
+ * ```text
+ *
+ * rad_to_deg(0.523599) # Returns 30
+ * rad_to_deg(PI)       # Returns 180
+ * rad_to_deg(PI * 2)   # Returns 360
+ *
+ * ```
+ */
+export function radToDeg(rad: number): number { return _C(0x18617f8e90b3n, 9702, rad) as number; }
+
+/**
+ * Converts from linear energy to decibels (audio). Since volume is not normally linear, this can be used to implement volume sliders that behave as expected.
+ * **Example:** Change the Master bus's volume through a {@link Slider} node, which ranges from `0.0` to `1.0`:
+ *
+ * ```text
+ *
+ * AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear_to_db($Slider.value))
+ *
+ * ```
+ */
+export function linearToDb(lin: number): number { return _C(0x18617f8e90b3n, 8633, lin) as number; }
+
+/**
+ * Converts from decibels to linear energy (audio).
+ */
+export function dbToLinear(db: number): number { return _C(0x18617f8e90b3n, 2656, db) as number; }
+
+/**
+ * Wraps the {@link Variant} `value` between `min` and `max`. `min` is *inclusive* while `max` is *exclusive*. This can be used for creating loop-like behavior or infinite surfaces.
+ * Variant types {@link int} and {@link float} are supported. If any of the arguments is {@link float}, this function returns a {@link float}, otherwise it returns an {@link int}.
+ *
+ * ```text
+ *
+ * var a = wrap(4, 5, 10)
+ * # a is 9 (int)
+ *
+ * var a = wrap(7, 5, 10)
+ * # a is 7 (int)
+ *
+ * var a = wrap(10.5, 5, 10)
+ * # a is 5.5 (float)
+ *
+ * ```
+ */
+export function wrap(value: Variant, min: Variant, max: Variant): Variant { return _C(0x1fffffe3ca0d616en, 14926, value, min, max) as Variant; }
+
+/**
+ * Wraps the integer `value` between `min` and `max`. `min` is *inclusive* while `max` is *exclusive*. This can be used for creating loop-like behavior or infinite surfaces.
+ *
+ * ```text
+ *
+ * # Infinite loop between 5 and 9
+ * frame = wrapi(frame + 1, 5, 10)
+ *
+ * ```
+ *
+ *
+ * ```text
+ *
+ * # result is -2
+ * var result = wrapi(-6, -5, -1)
+ *
+ * ```
+ */
+export function wrapi(value: number, min: number, max: number): number { return _C(0x104104326c2b897n, 14933, value, min, max) as number; }
+
+/**
+ * Wraps the float `value` between `min` and `max`. `min` is *inclusive* while `max` is *exclusive*. This can be used for creating loop-like behavior or infinite surfaces.
+ *
+ * ```text
+ *
+ * # Infinite loop between 5.0 and 9.9
+ * value = wrapf(value + 0.1, 5.0, 10.0)
+ *
+ * ```
+ *
+ *
+ * ```text
+ *
+ * # Infinite rotation (in radians)
+ * angle = wrapf(angle + 0.1, 0.0, TAU)
+ *
+ * ```
+ *
+ *
+ * ```text
+ *
+ * # Infinite rotation (in radians)
+ * angle = wrapf(angle + 0.1, -PI, PI)
+ *
+ * ```
+ *
+ * **Note:** If `min` is `0`, this is equivalent to {@link fposmod}, so prefer using that instead. {@link wrapf} is more flexible than using the {@link fposmod} approach by giving the user control over the minimum value.
+ */
+export function wrapf(value: number, min: number, max: number): number { return _C(0x18618633b8a0538n, 14932, value, min, max) as number; }
+
+/**
+ * Returns the maximum of the given numeric values. This function can take any number of arguments.
+ *
+ * ```text
+ *
+ * max(1, 7, 3, -6, 5) # Returns 7
+ *
+ * ```
+ *
+ * **Note:** When using this on vectors it will *not* perform component-wise maximum, and will pick the largest value when compared using `x < y`. To perform component-wise maximum, use {@link Vector2.max}, {@link Vector2i.max}, {@link Vector3.max}, {@link Vector3i.max}, {@link Vector4.max}, and {@link Vector4i.max}.
+ */
+export function max(arg1: Variant, arg2: Variant): Variant { return _C(0x7fffe2e83902a0n, 8804, arg1, arg2) as Variant; }
+
+/**
+ * Returns the maximum of two {@link int} values.
+ *
+ * ```text
+ *
+ * maxi(1, 2)   # Returns 2
+ * maxi(-3, -4) # Returns -3
+ *
+ * ```
+ */
+export function maxi(a: number, b: number): number { return _C(0x41042bac4b5fan, 8840, a, b) as number; }
+
+/**
+ * Returns the maximum of two {@link float} values.
+ *
+ * ```text
+ *
+ * maxf(3.6, 24)   # Returns 24.0
+ * maxf(-3.99, -4) # Returns -3.99
+ *
+ * ```
+ */
+export function maxf(a: number, b: number): number { return _C(0x61862058054can, 8839, a, b) as number; }
+
+/**
+ * Returns the minimum of the given numeric values. This function can take any number of arguments.
+ *
+ * ```text
+ *
+ * min(1, 7, 3, -6, 5) # Returns -6
+ *
+ * ```
+ *
+ * **Note:** When using this on vectors it will *not* perform component-wise minimum, and will pick the smallest value when compared using `x < y`. To perform component-wise minimum, use {@link Vector2.min}, {@link Vector2i.min}, {@link Vector3.min}, {@link Vector3i.min}, {@link Vector4.min}, and {@link Vector4i.min}.
+ */
+export function min(arg1: Variant, arg2: Variant): Variant { return _C(0x7fffe2e83902a0n, 8910, arg1, arg2) as Variant; }
+
+/**
+ * Returns the minimum of two {@link int} values.
+ *
+ * ```text
+ *
+ * mini(1, 2)   # Returns 1
+ * mini(-3, -4) # Returns -4
+ *
+ * ```
+ */
+export function mini(a: number, b: number): number { return _C(0x41042bac4b5fan, 8922, a, b) as number; }
+
+/**
+ * Returns the minimum of two {@link float} values.
+ *
+ * ```text
+ *
+ * minf(3.6, 24)   # Returns 3.6
+ * minf(-3.99, -4) # Returns -4.0
+ *
+ * ```
+ */
+export function minf(a: number, b: number): number { return _C(0x61862058054can, 8921, a, b) as number; }
+
+/**
+ * Clamps the `value`, returning a {@link Variant} not less than `min` and not more than `max`. Any values that can be compared with the less than and greater than operators will work.
+ *
+ * ```text
+ *
+ * var a = clamp(-10, -1, 5)
+ * # a is -1
+ *
+ * var b = clamp(8.1, 0.9, 5.5)
+ * # b is 5.5
+ *
+ * ```
+ *
+ * **Note:** For better type safety, use {@link clampf}, {@link clampi}, {@link Vector2.clamp}, {@link Vector2i.clamp}, {@link Vector3.clamp}, {@link Vector3i.clamp}, {@link Vector4.clamp}, {@link Vector4i.clamp}, or {@link Color.clamp} (not currently supported by this method).
+ * **Note:** When using this on vectors it will *not* perform component-wise clamping, and will pick `min` if `value < min` or `max` if `value > max`. To perform component-wise clamping use the methods listed above.
+ */
+export function clamp(value: Variant, min: Variant, max: Variant): Variant { return _C(0x1fffffe3ca0d616en, 2202, value, min, max) as Variant; }
+
+/**
+ * Clamps the `value`, returning an {@link int} not less than `min` and not more than `max`.
+ *
+ * ```text
+ *
+ * var speed = 42
+ * var a = clampi(speed, 1, 20) # a is 20
+ *
+ * speed = -10
+ * var b = clampi(speed, -1, 1) # b is -1
+ *
+ * ```
+ */
+export function clampi(value: number, min: number, max: number): number { return _C(0x104104326c2b897n, 2206, value, min, max) as number; }
+
+/**
+ * Clamps the `value`, returning a {@link float} not less than `min` and not more than `max`.
+ *
+ * ```text
+ *
+ * var speed = 42.1
+ * var a = clampf(speed, 1.0, 20.5) # a is 20.5
+ *
+ * speed = -10.0
+ * var b = clampf(speed, -1.0, 1.0) # b is -1.0
+ *
+ * ```
+ */
+export function clampf(value: number, min: number, max: number): number { return _C(0x18618633b8a0538n, 2205, value, min, max) as number; }
+
+/**
+ * Returns the smallest integer power of 2 that is greater than or equal to `value`.
+ *
+ * ```text
+ *
+ * nearest_po2(3) # Returns 4
+ * nearest_po2(4) # Returns 4
+ * nearest_po2(5) # Returns 8
+ *
+ * nearest_po2(0)  # Returns 0 (this may not be expected)
+ * nearest_po2(-1) # Returns 0 (this may not be expected)
+ *
+ * ```
+ *
+ * **Warning:** Due to its implementation, this method returns `0` rather than `1` for values less than or equal to `0`, with an exception for `value` being the smallest negative 64-bit integer (`-9223372036854775808`) in which case the `value` is returned unchanged.
+ */
+export function nearestPo2(value: number): number { return _C(0x1041809616d0n, 9062, value) as number; }
+
+/**
+ * Wraps `value` between `0` and the `length`. If the limit is reached, the next value the function returns is decreased to the `0` side or increased to the `length` side (like a triangle wave). If `length` is less than zero, it becomes positive.
+ *
+ * ```text
+ *
+ * pingpong(-3.0, 3.0) # Returns 3.0
+ * pingpong(-2.0, 3.0) # Returns 2.0
+ * pingpong(-1.0, 3.0) # Returns 1.0
+ * pingpong(0.0, 3.0)  # Returns 0.0
+ * pingpong(1.0, 3.0)  # Returns 1.0
+ * pingpong(2.0, 3.0)  # Returns 2.0
+ * pingpong(3.0, 3.0)  # Returns 3.0
+ * pingpong(4.0, 3.0)  # Returns 2.0
+ * pingpong(5.0, 3.0)  # Returns 1.0
+ * pingpong(6.0, 3.0)  # Returns 0.0
+ *
+ * ```
+ */
+export function pingpong(value: number, length: number): number { return _C(0x61862058054can, 9430, value, length) as number; }
+
+/**
+ * Randomizes the seed (or the internal state) of the random number generator. The current implementation uses a number based on the device's time.
+ * **Note:** This function is called automatically when the project is run. If you need to fix the seed to have consistent, reproducible results, use {@link seed} to initialize the random number generator.
+ */
+export function randomize(): void { _C(0x64d59d5cn, 9729); }
+
+/**
+ * Returns a random unsigned 32-bit integer. Use remainder to obtain a random value in the interval `[0, N - 1]` (where N is smaller than 2^32).
+ *
+ *
+ * ```gdscript
+ *
+ * randi()           # Returns random integer between 0 and 2^32 - 1
+ * randi() % 20      # Returns random integer between 0 and 19
+ * randi() % 100     # Returns random integer between 0 and 99
+ * randi() % 100 + 1 # Returns random integer between 1 and 100
+ *
+ * ```
+ */
+export function randi(): number { return _C(0x4029cb80d8n, 9724) as number; }
+
+/**
+ * Returns a random floating-point value between `0.0` and `1.0` (inclusive).
+ *
+ *
+ * ```gdscript
+ *
+ * randf() # Returns e.g. 0.375671
+ *
+ * ```
+ */
+export function randf(): number { return _C(0x607c594f85n, 9721) as number; }
+
+/**
+ * Returns a random signed 32-bit integer between `from` and `to` (inclusive). If `to` is lesser than `from`, they are swapped.
+ *
+ *
+ * ```gdscript
+ *
+ * randi_range(0, 1)      # Returns either 0 or 1
+ * randi_range(-10, 1000) # Returns random integer between -10 and 1000
+ *
+ * ```
+ */
+export function randiRange(from: number, to: number): number { return _C(0x41042bac4b5fan, 9725, from, to) as number; }
+
+/**
+ * Returns a random floating-point value between `from` and `to` (inclusive).
+ *
+ *
+ * ```gdscript
+ *
+ * randf_range(0, 20.5) # Returns e.g. 7.45315
+ * randf_range(-10, 10) # Returns e.g. -3.844535
+ *
+ * ```
+ */
+export function randfRange(from: number, to: number): number { return _C(0x61862058054can, 9722, from, to) as number; }
+
+/**
+ * Returns a [normally-distributed](https://en.wikipedia.org/wiki/Normal_distribution), pseudo-random floating-point value from the specified `mean` and a standard `deviation`. This is also known as a Gaussian distribution.
+ * **Note:** This method uses the [Box-Muller transform](https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform) algorithm.
+ */
+export function randfn(mean: number, deviation: number): number { return _C(0x61862058054can, 9723, mean, deviation) as number; }
+
+/**
+ * Sets the seed for the random number generator to `base`. Setting the seed manually can ensure consistent, repeatable results for most random functions.
+ *
+ *
+ * ```gdscript
+ *
+ * var my_seed = "Godot Rocks".hash()
+ * seed(my_seed)
+ * var a = randf() + randi()
+ * seed(my_seed)
+ * var b = randf() + randi()
+ * # a and b are now identical
+ *
+ * ```
+ */
+export function seed(base: number): void { _C(0x100116d310e5n, 10342, base); }
+
+/**
+ * Given a `seed`, returns a {@link PackedInt64Array} of size `2`, where its first element is the randomized {@link int} value, and the second element is the same as `seed`. Passing the same `seed` consistently returns the same array.
+ * **Note:** "Seed" here refers to the internal state of the pseudo random number generator, currently implemented as a 64 bit integer.
+ *
+ * ```text
+ *
+ * var a = rand_from_seed(4)
+ *
+ * print(a[0]) # Prints 2879024997
+ * print(a[1]) # Prints 4
+ *
+ * ```
+ */
+export function randFromSeed(seed: number): PackedInt64Array { return _C(0x13e152e9f285n, 9719, seed) as PackedInt64Array; }
+
+/**
+ * Returns a {@link WeakRef} instance holding a weak reference to `obj`. Returns an empty {@link WeakRef} instance if `obj` is `null`. Prints an error and returns `null` if `obj` is neither {@link Object}-derived nor `null`.
+ * A weak reference to an object is not enough to keep the object alive: when the only remaining references to a referent are weak references, garbage collection is free to destroy the referent and reuse its memory for something else. However, until the object is actually destroyed the weak reference may return the object even if there are no strong references to it.
+ */
+export function weakref(obj: Variant): Variant { return _C(0x1ffe10048e204n, 14843, obj) as Variant; }
+
+/**
+ * Returns the internal type of the given `variable`, using the {@link Variant.Type} values.
+ *
+ * ```text
+ *
+ * var json = JSON.new()
+ * json.parse('["a", "b", "c"]')
+ * var result = json.get_data()
+ * if typeof(result) == TYPE_ARRAY:
+ * 	print(result[0]) # Prints "a"
+ * else:
+ * 	print("Unexpected result!")
+ *
+ * ```
+ *
+ * See also {@link typeString}.
+ */
+export function _typeof(variable: Variant): number { return _C(0x1f8411374d042n, 14457, variable) as number; }
+
+/**
+ * Converts the given `variant` to the given `type`, using the {@link Variant.Type} values. This method is generous with how it handles types, it can automatically convert between array types, convert numeric {@link String}s to {@link int}, and converting most things to {@link String}.
+ * If the type conversion cannot be done, this method will return the default value for that type, for example converting {@link Rect2} to {@link Vector2} will always return {@link Vector2.ZERO}. This method will never show error messages as long as `type` is a valid Variant type.
+ * The returned value is a {@link Variant}, but the data inside and its type will be the same as the requested type.
+ *
+ * ```text
+ *
+ * type_convert("Hi!", TYPE_INT) # Returns 0
+ * type_convert("123", TYPE_INT) # Returns 123
+ * type_convert(123.4, TYPE_INT) # Returns 123
+ * type_convert(5, TYPE_VECTOR2) # Returns (0, 0)
+ * type_convert("Hi!", TYPE_NIL) # Returns null
+ *
+ * ```
+ */
+export function typeConvert(variant: Variant, type: number): Variant { return _C(0x5ffe29236c45an, 14454, variant, type) as Variant; }
+
+/**
+ * Converts one or more arguments of any {@link Variant} type to a {@link String} in the best way possible.
+ *
+ * ```text
+ *
+ * var a = [10, 20, 30]
+ * var b = str(a)
+ * print(len(a)) # Prints 3 (the number of elements in the array).
+ * print(len(b)) # Prints 12 (the length of the string "[10, 20, 30]").
+ *
+ * ```
+ */
+export function str(arg1: Variant): string { return _C(0x1f88101f0f758n, 13887, arg1) as string; }
+
+/**
+ * Returns a human-readable name for the given {@link Error} code.
+ *
+ * ```text
+ *
+ * print(OK)                              # Prints 0
+ * print(error_string(OK))                # Prints "OK"
+ * print(error_string(ERR_BUSY))          # Prints "Busy"
+ * print(error_string(ERR_OUT_OF_MEMORY)) # Prints "Out of memory"
+ *
+ * ```
+ */
+export function errorString(error: number): string { return _C(0x108138309612n, 3166, error) as string; }
+
+/**
+ * Returns a human-readable name of the given `type`, using the {@link Variant.Type} values.
+ *
+ * ```text
+ *
+ * print(TYPE_INT) # Prints 2
+ * print(type_string(TYPE_INT)) # Prints "int"
+ * print(type_string(TYPE_STRING)) # Prints "String"
+ *
+ * ```
+ *
+ * See also {@link typeof}.
+ */
+export function typeString(type: number): string { return _C(0x108138309612n, 14456, type) as string; }
+
+/**
+ * Converts one or more arguments of any type to string in the best way possible and prints them to the console.
+ *
+ *
+ * ```gdscript
+ *
+ * var a = [1, 2, 3]
+ * print("a", "b", a) # Prints "ab[1, 2, 3]"
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** Consider using {@link pushError} and {@link pushWarning} to print error and warning messages instead of {@link print} or {@link printRich}. This distinguishes them from print messages used for debugging purposes, while also displaying a stack trace when an error or warning is printed. See also {@link Engine.printToStdout} and {@link ProjectSettings.application/run/disableStdout}.
+ */
+export function print(arg1: Variant): void { _C(0x1f8019de0016en, 9554, arg1); }
+
+/**
+ * Converts one or more arguments of any type to string in the best way possible and prints them to the console.
+ * The following BBCode tags are supported: `b`, `i`, `u`, `s`, `indent`, `code`, `url`, `center`, `right`, `color`, `bgcolor`, `fgcolor`.
+ * URL tags only support URLs wrapped by a URL tag, not URLs with a different title.
+ * When printing to standard output, the supported subset of BBCode is converted to ANSI escape codes for the terminal emulator to display. Support for ANSI escape codes varies across terminal emulators, especially for italic and strikethrough. In standard output, `code` is represented with faint text but without any font change. Unsupported tags are left as-is in standard output.
+ *
+ * {@link gdscript skip-lint}
+ * print_rich("[b]Hello world![/b]") # Prints "Hello world!", in green with a bold font.
+ * [/gdscript]
+ * {@link csharp skip-lint}
+ * GD.PrintRich("[b]Hello world![/b]"); // Prints "Hello world!", in green with a bold font.
+ * [/csharp]
+ *
+ * **Note:** Consider using {@link pushError} and {@link pushWarning} to print error and warning messages instead of {@link print} or {@link printRich}. This distinguishes them from print messages used for debugging purposes, while also displaying a stack trace when an error or warning is printed.
+ * **Note:** Output displayed in the editor supports clickable {@link code skip-lint}[text](address) tags. The {@link code skip-lint}[]() tag's `address` value is handled by {@link OS.shellOpen} when clicked.
+ */
+export function printRich(arg1: Variant): void { _C(0x1f8019de0016en, 9557, arg1); }
+
+/**
+ * Prints one or more arguments to strings in the best way possible to standard error line.
+ *
+ *
+ * ```gdscript
+ *
+ * printerr("prints to stderr")
+ *
+ * ```
+ */
+export function printerr(arg1: Variant): void { _C(0x1f8019de0016en, 9562, arg1); }
+
+/**
+ * Prints one or more arguments to the console with a tab between each argument.
+ *
+ *
+ * ```gdscript
+ *
+ * printt("A", "B", "C") # Prints "A       B       C"
+ *
+ * ```
+ */
+export function printt(arg1: Variant): void { _C(0x1f8019de0016en, 9565, arg1); }
+
+/**
+ * Prints one or more arguments to the console with a space between each argument.
+ *
+ *
+ * ```gdscript
+ *
+ * prints("A", "B", "C") # Prints "A B C"
+ *
+ * ```
+ */
+export function prints(arg1: Variant): void { _C(0x1f8019de0016en, 9564, arg1); }
+
+/**
+ * Prints one or more arguments to strings in the best way possible to the OS terminal. Unlike {@link print}, no newline is automatically added at the end.
+ * **Note:** The OS terminal is *not* the same as the editor's Output dock. The output sent to the OS terminal can be seen when running Godot from a terminal. On Windows, this requires using the `console.exe` executable.
+ *
+ *
+ * ```gdscript
+ *
+ * # Prints "ABC" to terminal.
+ * printraw("A")
+ * printraw("B")
+ * printraw("C")
+ *
+ * ```
+ */
+export function printraw(arg1: Variant): void { _C(0x1f8019de0016en, 9563, arg1); }
+
+/**
+ * If verbose mode is enabled ({@link OS.isStdoutVerbose} returning `true`), converts one or more arguments of any type to string in the best way possible and prints them to the console.
+ */
+export function printVerbose(arg1: Variant): void { _C(0x1f8019de0016en, 9561, arg1); }
+
+/**
+ * Pushes an error message to Godot's built-in debugger and to the OS terminal.
+ *
+ *
+ * ```gdscript
+ *
+ * push_error("test error") # Prints "test error" to debugger and terminal as an error.
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** This function does not pause project execution. To print an error message and pause project execution in debug builds, use `assert(false, "test error")` instead.
+ */
+export function pushError(arg1: Variant): void { _C(0x1f8019de0016en, 9640, arg1); }
+
+/**
+ * Pushes a warning message to Godot's built-in debugger and to the OS terminal.
+ *
+ *
+ * ```gdscript
+ *
+ * push_warning("test warning") # Prints "test warning" to debugger and terminal as a warning.
+ *
+ * ```
+ */
+export function pushWarning(arg1: Variant): void { _C(0x1f8019de0016en, 9663, arg1); }
+
+/**
+ * Converts a {@link Variant} `variable` to a formatted {@link String} that can then be parsed using {@link strToVar}.
+ *
+ *
+ * ```gdscript
+ *
+ * var a = { "a": 1, "b": 2 }
+ * print(var_to_str(a))
+ *
+ * ```
+ *
+ *
+ *
+ * Prints:
+ *
+ * ```text
+ *
+ * {
+ * 	"a": 1,
+ * 	"b": 2
+ * }
+ *
+ * ```
+ *
+ * **Note:** Converting {@link Signal} or {@link Callable} is not supported and will result in an empty value for these types, regardless of their data.
+ */
+export function varToStr(variable: Variant): string { return _C(0x1f88133a7a7c7n, 14675, variable) as string; }
+
+/**
+ * Converts a formatted `string` that was returned by {@link varToStr} to the original {@link Variant}.
+ *
+ *
+ * ```gdscript
+ *
+ * var data = '{ "a": 1, "b": 2 }' # data is a String
+ * var dict = str_to_var(data)     # dict is a Dictionary
+ * print(dict["a"])                # Prints 1
+ *
+ * ```
+ */
+export function strToVar(string: string): Variant { return _C(0x27e170bdf9fbn, 13888, string) as Variant; }
+
+/**
+ * Encodes a {@link Variant} value to a byte array, without encoding objects. Deserialization can be done with {@link bytesToVar}.
+ * **Note:** If you need object serialization, see {@link varToBytesWithObjects}.
+ * **Note:** Encoding {@link Callable} is not supported and will result in an empty value, regardless of the data.
+ */
+export function varToBytes(variable: Variant): PackedByteArray { return _C(0x1fba1afabc52an, 14673, variable) as PackedByteArray; }
+
+/**
+ * Decodes a byte array back to a {@link Variant} value, without decoding objects.
+ * **Note:** If you need object deserialization, see {@link bytesToVarWithObjects}.
+ */
+export function bytesToVar(bytes: PackedByteArray): Variant { return _C(0xefe1fd4f193cn, 1963, bytes) as Variant; }
+
+/**
+ * Encodes a {@link Variant} value to a byte array. Encoding objects is allowed (and can potentially include executable code). Deserialization can be done with {@link bytesToVarWithObjects}.
+ * **Note:** Encoding {@link Callable} is not supported and will result in an empty value, regardless of the data.
+ */
+export function varToBytesWithObjects(variable: Variant): PackedByteArray { return _C(0x1fba1afabc52an, 14674, variable) as PackedByteArray; }
+
+/**
+ * Decodes a byte array back to a {@link Variant} value. Decoding objects is allowed.
+ * **Warning:** Deserialized object can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats (remote code execution).
+ */
+export function bytesToVarWithObjects(bytes: PackedByteArray): Variant { return _C(0xefe1fd4f193cn, 1964, bytes) as Variant; }
+
+/**
+ * Returns the integer hash of the passed `variable`.
+ *
+ *
+ * ```gdscript
+ *
+ * print(hash("a")) # Prints 177670
+ *
+ * ```
+ */
+export function hash(variable: Variant): number { return _C(0x1f8411374d042n, 7487, variable) as number; }
+
+/**
+ * Returns the {@link Object} that corresponds to `instanceId`. All Objects have a unique instance ID. See also {@link Object.getInstanceId}.
+ *
+ *
+ * ```gdscript
+ *
+ * var drink = "water"
+ *
+ * func _ready():
+ * 	var id = get_instance_id()
+ * 	var instance = instance_from_id(id)
+ * 	print(instance.drink) # Prints "water"
+ *
+ * ```
+ */
+export function instanceFromId(instanceId: number): Object { return _C(0x130144f1c26cn, 7646, instanceId) as Object; }
+
+/**
+ * Returns `true` if the Object that corresponds to `id` is a valid object (e.g. has not been deleted from memory). All Objects have a unique instance ID.
+ */
+export function isInstanceIdValid(id: number): boolean { return _C(0x1021851053cen, 8033, id) as boolean; }
+
+/**
+ * Returns `true` if `instance` is a valid Object (e.g. has not been deleted from memory).
+ */
+export function isInstanceValid(instance: Variant): boolean { return _C(0x1f8213b5fb849n, 8034, instance) as boolean; }
+
+/**
+ * Allocates a unique ID which can be used by the implementation to construct an RID. This is used mainly from native extensions to implement servers.
+ */
+export function ridAllocateId(): number { return _C(0x4029cb80d8n, 10112) as number; }
+
+/**
+ * Creates an RID from a `base`. This is used mainly from native extensions to build servers.
+ */
+export function ridFromInt64(base: number): RID { return _C(0x12e1cc4239a4n, 10113, base) as RID; }
+
+/**
+ * Returns `true`, for value types, if `a` and `b` share the same value. Returns `true`, for reference types, if the references of `a` and `b` are the same.
+ *
+ * ```text
+ *
+ * # Vector2 is a value type
+ * var vec2_a = Vector2(0, 0)
+ * var vec2_b = Vector2(0, 0)
+ * var vec2_c = Vector2(1, 1)
+ * is_same(vec2_a, vec2_a)  # true
+ * is_same(vec2_a, vec2_b)  # true
+ * is_same(vec2_a, vec2_c)  # false
+ *
+ * # Array is a reference type
+ * var arr_a = []
+ * var arr_b = []
+ * is_same(arr_a, arr_a)  # true
+ * is_same(arr_a, arr_b)  # false
+ *
+ * ```
+ *
+ * These are {@link Variant} value types: `null`, {@link bool}, {@link int}, {@link float}, {@link String}, {@link StringName}, {@link Vector2}, {@link Vector2i}, {@link Vector3}, {@link Vector3i}, {@link Vector4}, {@link Vector4i}, {@link Rect2}, {@link Rect2i}, {@link Transform2D}, {@link Transform3D}, {@link Plane}, {@link Quaternion}, {@link AABB}, {@link Basis}, {@link Projection}, {@link Color}, {@link NodePath}, {@link RID}, {@link Callable} and {@link Signal}.
+ * These are {@link Variant} reference types: {@link Object}, {@link Dictionary}, {@link Array}, {@link PackedByteArray}, {@link PackedInt32Array}, {@link PackedInt64Array}, {@link PackedFloat32Array}, {@link PackedFloat64Array}, {@link PackedStringArray}, {@link PackedVector2Array}, {@link PackedVector3Array}, {@link PackedVector4Array}, and {@link PackedColorArray}.
+ */
+export function isSame(a: Variant, b: Variant): boolean { return _C(0x7ff822540218a4n, 8259, a, b) as boolean; }
+
+