@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/utility-functions.ts

@@ -14,7 +14,7 @@ import type { Variant, PackedByteArray, PackedInt64Array, RID } from './heap-typ
  *
  * ```
  */
-export function sin(angleRad: number): number { return _C(0x18617f8e90b3n, 13606, angleRad) as number; }
+export function sin(angleRad: number): number { return _C(0n, 13606, angleRad) as number; }
 
 /**
  * Returns the cosine of angle `angleRad` in radians.
@@ -27,7 +27,7 @@ export function sin(angleRad: number): number { return _C(0x18617f8e90b3n, 13606
  *
  * ```
  */
-export function cos(angleRad: number): number { return _C(0x18617f8e90b3n, 2500, angleRad) as number; }
+export function cos(angleRad: number): number { return _C(0n, 2500, angleRad) as number; }
 
 /**
  * Returns the tangent of angle `angleRad` in radians.
@@ -38,7 +38,7 @@ export function cos(angleRad: number): number { return _C(0x18617f8e90b3n, 2500,
  *
  * ```
  */
-export function tan(angleRad: number): number { return _C(0x18617f8e90b3n, 14117, angleRad) as number; }
+export function tan(angleRad: number): number { return _C(0n, 14117, angleRad) as number; }
 
 /**
  * Returns the hyperbolic sine of `x`.
@@ -50,7 +50,7 @@ export function tan(angleRad: number): number { return _C(0x18617f8e90b3n, 14117
  *
  * ```
  */
-export function sinh(x: number): number { return _C(0x18617f8e90b3n, 13607, x) as number; }
+export function sinh(x: number): number { return _C(0n, 13607, x) as number; }
 
 /**
  * Returns the hyperbolic cosine of `x` in radians.
@@ -61,7 +61,7 @@ export function sinh(x: number): number { return _C(0x18617f8e90b3n, 13607, x) a
  *
  * ```
  */
-export function cosh(x: number): number { return _C(0x18617f8e90b3n, 2501, x) as number; }
+export function cosh(x: number): number { return _C(0n, 2501, x) as number; }
 
 /**
  * Returns the hyperbolic tangent of `x`.
@@ -73,7 +73,7 @@ export function cosh(x: number): number { return _C(0x18617f8e90b3n, 2501, x) as
  *
  * ```
  */
