@ringozz/godot 0.1.0

package/gen/value-types/Vector4.ts

@@ -0,0 +1,285 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { GodotVar, _C, _R, _get, _set } from '../../src/runtime.ts';
+import type { GodotArray, GodotDictionary, PackedVector4Array, Variant } from '../heap-types/index.ts';
+import type { Projection, Vector4i } from '../value-types/index.ts';
+
+/**
+ * A 4-element structure that can be used to represent 4D coordinates or any other quadruplet of numeric values.
+ * It uses floating-point coordinates. By default, these floating-point values use 32-bit precision, unlike {@link float} which is always 64-bit. If double precision is needed, compile the engine with the option `precision=double`.
+ * See {@link Vector4i} for its integer counterpart.
+ * **Note:** In a boolean context, a Vector4 will evaluate to `false` if it's equal to `Vector4(0, 0, 0, 0)`. Otherwise, a Vector4 will always evaluate to `true`.
+ */
+export class Vector4 extends GodotVar {
+    /**
+     * The vector's X component. Also accessible by using the index position `[0]`.
+     */
+    get x(): number { return _get(this, 14941) as number; }
+    set x(v: number) { _set(this, 14941, v); }
+
+    /**
+     * The vector's Y component. Also accessible by using the index position `[1]`.
+     */
+    get y(): number { return _get(this, 14952) as number; }
+    set y(v: number) { _set(this, 14952, v); }
+
+    /**
+     * The vector's Z component. Also accessible by using the index position `[2]`.
+     */
+    get z(): number { return _get(this, 14956) as number; }
+    set z(v: number) { _set(this, 14956, v); }
+
+    /**
+     * The vector's W component. Also accessible by using the index position `[3]`.
+     */
+    get w(): number { return _get(this, 14833) as number; }
+    set w(v: number) { _set(this, 14833, v); }
+
+    constructor();
+    constructor(from: Vector4);
+    constructor(from: Vector4i);
+    constructor(x: number, y: number, z: number, w: number);
+    constructor(...args: any[]) { super(12, ...args); }
+
+    /**
+     * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_W}.
+     */
+    minAxisIndex(): number { return _C(this, 8911) as number; }
+
+    /**
+     * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
+     */
+    maxAxisIndex(): number { return _C(this, 8806) as number; }
+
+    /**
+     * Returns the length (magnitude) of this vector.
+     */
+    length(): number { return _C(this, 8546) as number; }
+
+    /**
+     * Returns the squared length (squared magnitude) of this vector.
+     * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+     */
+    lengthSquared(): number { return _C(this, 8547) as number; }
+
+    /**
+     * Returns a new vector with all components in absolute values (i.e. positive).
+     */
+    abs(): Vector4 { return _C(this, 1053) as Vector4; }
+
+    /**
+     * Returns a new vector with each component set to `1.0` if it's positive, `-1.0` if it's negative, and `0.0` if it's zero. The result is identical to calling {@link sign} on each component.
+     */
+    sign(): Vector4 { return _C(this, 13597) as Vector4; }
+
+    /**
+     * Returns a new vector with all components rounded down (towards negative infinity).
+     */
+    floor(): Vector4 { return _C(this, 3335) as Vector4; }
+
+    /**
+     * Returns a new vector with all components rounded up (towards positive infinity).
+     */
+    ceil(): Vector4 { return _C(this, 2156) as Vector4; }
+
+    /**
+     * Returns a new vector with all components rounded to the nearest integer, with halfway cases rounded away from zero.
+     */
+    round(): Vector4 { return _C(this, 10166) as Vector4; }
+
+    /**
+     * Returns the result of the linear interpolation between this vector and `to` by amount `weight`. `weight` is on the range of `0.0` to `1.0`, representing the amount of interpolation.
+     */
+    lerp(to: Vector4, weight: number): Vector4 { return _C(this, 8548, to, weight) as Vector4; }
+
+    /**
+     * Performs a cubic interpolation between this vector and `b` using `preA` and `postB` as handles, and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
+     */
+    cubicInterpolate(b: Vector4, preA: Vector4, postB: Vector4, weight: number): Vector4 { return _C(this, 2590, b, preA, postB, weight) as Vector4; }
+
+    /**
+     * Performs a cubic interpolation between this vector and `b` using `preA` and `postB` as handles, and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
+     * It can perform smoother interpolation than {@link cubicInterpolate} by the time values.
+     */
+    cubicInterpolateInTime(b: Vector4, preA: Vector4, postB: Vector4, weight: number, bT: number, preAT: number, postBT: number): Vector4 { return _C(this, 2593, b, preA, postB, weight, bT, preAT, postBT) as Vector4; }
+
+    /**
+     * Returns a vector composed of the {@link fposmod} of this vector's components and `mod`.
+     */
+    posmod(mod: number): Vector4 { return _C(this, 9518, mod) as Vector4; }
+
+    /**
+     * Returns a vector composed of the {@link fposmod} of this vector's components and `modv`'s components.
+     */
+    posmodv(modv: Vector4): Vector4 { return _C(this, 9519, modv) as Vector4; }
+
+    /**
+     * Returns a new vector with each component snapped to the nearest multiple of the corresponding component in `step`. This can also be used to round the components to an arbitrary number of decimals.
+     */
+    snapped(step: Vector4): Vector4 { return _C(this, 13674, step) as Vector4; }
+
+    /**
+     * Returns a new vector with each component snapped to the nearest multiple of `step`. This can also be used to round the components to an arbitrary number of decimals.
+     */
+    snappedf(step: number): Vector4 { return _C(this, 13675, step) as Vector4; }
+
+    /**
+     * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
+     */
+    clamp(min: Vector4, max: Vector4): Vector4 { return _C(this, 2202, min, max) as Vector4; }
+
+    /**
+     * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
+     */
+    clampf(min: number, max: number): Vector4 { return _C(this, 2205, min, max) as Vector4; }
+
+    /**
+     * Returns the result of scaling the vector to unit length. Equivalent to `v / v.length()`. Returns `(0, 0, 0, 0)` if `v.length() == 0`. See also {@link isNormalized}.
+     * **Note:** This function may return incorrect values if the input vector length is near zero.
+     */
+    normalized(): Vector4 { return _C(this, 9103) as Vector4; }
+
+    /**
+     * Returns `true` if the vector is normalized, i.e. its length is approximately equal to 1.
+     */
+    isNormalized(): boolean { return _C(this, 8138) as boolean; }
+
+    /**
+     * Returns the normalized vector pointing from this vector to `to`. This is equivalent to using `(b - a).normalized()`.
+     */
+    directionTo(to: Vector4): Vector4 { return _C(this, 2792, to) as Vector4; }
+
+    /**
+     * Returns the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+     */
+    distanceTo(to: Vector4): number { return _C(this, 2850, to) as number; }
+
+    /**
+     * Returns the squared [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+     * This method runs faster than {@link distanceTo}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+     */
+    distanceSquaredTo(to: Vector4): number { return _C(this, 2849, to) as number; }
+
+    /**
+     * Returns the dot product of this vector and `with`.
+     */
+    dot(_with: Vector4): number { return _C(this, 2871, _with) as number; }
+
+    /**
+     * Returns the inverse of the vector. This is the same as `Vector4(1.0 / v.x, 1.0 / v.y, 1.0 / v.z, 1.0 / v.w)`.
+     */
+    inverse(): Vector4 { return _C(this, 7714) as Vector4; }
+
+    /**
+     * Returns `true` if this vector and `to` are approximately equal, by running {@link isEqualApprox} on each component.
+     */
+    isEqualApprox(to: Vector4): boolean { return _C(this, 7938, to) as boolean; }
+
+    /**
+     * Returns `true` if this vector's values are approximately zero, by running {@link isZeroApprox} on each component.
+     * This method is faster than using {@link isEqualApprox} with one value as a zero vector.
+     */
+    isZeroApprox(): boolean { return _C(this, 8459) as boolean; }
+
+    /**
+     * Returns `true` if this vector is finite, by calling {@link isFinite} on each component.
+     */
+    isFinite(): boolean { return _C(this, 7951) as boolean; }
+
+    /**
+     * Returns the component-wise minimum of this and `with`, equivalent to `Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z), minf(w, with.w))`.
+     */
+    min(_with: Vector4): Vector4 { return _C(this, 8910, _with) as Vector4; }
+
+    /**
+     * Returns the component-wise minimum of this and `with`, equivalent to `Vector4(minf(x, with), minf(y, with), minf(z, with), minf(w, with))`.
+     */
+    minf(_with: number): Vector4 { return _C(this, 8921, _with) as Vector4; }
+
+    /**
+     * Returns the component-wise maximum of this and `with`, equivalent to `Vector4(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z), maxf(w, with.w))`.
+     */
+    max(_with: Vector4): Vector4 { return _C(this, 8804, _with) as Vector4; }
+
+    /**
+     * Returns the component-wise maximum of this and `with`, equivalent to `Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w, with))`.
+     */
+    maxf(_with: number): Vector4 { return _C(this, 8839, _with) as Vector4; }
+
+    equals(other: Variant | Vector4): boolean { return _C(this, -1, other) as boolean; }
+
+    notEquals(other: Variant | Vector4): boolean { return _C(this, -2, other) as boolean; }
+
+    /**
+     * Returns the negative value of the {@link Vector4}. This is the same as writing `Vector4(-v.x, -v.y, -v.z, -v.w)`. This operation flips the direction of the vector while keeping the same magnitude. With floats, the number zero can be either positive or negative.
+     */
+    neg(): Vector4 { return _C(this, -11, undefined) as Vector4; }
+
+    /**
+     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
+     */
+    pos(): Vector4 { return _C(this, -12, undefined) as Vector4; }
+
+    not(): boolean { return _C(this, -24, undefined) as boolean; }
+
+    /**
+     * Multiplies each component of the {@link Vector4} by the given {@link int}.
+     */
+    mul(other: number | Vector4 | Projection): Vector4 { return _C(this, -9, other) as Vector4; }
+
+    /**
+     * Divides each component of the {@link Vector4} by the given {@link int}.
+     */
+    div(other: number | Vector4): Vector4 { return _C(this, -10, other) as Vector4; }
+
+    /**
+     * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is less than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+     * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
+     */
+    lessThan(other: Vector4): boolean { return _C(this, -3, other) as boolean; }
+
+    /**
+     * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is less than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+     * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
+     */
+    lessThanOrEqual(other: Vector4): boolean { return _C(this, -4, other) as boolean; }
+
+    /**
+     * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is greater than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+     * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
+     */
+    greaterThan(other: Vector4): boolean { return _C(this, -5, other) as boolean; }
+
+    /**
+     * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is greater than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+     * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
+     */
+    greaterThanOrEqual(other: Vector4): boolean { return _C(this, -6, other) as boolean; }
+
+    /**
+     * Adds each component of the {@link Vector4} by the components of the given {@link Vector4}.
+     *
+     * ```text
+     *
+     * print(Vector4(10, 20, 30, 40) + Vector4(3, 4, 5, 6)) # Prints (13.0, 24.0, 35.0, 46.0)
+     *
+     * ```
+     */
+    add(other: Vector4): Vector4 { return _C(this, -7, other) as Vector4; }
+
+    /**
+     * Subtracts each component of the {@link Vector4} by the components of the given {@link Vector4}.
+     *
+     * ```text
+     *
+     * print(Vector4(10, 20, 30, 40) - Vector4(3, 4, 5, 6)) # Prints (7.0, 16.0, 25.0, 34.0)
+     *
+     * ```
+     */
+    sub(other: Vector4): Vector4 { return _C(this, -8, other) as Vector4; }
+
+    contains(other: GodotDictionary | GodotArray | PackedVector4Array): boolean { return _C(this, -25, other) as boolean; }
+
+    static readonly name = _R(12, Vector4);
+}