-export function tanh(x: number): number { return _C(0x18617f8e90b3n, 14122, x) as number; }
+export function tanh(x: number): number { return _C(0n, 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`.
@@ -85,7 +85,7 @@ export function tanh(x: number): number { return _C(0x18617f8e90b3n, 14122, x) a
  *
  * ```
  */
-export function asin(x: number): number { return _C(0x18617f8e90b3n, 1600, x) as number; }
+export function asin(x: number): number { return _C(0n, 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`.
@@ -97,7 +97,7 @@ export function asin(x: number): number { return _C(0x18617f8e90b3n, 1600, x) as
  *
  * ```
  */
-export function acos(x: number): number { return _C(0x18617f8e90b3n, 1152, x) as number; }
+export function acos(x: number): number { return _C(0n, 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.
@@ -111,7 +111,7 @@ export function acos(x: number): number { return _C(0x18617f8e90b3n, 1152, x) as
  *
  * 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; }
+export function atan(x: number): number { return _C(0n, 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.
@@ -123,7 +123,7 @@ export function atan(x: number): number { return _C(0x18617f8e90b3n, 1606, x) as
  *
  * ```
  */
-export function atan2(y: number, x: number): number { return _C(0x61862058054can, 1607, y, x) as number; }
+export function atan2(y: number, x: number): number { return _C(0n, 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.
@@ -135,7 +135,7 @@ export function atan2(y: number, x: number): number { return _C(0x61862058054can
  *
  * ```
  */
-export function asinh(x: number): number { return _C(0x18617f8e90b3n, 1601, x) as number; }
+export function asinh(x: number): number { return _C(0n, 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`.
@@ -149,7 +149,7 @@ export function asinh(x: number): number { return _C(0x18617f8e90b3n, 1601, x) a
  *
  * ```
  */
-export function acosh(x: number): number { return _C(0x18617f8e90b3n, 1153, x) as number; }
+export function acosh(x: number): number { return _C(0n, 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).
@@ -165,7 +165,7 @@ export function acosh(x: number): number { return _C(0x18617f8e90b3n, 1153, x) a
  *
  * ```
  */
-export function atanh(x: number): number { return _C(0x18617f8e90b3n, 1608, x) as number; }
+export function atanh(x: number): number { return _C(0n, 1608, x) as number; }
 
 /**
  * Returns the square root of `x`, where `x` is a non-negative number.
@@ -180,7 +180,7 @@ export function atanh(x: number): number { return _C(0x18617f8e90b3n, 1608, x) a
  *
  * **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; }
+export function sqrt(x: number): number { return _C(0n, 13799, x) as number; }
 
 /**
  * Returns the floating-point remainder of `x` divided by `y`, keeping the sign of `x`.
@@ -193,7 +193,7 @@ export function sqrt(x: number): number { return _C(0x18617f8e90b3n, 13799, x) a
  *
  * For the integer remainder operation, use the `%` operator.
  */
-export function fmod(x: number, y: number): number { return _C(0x61862058054can, 3345, x, y) as number; }
+export function fmod(x: number, y: number): number { return _C(0n, 3345, x, y) as number; }
 
 /**
  * Returns the floating-point modulus of `x` divided by `y`, wrapping equally in positive and negative.
@@ -222,7 +222,7 @@ export function fmod(x: number, y: number): number { return _C(0x61862058054can,
  *
  * ```
  */
-export function fposmod(x: number, y: number): number { return _C(0x61862058054can, 3555, x, y) as number; }
+export function fposmod(x: number, y: number): number { return _C(0n, 3555, x, y) as number; }
 
 /**
  * Returns the integer modulus of `x` divided by `y` that wraps equally in positive and negative.
@@ -250,7 +250,7 @@ export function fposmod(x: number, y: number): number { return _C(0x61862058054c
  *
  * ```
  */
-export function posmod(x: number, y: number): number { return _C(0x41042bac4b5fan, 9518, x, y) as number; }
+export function posmod(x: number, y: number): number { return _C(0n, 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}.
@@ -265,20 +265,20 @@ export function posmod(x: number, y: number): number { return _C(0x41042bac4b5fa
  * 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; }
+export function floor(x: Variant): Variant { return _C(0n, 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; }
+export function floorf(x: number): number { return _C(0n, 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; }
+export function floori(x: number): number { return _C(0n, 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}.
@@ -293,19 +293,19 @@ export function floori(x: number): number { return _C(0x1841a5b9ecaan, 3342, x)
  * 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; }
+export function ceil(x: Variant): Variant { return _C(0n, 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; }
+export function ceilf(x: number): number { return _C(0n, 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; }
+export function ceili(x: number): number { return _C(0n, 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}.
@@ -321,19 +321,19 @@ export function ceili(x: number): number { return _C(0x1841a5b9ecaan, 2158, x) a
  * 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; }
+export function round(x: Variant): Variant { return _C(0n, 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; }
+export function roundf(x: number): number { return _C(0n, 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; }
+export function roundi(x: number): number { return _C(0n, 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}.
@@ -362,7 +362,7 @@ export function roundi(x: number): number { return _C(0x1841a5b9ecaan, 10170, x)
  *
  * **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; }
+export function abs(x: Variant): Variant { return _C(0n, 1053, x) as Variant; }
 
 /**
  * Returns the absolute value of float parameter `x` (i.e. positive value).
@@ -374,7 +374,7 @@ export function abs(x: Variant): Variant { return _C(0x1ffe10048e204n, 1053, x)
  *
  * ```
  */
-export function absf(x: number): number { return _C(0x18617f8e90b3n, 1054, x) as number; }
+export function absf(x: number): number { return _C(0n, 1054, x) as number; }
 
 /**
  * Returns the absolute value of int parameter `x` (i.e. positive value).
@@ -386,7 +386,7 @@ export function absf(x: number): number { return _C(0x18617f8e90b3n, 1054, x) as
  *
  * ```
  */
-export function absi(x: number): number { return _C(0x1041809616d0n, 1055, x) as number; }
+export function absi(x: number): number { return _C(0n, 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.
@@ -405,7 +405,7 @@ export function absi(x: number): number { return _C(0x1041809616d0n, 1055, x) as
  *
  * **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; }
+export function sign(x: Variant): Variant { return _C(0n, 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.
@@ -419,7 +419,7 @@ export function sign(x: Variant): Variant { return _C(0x1ffe10048e204n, 13597, x
  *
  * ```
  */
-export function signf(x: number): number { return _C(0x18617f8e90b3n, 13599, x) as number; }
+export function signf(x: number): number { return _C(0n, 13599, x) as number; }
 
 /**
  * Returns `-1` if `x` is negative, `1` if `x` is positive, and `0` if `x` is zero.
@@ -432,7 +432,7 @@ export function signf(x: number): number { return _C(0x18617f8e90b3n, 13599, x)
  *
  * ```
  */
-export function signi(x: number): number { return _C(0x1041809616d0n, 13600, x) as number; }
+export function signi(x: number): number { return _C(0n, 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.
@@ -450,7 +450,7 @@ export function signi(x: number): number { return _C(0x1041809616d0n, 13600, x)
  * 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; }
+export function snapped(x: Variant, step: Variant): Variant { return _C(0n, 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.
@@ -463,7 +463,7 @@ export function snapped(x: Variant, step: Variant): Variant { return _C(0x7fffe2
  *
  * ```
  */
-export function snappedf(x: number, step: number): number { return _C(0x61862058054can, 13675, x, step) as number; }
+export function snappedf(x: number, step: number): number { return _C(0n, 13675, x, step) as number; }
 
 /**
  * Returns the multiple of `step` that is the closest to `x`.
@@ -476,7 +476,7 @@ export function snappedf(x: number, step: number): number { return _C(0x61862058
  *
  * ```
  */
-export function snappedi(x: number, step: number): number { return _C(0x41842d4d572f9n, 13676, x, step) as number; }
+export function snappedi(x: number, step: number): number { return _C(0n, 13676, x, step) as number; }
 
 /**
  * Returns the result of `base` raised to the power of `exp`.
@@ -489,7 +489,7 @@ export function snappedi(x: number, step: number): number { return _C(0x41842d4d
  *
  * ```
  */
-export function pow(base: number, exp: number): number { return _C(0x61862058054can, 9522, base, exp) as number; }
+export function pow(base: number, exp: number): number { return _C(0n, 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.
@@ -503,7 +503,7 @@ export function pow(base: number, exp: number): number { return _C(0x61862058054
  *
  * **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; }
+export function log(x: number): number { return _C(0n, 8704, x) as number; }
 
 /**
  * The natural exponential function. It raises the mathematical constant *e* to the power of `x` and returns it.
@@ -516,35 +516,35 @@ export function log(x: number): number { return _C(0x18617f8e90b3n, 8704, x) as
  *
  * ```
  */
-export function exp(x: number): number { return _C(0x18617f8e90b3n, 3185, x) as number; }
+export function exp(x: number): number { return _C(0n, 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; }
+export function isNan(x: number): boolean { return _C(0n, 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; }
+export function isInf(x: number): boolean { return _C(0n, 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; }
+export function isEqualApprox(a: number, b: number): boolean { return _C(0n, 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; }
+export function isZeroApprox(x: number): boolean { return _C(0n, 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; }
+export function isFinite(x: number): boolean { return _C(0n, 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:
@@ -564,7 +564,7 @@ export function isFinite(x: number): boolean { return _C(0x1821d4bde6edn, 7951,
  * [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; }
+export function ease(x: number, curve: number): number { return _C(0n, 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.
@@ -577,7 +577,7 @@ export function ease(x: number, curve: number): number { return _C(0x61862058054
  *
  * ```
  */
-export function stepDecimals(x: number): number { return _C(0x1841a5b9ecaan, 13862, x) as number; }
+export function stepDecimals(x: number): number { return _C(0n, 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`.
@@ -592,7 +592,7 @@ export function stepDecimals(x: number): number { return _C(0x1841a5b9ecaan, 138
  * 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; }
+export function lerp(from: Variant, to: Variant, weight: Variant): Variant { return _C(0n, 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.
@@ -605,44 +605,44 @@ export function lerp(from: Variant, to: Variant, weight: Variant): Variant { ret
  *
  * 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; }
+export function lerpf(from: number, to: number, weight: number): number { return _C(0n, 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; }
+export function cubicInterpolate(from: number, to: number, pre: number, post: number, weight: number): number { return _C(0n, 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; }
+export function cubicInterpolateAngle(from: number, to: number, pre: number, post: number, weight: number): number { return _C(0n, 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; }
+export function cubicInterpolateInTime(from: number, to: number, pre: number, post: number, weight: number, toT: number, preT: number, postT: number): number { return _C(0n, 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; }
+export function cubicInterpolateAngleInTime(from: number, to: number, pre: number, post: number, weight: number, toT: number, preT: number, postT: number): number { return _C(0n, 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; }
+export function bezierInterpolate(start: number, control1: number, control2: number, end: number, t: number): number { return _C(0n, 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; }
+export function bezierDerivative(start: number, control1: number, control2: number, end: number, t: number): number { return _C(0n, 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; }
+export function angleDifference(from: number, to: number): number { return _C(0n, 1450, from, to) as number; }
 
 /**
  * Linearly interpolates between two angles (in radians) by a `weight` value between 0.0 and 1.0.
@@ -662,7 +662,7 @@ export function angleDifference(from: number, to: number): number { return _C(0x
  *
  * **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; }
+export function lerpAngle(from: number, to: number, weight: number): number { return _C(0n, 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.
@@ -681,7 +681,7 @@ export function lerpAngle(from: number, to: number, weight: number): number { re
  *
  * 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; }
+export function inverseLerp(from: number, to: number, weight: number): number { return _C(0n, 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.
@@ -695,7 +695,7 @@ export function inverseLerp(from: number, to: number, weight: number): number {
  * 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; }
+export function remap(value: number, istart: number, istop: number, ostart: number, ostop: number): number { return _C(0n, 9875, value, istart, istop, ostart, ostop) as number; }
 
 /**
  * Returns a smooth cubic Hermite interpolation between `0` and `1`.
@@ -716,7 +716,7 @@ export function remap(value: number, istart: number, istop: number, ostart: numb
  * [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; }
+export function smoothstep(from: number, to: number, x: number): number { return _C(0n, 13670, from, to, x) as number; }
 
 /**
  * Moves `from` toward `to` by the `delta` amount. Will not go past `to`.
@@ -731,14 +731,14 @@ export function smoothstep(from: number, to: number, x: number): number { return
  *
  * ```
  */
-export function moveToward(from: number, to: number, delta: number): number { return _C(0x18618633b8a0538n, 9004, from, to, delta) as number; }
+export function moveToward(from: number, to: number, delta: number): number { return _C(0n, 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; }
+export function rotateToward(from: number, to: number, delta: number): number { return _C(0n, 10140, from, to, delta) as number; }
 
 /**
  * Converts an angle expressed in degrees to radians.
@@ -749,7 +749,7 @@ export function rotateToward(from: number, to: number, delta: number): number {
  *
  * ```
  */
-export function degToRad(deg: number): number { return _C(0x18617f8e90b3n, 2715, deg) as number; }
+export function degToRad(deg: number): number { return _C(0n, 2715, deg) as number; }
 
 /**
  * Converts an angle expressed in radians to degrees.
@@ -762,7 +762,7 @@ export function degToRad(deg: number): number { return _C(0x18617f8e90b3n, 2715,
  *
  * ```
  */
-export function radToDeg(rad: number): number { return _C(0x18617f8e90b3n, 9702, rad) as number; }
+export function radToDeg(rad: number): number { return _C(0n, 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.
@@ -774,12 +774,12 @@ export function radToDeg(rad: number): number { return _C(0x18617f8e90b3n, 9702,
  *
  * ```
  */
-export function linearToDb(lin: number): number { return _C(0x18617f8e90b3n, 8633, lin) as number; }
+export function linearToDb(lin: number): number { return _C(0n, 8633, lin) as number; }
 
 /**
  * Converts from decibels to linear energy (audio).
  */
-export function dbToLinear(db: number): number { return _C(0x18617f8e90b3n, 2656, db) as number; }
+export function dbToLinear(db: number): number { return _C(0n, 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.
@@ -798,7 +798,7 @@ export function dbToLinear(db: number): number { return _C(0x18617f8e90b3n, 2656
  *
  * ```
  */
-export function wrap(value: Variant, min: Variant, max: Variant): Variant { return _C(0x1fffffe3ca0d616en, 14926, value, min, max) as Variant; }
+export function wrap(value: Variant, min: Variant, max: Variant): Variant { return _C(0n, 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.
@@ -818,7 +818,7 @@ export function wrap(value: Variant, min: Variant, max: Variant): Variant { retu
  *
  * ```
  */
-export function wrapi(value: number, min: number, max: number): number { return _C(0x104104326c2b897n, 14933, value, min, max) as number; }
+export function wrapi(value: number, min: number, max: number): number { return _C(0n, 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.
@@ -848,7 +848,7 @@ export function wrapi(value: number, min: number, max: number): number { return
  *
  * **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; }
+export function wrapf(value: number, min: number, max: number): number { return _C(0n, 14932, value, min, max) as number; }
 
 /**
  * Returns the maximum of the given numeric values. This function can take any number of arguments.
@@ -861,7 +861,7 @@ export function wrapf(value: number, min: number, max: number): number { return
  *
  * **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; }
+export function max(arg1: Variant, arg2: Variant): Variant { return _C(0n, 8804, arg1, arg2) as Variant; }
 
 /**
  * Returns the maximum of two {@link int} values.
@@ -873,7 +873,7 @@ export function max(arg1: Variant, arg2: Variant): Variant { return _C(0x7fffe2e
  *
  * ```
  */
-export function maxi(a: number, b: number): number { return _C(0x41042bac4b5fan, 8840, a, b) as number; }
+export function maxi(a: number, b: number): number { return _C(0n, 8840, a, b) as number; }
 
 /**
  * Returns the maximum of two {@link float} values.
@@ -885,7 +885,7 @@ export function maxi(a: number, b: number): number { return _C(0x41042bac4b5fan,
  *
  * ```
  */
-export function maxf(a: number, b: number): number { return _C(0x61862058054can, 8839, a, b) as number; }
+export function maxf(a: number, b: number): number { return _C(0n, 8839, a, b) as number; }
 
 /**
  * Returns the minimum of the given numeric values. This function can take any number of arguments.
@@ -898,7 +898,7 @@ export function maxf(a: number, b: number): number { return _C(0x61862058054can,
  *
  * **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; }
+export function min(arg1: Variant, arg2: Variant): Variant { return _C(0n, 8910, arg1, arg2) as Variant; }
 
 /**
  * Returns the minimum of two {@link int} values.
@@ -910,7 +910,7 @@ export function min(arg1: Variant, arg2: Variant): Variant { return _C(0x7fffe2e
  *
  * ```
  */
-export function mini(a: number, b: number): number { return _C(0x41042bac4b5fan, 8922, a, b) as number; }
+export function mini(a: number, b: number): number { return _C(0n, 8922, a, b) as number; }
 
 /**
  * Returns the minimum of two {@link float} values.
@@ -922,7 +922,7 @@ export function mini(a: number, b: number): number { return _C(0x41042bac4b5fan,
  *
  * ```
  */
-export function minf(a: number, b: number): number { return _C(0x61862058054can, 8921, a, b) as number; }
+export function minf(a: number, b: number): number { return _C(0n, 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.
@@ -940,7 +940,7 @@ export function minf(a: number, b: number): number { return _C(0x61862058054can,
  * **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; }
+export function clamp(value: Variant, min: Variant, max: Variant): Variant { return _C(0n, 2202, value, min, max) as Variant; }
 
 /**
  * Clamps the `value`, returning an {@link int} not less than `min` and not more than `max`.
@@ -955,7 +955,7 @@ export function clamp(value: Variant, min: Variant, max: Variant): Variant { ret
  *
  * ```
  */
-export function clampi(value: number, min: number, max: number): number { return _C(0x104104326c2b897n, 2206, value, min, max) as number; }
+export function clampi(value: number, min: number, max: number): number { return _C(0n, 2206, value, min, max) as number; }
 
 /**
  * Clamps the `value`, returning a {@link float} not less than `min` and not more than `max`.
@@ -970,7 +970,7 @@ export function clampi(value: number, min: number, max: number): number { return
  *
  * ```
  */
-export function clampf(value: number, min: number, max: number): number { return _C(0x18618633b8a0538n, 2205, value, min, max) as number; }
+export function clampf(value: number, min: number, max: number): number { return _C(0n, 2205, value, min, max) as number; }
 
 /**
  * Returns the smallest integer power of 2 that is greater than or equal to `value`.
@@ -988,7 +988,7 @@ export function clampf(value: number, min: number, max: number): number { return
  *
  * **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; }
+export function nearestPo2(value: number): number { return _C(0n, 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.
@@ -1008,13 +1008,13 @@ export function nearestPo2(value: number): number { return _C(0x1041809616d0n, 9
  *
  * ```
  */
-export function pingpong(value: number, length: number): number { return _C(0x61862058054can, 9430, value, length) as number; }
+export function pingpong(value: number, length: number): number { return _C(0n, 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); }
+export function randomize(): void { _C(0n, 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).
@@ -1029,7 +1029,7 @@ export function randomize(): void { _C(0x64d59d5cn, 9729); }
  *
  * ```
  */
-export function randi(): number { return _C(0x4029cb80d8n, 9724) as number; }
+export function randi(): number { return _C(0n, 9724) as number; }
 
 /**
  * Returns a random floating-point value between `0.0` and `1.0` (inclusive).
@@ -1041,7 +1041,7 @@ export function randi(): number { return _C(0x4029cb80d8n, 9724) as number; }
  *
  * ```
  */
-export function randf(): number { return _C(0x607c594f85n, 9721) as number; }
+export function randf(): number { return _C(0n, 9721) as number; }
 
 /**
  * Returns a random signed 32-bit integer between `from` and `to` (inclusive). If `to` is lesser than `from`, they are swapped.
@@ -1054,7 +1054,7 @@ export function randf(): number { return _C(0x607c594f85n, 9721) as number; }
  *
  * ```
  */
-export function randiRange(from: number, to: number): number { return _C(0x41042bac4b5fan, 9725, from, to) as number; }
+export function randiRange(from: number, to: number): number { return _C(0n, 9725, from, to) as number; }
 
 /**
  * Returns a random floating-point value between `from` and `to` (inclusive).
@@ -1067,13 +1067,13 @@ export function randiRange(from: number, to: number): number { return _C(0x41042
  *
  * ```
  */
-export function randfRange(from: number, to: number): number { return _C(0x61862058054can, 9722, from, to) as number; }
+export function randfRange(from: number, to: number): number { return _C(0n, 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; }
+export function randfn(mean: number, deviation: number): number { return _C(0n, 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.
@@ -1090,7 +1090,7 @@ export function randfn(mean: number, deviation: number): number { return _C(0x61
  *
  * ```
  */
-export function seed(base: number): void { _C(0x100116d310e5n, 10342, base); }
+export function seed(base: number): void { _C(0n, 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.
@@ -1105,13 +1105,13 @@ export function seed(base: number): void { _C(0x100116d310e5n, 10342, base); }
  *
  * ```
  */
-export function randFromSeed(seed: number): PackedInt64Array { return _C(0x13e152e9f285n, 9719, seed) as PackedInt64Array; }
+export function randFromSeed(seed: number): PackedInt64Array { return _C(0n, 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; }
+export function weakref(obj: Variant): Variant { return _C(0n, 14843, obj) as Variant; }
 
 /**
  * Returns the internal type of the given `variable`, using the {@link Variant.Type} values.
@@ -1130,7 +1130,7 @@ export function weakref(obj: Variant): Variant { return _C(0x1ffe10048e204n, 148
  *
  * See also {@link typeString}.
  */
-export function _typeof(variable: Variant): number { return _C(0x1f8411374d042n, 14457, variable) as number; }
+export function _typeof(variable: Variant): number { return _C(0n, 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}.
@@ -1147,7 +1147,7 @@ export function _typeof(variable: Variant): number { return _C(0x1f8411374d042n,
  *
  * ```
  */
-export function typeConvert(variant: Variant, type: number): Variant { return _C(0x5ffe29236c45an, 14454, variant, type) as Variant; }
+export function typeConvert(variant: Variant, type: number): Variant { return _C(0n, 14454, variant, type) as Variant; }
 
 /**
  * Converts one or more arguments of any {@link Variant} type to a {@link String} in the best way possible.
@@ -1161,7 +1161,7 @@ export function typeConvert(variant: Variant, type: number): Variant { return _C
  *
  * ```
  */
-export function str(arg1: Variant): string { return _C(0x1f88101f0f758n, 13887, arg1) as string; }
+export function str(arg1: Variant): string { return _C(0n, 13887, arg1) as string; }
 
 /**
  * Returns a human-readable name for the given {@link Error} code.
@@ -1175,7 +1175,7 @@ export function str(arg1: Variant): string { return _C(0x1f88101f0f758n, 13887,
  *
  * ```
  */
-export function errorString(error: number): string { return _C(0x108138309612n, 3166, error) as string; }
+export function errorString(error: number): string { return _C(0n, 3166, error) as string; }
 
 /**
  * Returns a human-readable name of the given `type`, using the {@link Variant.Type} values.
@@ -1190,7 +1190,7 @@ export function errorString(error: number): string { return _C(0x108138309612n,
  *
  * See also {@link typeof}.
  */
-export function typeString(type: number): string { return _C(0x108138309612n, 14456, type) as string; }
+export function typeString(type: number): string { return _C(0n, 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.
@@ -1207,7 +1207,7 @@ export function typeString(type: number): string { return _C(0x108138309612n, 14
  *
  * **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); }
+export function print(arg1: Variant): void { _C(0n, 9554, arg1); }
 
 /**
  * Converts one or more arguments of any type to string in the best way possible and prints them to the console.
@@ -1225,7 +1225,7 @@ export function print(arg1: Variant): void { _C(0x1f8019de0016en, 9554, arg1); }
  * **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); }
+export function printRich(arg1: Variant): void { _C(0n, 9557, arg1); }
 
 /**
  * Prints one or more arguments to strings in the best way possible to standard error line.
@@ -1237,7 +1237,7 @@ export function printRich(arg1: Variant): void { _C(0x1f8019de0016en, 9557, arg1
  *
  * ```
  */
-export function printerr(arg1: Variant): void { _C(0x1f8019de0016en, 9562, arg1); }
+export function printerr(arg1: Variant): void { _C(0n, 9562, arg1); }
 
 /**
  * Prints one or more arguments to the console with a tab between each argument.
@@ -1249,7 +1249,7 @@ export function printerr(arg1: Variant): void { _C(0x1f8019de0016en, 9562, arg1)
  *
  * ```
  */
-export function printt(arg1: Variant): void { _C(0x1f8019de0016en, 9565, arg1); }
+export function printt(arg1: Variant): void { _C(0n, 9565, arg1); }
 
 /**
  * Prints one or more arguments to the console with a space between each argument.
@@ -1261,7 +1261,7 @@ export function printt(arg1: Variant): void { _C(0x1f8019de0016en, 9565, arg1);
  *
  * ```
  */
-export function prints(arg1: Variant): void { _C(0x1f8019de0016en, 9564, arg1); }
+export function prints(arg1: Variant): void { _C(0n, 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.
@@ -1277,12 +1277,12 @@ export function prints(arg1: Variant): void { _C(0x1f8019de0016en, 9564, arg1);
  *
  * ```
  */
-export function printraw(arg1: Variant): void { _C(0x1f8019de0016en, 9563, arg1); }
+export function printraw(arg1: Variant): void { _C(0n, 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); }
+export function printVerbose(arg1: Variant): void { _C(0n, 9561, arg1); }
 
 /**
  * Pushes an error message to Godot's built-in debugger and to the OS terminal.
@@ -1298,7 +1298,7 @@ export function printVerbose(arg1: Variant): void { _C(0x1f8019de0016en, 9561, a
  *
  * **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); }
+export function pushError(arg1: Variant): void { _C(0n, 9640, arg1); }
 
 /**
  * Pushes a warning message to Godot's built-in debugger and to the OS terminal.
@@ -1310,7 +1310,7 @@ export function pushError(arg1: Variant): void { _C(0x1f8019de0016en, 9640, arg1
  *
  * ```
  */
-export function pushWarning(arg1: Variant): void { _C(0x1f8019de0016en, 9663, arg1); }
+export function pushWarning(arg1: Variant): void { _C(0n, 9663, arg1); }
 
 /**
  * Converts a {@link Variant} `variable` to a formatted {@link String} that can then be parsed using {@link strToVar}.
@@ -1338,7 +1338,7 @@ export function pushWarning(arg1: Variant): void { _C(0x1f8019de0016en, 9663, ar
  *
  * **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; }
+export function varToStr(variable: Variant): string { return _C(0n, 14675, variable) as string; }
 
 /**
  * Converts a formatted `string` that was returned by {@link varToStr} to the original {@link Variant}.
@@ -1352,32 +1352,32 @@ export function varToStr(variable: Variant): string { return _C(0x1f88133a7a7c7n
  *
  * ```
  */
-export function strToVar(string: string): Variant { return _C(0x27e170bdf9fbn, 13888, string) as Variant; }
+export function strToVar(string: string): Variant { return _C(0n, 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; }
+export function varToBytes(variable: Variant): PackedByteArray { return _C(0n, 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; }
+export function bytesToVar(bytes: PackedByteArray): Variant { return _C(0n, 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; }
+export function varToBytesWithObjects(variable: Variant): PackedByteArray { return _C(0n, 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; }
+export function bytesToVarWithObjects(bytes: PackedByteArray): Variant { return _C(0n, 1964, bytes) as Variant; }
 
 /**
  * Returns the integer hash of the passed `variable`.
@@ -1389,7 +1389,7 @@ export function bytesToVarWithObjects(bytes: PackedByteArray): Variant { return
  *
  * ```
  */
-export function hash(variable: Variant): number { return _C(0x1f8411374d042n, 7487, variable) as number; }
+export function hash(variable: Variant): number { return _C(0n, 7487, variable) as number; }
 
 /**
  * Returns the {@link Object} that corresponds to `instanceId`. All Objects have a unique instance ID. See also {@link Object.getInstanceId}.
@@ -1406,27 +1406,27 @@ export function hash(variable: Variant): number { return _C(0x1f8411374d042n, 74
  *
  * ```
  */
-export function instanceFromId(instanceId: number): Object { return _C(0x130144f1c26cn, 7646, instanceId) as Object; }
+export function instanceFromId(instanceId: number): Object { return _C(0n, 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; }
+export function isInstanceIdValid(id: number): boolean { return _C(0n, 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; }
+export function isInstanceValid(instance: Variant): boolean { return _C(0n, 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; }
+export function ridAllocateId(): number { return _C(0n, 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; }
+export function ridFromInt64(base: number): RID { return _C(0n, 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.
@@ -1452,6 +1452,6 @@ export function ridFromInt64(base: number): RID { return _C(0x12e1cc4239a4n, 101
  * 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; }
+export function isSame(a: Variant, b: Variant): boolean { return _C(0n, 8259, a, b) as boolean; }