package/gen/value-types/Vector4i.ts

@@ -0,0 +1,208 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { GodotVar, _C, _R, _get, _set } from '../../src/runtime.ts';
+import type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
+import type { Vector4 } from '../value-types/index.ts';
+
+/**
+ * A 4-element structure that can be used to represent 4D grid coordinates or any other quadruplet of integers.
+ * It uses integer coordinates and is therefore preferable to {@link Vector4} when exact precision is required. Note that the values are limited to 32 bits, and unlike {@link Vector4} this cannot be configured with an engine build option. Use {@link int} or {@link PackedInt64Array} if 64-bit values are needed.
+ * **Note:** In a boolean context, a Vector4i will evaluate to `false` if it's equal to `Vector4i(0, 0, 0, 0)`. Otherwise, a Vector4i will always evaluate to `true`.
+ */
+export class Vector4i extends GodotVar {
+    /**
+     * The vector's X component. Also accessible by using the index position `[0]`.
+     */
+    get x(): number { return _get(this, 14941) as number; }
+    set x(v: number) { _set(this, 14941, v); }
+
+    /**
+     * The vector's Y component. Also accessible by using the index position `[1]`.
+     */
+    get y(): number { return _get(this, 14952) as number; }
+    set y(v: number) { _set(this, 14952, v); }
+
+    /**
+     * The vector's Z component. Also accessible by using the index position `[2]`.
+     */
+    get z(): number { return _get(this, 14956) as number; }
+    set z(v: number) { _set(this, 14956, v); }
+
+    /**
+     * The vector's W component. Also accessible by using the index position `[3]`.
+     */
+    get w(): number { return _get(this, 14833) as number; }
+    set w(v: number) { _set(this, 14833, v); }
+
+    constructor();
+    constructor(from: Vector4i);
+    constructor(from: Vector4);
+    constructor(x: number, y: number, z: number, w: number);
+    constructor(...args: any[]) { super(13, ...args); }
+
+    /**
+     * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_W}.
+     */
+    minAxisIndex(): number { return _C(this, 8911) as number; }
+
+    /**
+     * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
+     */
+    maxAxisIndex(): number { return _C(this, 8806) as number; }
+
+    /**
+     * Returns the length (magnitude) of this vector.
+     */
+    length(): number { return _C(this, 8546) as number; }
+
+    /**
+     * Returns the squared length (squared magnitude) of this vector.
+     * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+     */
+    lengthSquared(): number { return _C(this, 8547) as number; }
+
+    /**
+     * Returns a new vector with each component set to `1` if it's positive, `-1` if it's negative, and `0` if it's zero. The result is identical to calling {@link sign} on each component.
+     */
+    sign(): Vector4i { return _C(this, 13597) as Vector4i; }
+
+    /**
+     * Returns a new vector with all components in absolute values (i.e. positive).
+     */
+    abs(): Vector4i { return _C(this, 1053) as Vector4i; }
+
+    /**
+     * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
+     */
+    clamp(min: Vector4i, max: Vector4i): Vector4i { return _C(this, 2202, min, max) as Vector4i; }
+
+    /**
+     * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
+     */
+    clampi(min: number, max: number): Vector4i { return _C(this, 2206, min, max) as Vector4i; }
+
+    /**
+     * Returns a new vector with each component snapped to the closest multiple of the corresponding component in `step`.
+     */
+    snapped(step: Vector4i): Vector4i { return _C(this, 13674, step) as Vector4i; }
+
+    /**
+     * Returns a new vector with each component snapped to the closest multiple of `step`.
+     */
+    snappedi(step: number): Vector4i { return _C(this, 13676, step) as Vector4i; }
+
+    /**
+     * Returns the component-wise minimum of this and `with`, equivalent to `Vector4i(mini(x, with.x), mini(y, with.y), mini(z, with.z), mini(w, with.w))`.
+     */
+    min(_with: Vector4i): Vector4i { return _C(this, 8910, _with) as Vector4i; }
+
+    /**
+     * Returns the component-wise minimum of this and `with`, equivalent to `Vector4i(mini(x, with), mini(y, with), mini(z, with), mini(w, with))`.
+     */
+    mini(_with: number): Vector4i { return _C(this, 8922, _with) as Vector4i; }
+
+    /**
+     * Returns the component-wise maximum of this and `with`, equivalent to `Vector4i(maxi(x, with.x), maxi(y, with.y), maxi(z, with.z), maxi(w, with.w))`.
+     */
+    max(_with: Vector4i): Vector4i { return _C(this, 8804, _with) as Vector4i; }
+
+    /**
+     * Returns the component-wise maximum of this and `with`, equivalent to `Vector4i(maxi(x, with), maxi(y, with), maxi(z, with), maxi(w, with))`.
+     */
+    maxi(_with: number): Vector4i { return _C(this, 8840, _with) as Vector4i; }
+
+    /**
+     * Returns the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+     */
+    distanceTo(to: Vector4i): number { return _C(this, 2850, to) as number; }
+
+    /**
+     * Returns the squared [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+     * This method runs faster than {@link distanceTo}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+     */
+    distanceSquaredTo(to: Vector4i): number { return _C(this, 2849, to) as number; }
+
+    equals(other: Variant | Vector4i): boolean { return _C(this, -1, other) as boolean; }
+
+    notEquals(other: Variant | Vector4i): boolean { return _C(this, -2, other) as boolean; }
+
+    /**
+     * Returns the negative value of the {@link Vector4i}. This is the same as writing `Vector4i(-v.x, -v.y, -v.z, -v.w)`. This operation flips the direction of the vector while keeping the same magnitude.
+     */
+    neg(): Vector4i { return _C(this, -11, undefined) as Vector4i; }
+
+    /**
+     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
+     */
+    pos(): Vector4i { return _C(this, -12, undefined) as Vector4i; }
+
+    not(): boolean { return _C(this, -24, undefined) as boolean; }
+
+    /**
+     * Multiplies each component of the {@link Vector4i} by the given {@link int}.
+     */
+    mul(other: number | Vector4i): Vector4i { return _C(this, -9, other) as Vector4i; }
+
+    /**
+     * Divides each component of the {@link Vector4i} by the given {@link int}.
+     */
+    div(other: number | Vector4i): Vector4i { return _C(this, -10, other) as Vector4i; }
+
+    /**
+     * Gets the remainder of each component of the {@link Vector4i} with the given {@link int}. This operation uses truncated division, which is often not desired as it does not work well with negative numbers. Consider using {@link posmod} instead if you want to handle negative numbers.
+     *
+     * ```text
+     *
+     * print(Vector4i(10, -20, 30, -40) % 7) # Prints (3, -6, 2, -5)
+     *
+     * ```
+     */
+    mod(other: number | Vector4i): Vector4i { return _C(this, -13, other) as Vector4i; }
+
+    /**
+     * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is less than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+     */
+    lessThan(other: Vector4i): boolean { return _C(this, -3, other) as boolean; }
+
+    /**
+     * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is less than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+     */
+    lessThanOrEqual(other: Vector4i): boolean { return _C(this, -4, other) as boolean; }
+
+    /**
+     * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is greater than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+     */
+    greaterThan(other: Vector4i): boolean { return _C(this, -5, other) as boolean; }
+
+    /**
+     * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is greater than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+     */
+    greaterThanOrEqual(other: Vector4i): boolean { return _C(this, -6, other) as boolean; }
+
+    /**
+     * Adds each component of the {@link Vector4i} by the components of the given {@link Vector4i}.
+     *
+     * ```text
+     *
+     * print(Vector4i(10, 20, 30, 40) + Vector4i(3, 4, 5, 6)) # Prints (13, 24, 35, 46)
+     *
+     * ```
+     */
+    add(other: Vector4i): Vector4i { return _C(this, -7, other) as Vector4i; }
+
+    /**
+     * Subtracts each component of the {@link Vector4i} by the components of the given {@link Vector4i}.
+     *
+     * ```text
+     *
+     * print(Vector4i(10, 20, 30, 40) - Vector4i(3, 4, 5, 6)) # Prints (7, 16, 25, 34)
+     *
+     * ```
+     */
+    sub(other: Vector4i): Vector4i { return _C(this, -8, other) as Vector4i; }
+
+    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
+
+    static readonly name = _R(13, Vector4i);
+}

package/gen/value-types/index.ts

@@ -0,0 +1,19 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+export * from './Vector2.ts';
+export * from './Vector2i.ts';
+export * from './Rect2.ts';
+export * from './Rect2i.ts';
+export * from './Vector3.ts';
+export * from './Vector3i.ts';
+export * from './Transform2D.ts';
+export * from './Vector4.ts';
+export * from './Vector4i.ts';
+export * from './Plane.ts';
+export * from './Quaternion.ts';
+export * from './AABB.ts';
+export * from './Basis.ts';
+export * from './Transform3D.ts';
+export * from './Projection.ts';
+export * from './Color.ts';

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@ringozz/godot",
+  "author": "Vladimir Davidovich",
+  "version": "0.1.0",
+  "description": "Node-API bindings for Godot Engine — call Godot classes from JavaScript",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./gen/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./runtime": "./src/runtime.ts",
+    "./debug": "./src/debug.ts",
+    "./*": "./gen/classes/*.ts"
+  },
+  "files": [
+    "src/",
+    "gen/"
+  ],
+  "godot": {
+    "version_major": 4,
+    "version_minor": 7,
+    "version_patch": 1,
+    "version_status": "stable",
+    "version_build": "official",
+    "version_full_name": "Godot Engine v4.7.1.stable.official",
+    "precision": "single"
+  },
+  "optionalDependencies": {
+    "@ringozz/godot-macos-arm64": "^0.1.0",
+    "@ringozz/godot-windows-x86_64": "^0.1.0",
+    "@ringozz/godot-web-wasm32": "^0.1.0"
+  }
+}