typescript-to-gdscript 0.1.0

package/typings/classes/ConvertTransformModifier3D.d.ts

@@ -0,0 +1,65 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link SkeletonModifier3D} that apply transform to the bone which converted from reference. */
+declare class ConvertTransformModifier3D extends BoneConstraint3D {
+  /** The number of settings in the modifier. */
+  setting_count: int;
+
+  /** Returns the axis of the remapping destination transform. */
+  get_apply_axis(index: int): int;
+  /** Returns the maximum value of the remapping destination range. */
+  get_apply_range_max(index: int): float;
+  /** Returns the minimum value of the remapping destination range. */
+  get_apply_range_min(index: int): float;
+  /** Returns the operation of the remapping destination transform. */
+  get_apply_transform_mode(index: int): int;
+  /** Returns the axis of the remapping source transform. */
+  get_reference_axis(index: int): int;
+  /** Returns the maximum value of the remapping source range. */
+  get_reference_range_max(index: int): float;
+  /** Returns the minimum value of the remapping source range. */
+  get_reference_range_min(index: int): float;
+  /** Returns the operation of the remapping source transform. */
+  get_reference_transform_mode(index: int): int;
+  /** Returns `true` if the additive option is enabled in the setting at `index`. */
+  is_additive(index: int): boolean;
+  /** Returns `true` if the relative option is enabled in the setting at `index`. */
+  is_relative(index: int): boolean;
+  /**
+   * Sets additive option in the setting at `index` to `enabled`. This mainly affects the process of applying transform to the {@link BoneConstraint3D.set_apply_bone}.
+   * If sets `enabled` to `true`, the processed transform is added to the pose of the current apply bone.
+   * If sets `enabled` to `false`, the pose of the current apply bone is replaced with the processed transform. However, if set {@link set_relative} to `true`, the transform is relative to rest.
+   */
+  set_additive(index: int, enabled: boolean): void;
+  /** Sets the axis of the remapping destination transform. */
+  set_apply_axis(index: int, axis: int): void;
+  /** Sets the maximum value of the remapping destination range. */
+  set_apply_range_max(index: int, range_max: float): void;
+  /** Sets the minimum value of the remapping destination range. */
+  set_apply_range_min(index: int, range_min: float): void;
+  /** Sets the operation of the remapping destination transform. */
+  set_apply_transform_mode(index: int, transform_mode: int): void;
+  /** Sets the axis of the remapping source transform. */
+  set_reference_axis(index: int, axis: int): void;
+  /** Sets the maximum value of the remapping source range. */
+  set_reference_range_max(index: int, range_max: float): void;
+  /** Sets the minimum value of the remapping source range. */
+  set_reference_range_min(index: int, range_min: float): void;
+  /** Sets the operation of the remapping source transform. */
+  set_reference_transform_mode(index: int, transform_mode: int): void;
+  /**
+   * Sets relative option in the setting at `index` to `enabled`.
+   * If sets `enabled` to `true`, the extracted and applying transform is relative to the rest.
+   * If sets `enabled` to `false`, the extracted transform is absolute.
+   */
+  set_relative(index: int, enabled: boolean): void;
+
+  // enum TransformMode
+  /** Convert with position. Transfer the difference. */
+  static readonly TRANSFORM_MODE_POSITION: int;
+  /** Convert with rotation. The angle is the roll for the specified axis. */
+  static readonly TRANSFORM_MODE_ROTATION: int;
+  /** Convert with scale. Transfers the ratio, not the difference. */
+  static readonly TRANSFORM_MODE_SCALE: int;
+}

package/typings/classes/ConvexPolygonShape2D.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D convex polygon shape used for physics collision. */
+declare class ConvexPolygonShape2D extends Shape2D {
+  /**
+   * The polygon's list of vertices that form a convex hull. Can be in either clockwise or counterclockwise order.
+   * **Warning:** Only set this property to a list of points that actually form a convex hull. Use {@link set_point_cloud} to generate the convex hull of an arbitrary set of points.
+   */
+  points: PackedVector2Array;
+  set_points(value: PackedVector2Array | Array<unknown>): void;
+  get_points(): PackedVector2Array;
+
+  /**
+   * Based on the set of points provided, this assigns the {@link points} property using the convex hull algorithm, removing all unneeded points. See {@link Geometry2D.convex_hull} for details.
+   */
+  set_point_cloud(point_cloud: PackedVector2Array | Array<unknown>): void;
+}

package/typings/classes/ConvexPolygonShape3D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D convex polyhedron shape used for physics collision. */
+declare class ConvexPolygonShape3D extends Shape3D {
+  /** The list of 3D points forming the convex polygon shape. */
+  points: PackedVector3Array;
+  set_points(value: PackedVector3Array | Array<unknown>): void;
+  get_points(): PackedVector3Array;
+}

package/typings/classes/CopyTransformModifier3D.d.ts

@@ -0,0 +1,117 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link SkeletonModifier3D} that apply transform to the bone which copied from reference. */
+declare class CopyTransformModifier3D extends BoneConstraint3D {
+  /** The number of settings in the modifier. */
+  setting_count: int;
+
+  /** Returns the axis flags of the setting at `index`. */
+  get_axis_flags(index: int): int;
+  /** Returns the copy flags of the setting at `index`. */
+  get_copy_flags(index: int): int;
+  /** Returns the invert flags of the setting at `index`. */
+  get_invert_flags(index: int): int;
+  /** Returns `true` if the additive option is enabled in the setting at `index`. */
+  is_additive(index: int): boolean;
+  /**
+   * Returns `true` if the enable flags has the flag for the X-axis in the setting at `index`. See also {@link set_axis_flags}.
+   */
+  is_axis_x_enabled(index: int): boolean;
+  /**
+   * Returns `true` if the invert flags has the flag for the X-axis in the setting at `index`. See also {@link set_invert_flags}.
+   */
+  is_axis_x_inverted(index: int): boolean;
+  /**
+   * Returns `true` if the enable flags has the flag for the Y-axis in the setting at `index`. See also {@link set_axis_flags}.
+   */
+  is_axis_y_enabled(index: int): boolean;
+  /**
+   * Returns `true` if the invert flags has the flag for the Y-axis in the setting at `index`. See also {@link set_invert_flags}.
+   */
+  is_axis_y_inverted(index: int): boolean;
+  /**
+   * Returns `true` if the enable flags has the flag for the Z-axis in the setting at `index`. See also {@link set_axis_flags}.
+   */
+  is_axis_z_enabled(index: int): boolean;
+  /**
+   * Returns `true` if the invert flags has the flag for the Z-axis in the setting at `index`. See also {@link set_invert_flags}.
+   */
+  is_axis_z_inverted(index: int): boolean;
+  /**
+   * Returns `true` if the copy flags has the flag for the position in the setting at `index`. See also {@link set_copy_flags}.
+   */
+  is_position_copying(index: int): boolean;
+  /** Returns `true` if the relative option is enabled in the setting at `index`. */
+  is_relative(index: int): boolean;
+  /**
+   * Returns `true` if the copy flags has the flag for the rotation in the setting at `index`. See also {@link set_copy_flags}.
+   */
+  is_rotation_copying(index: int): boolean;
+  /**
+   * Returns `true` if the copy flags has the flag for the scale in the setting at `index`. See also {@link set_copy_flags}.
+   */
+  is_scale_copying(index: int): boolean;
+  /**
+   * Sets additive option in the setting at `index` to `enabled`. This mainly affects the process of applying transform to the {@link BoneConstraint3D.set_apply_bone}.
+   * If sets `enabled` to `true`, the processed transform is added to the pose of the current apply bone.
+   * If sets `enabled` to `false`, the pose of the current apply bone is replaced with the processed transform. However, if set {@link set_relative} to `true`, the transform is relative to rest.
+   */
+  set_additive(index: int, enabled: boolean): void;
+  /** Sets the flags to copy axes. If the flag is valid, the axis is copied. */
+  set_axis_flags(index: int, axis_flags: int): void;
+  /** If sets `enabled` to `true`, the X-axis will be copied. */
+  set_axis_x_enabled(index: int, enabled: boolean): void;
+  /** If sets `enabled` to `true`, the X-axis will be inverted. */
+  set_axis_x_inverted(index: int, enabled: boolean): void;
+  /** If sets `enabled` to `true`, the Y-axis will be copied. */
+  set_axis_y_enabled(index: int, enabled: boolean): void;
+  /** If sets `enabled` to `true`, the Y-axis will be inverted. */
+  set_axis_y_inverted(index: int, enabled: boolean): void;
+  /** If sets `enabled` to `true`, the Z-axis will be copied. */
+  set_axis_z_enabled(index: int, enabled: boolean): void;
+  /** If sets `enabled` to `true`, the Z-axis will be inverted. */
+  set_axis_z_inverted(index: int, enabled: boolean): void;
+  /**
+   * Sets the flags to process the transform operations. If the flag is valid, the transform operation is processed.
+   * **Note:** If the rotation is valid for only one axis, it respects the roll of the valid axis. If the rotation is valid for two axes, it discards the roll of the invalid axis.
+   */
+  set_copy_flags(index: int, copy_flags: int): void;
+  /** If sets `enabled` to `true`, the position will be copied. */
+  set_copy_position(index: int, enabled: boolean): void;
+  /** If sets `enabled` to `true`, the rotation will be copied. */
+  set_copy_rotation(index: int, enabled: boolean): void;
+  /** If sets `enabled` to `true`, the scale will be copied. */
+  set_copy_scale(index: int, enabled: boolean): void;
+  /**
+   * Sets the flags to inverte axes. If the flag is valid, the axis is copied.
+   * **Note:** An inverted scale means an inverse number, not a negative scale. For example, inverting `2.0` means `0.5`.
+   * **Note:** An inverted rotation flips the elements of the quaternion. For example, a two-axis inversion will flip the roll of each axis, and a three-axis inversion will flip the final orientation. However, be aware that flipping only one axis may cause unintended rotation by the unflipped axes, due to the characteristics of the quaternion.
+   */
+  set_invert_flags(index: int, axis_flags: int): void;
+  /**
+   * Sets relative option in the setting at `index` to `enabled`.
+   * If sets `enabled` to `true`, the extracted and applying transform is relative to the rest.
+   * If sets `enabled` to `false`, the extracted transform is absolute.
+   */
+  set_relative(index: int, enabled: boolean): void;
+
+  // enum TransformFlag
+  /** If set, allows to copy the position. */
+  static readonly TRANSFORM_FLAG_POSITION: int;
+  /** If set, allows to copy the rotation. */
+  static readonly TRANSFORM_FLAG_ROTATION: int;
+  /** If set, allows to copy the scale. */
+  static readonly TRANSFORM_FLAG_SCALE: int;
+  /** If set, allows to copy the position/rotation/scale. */
+  static readonly TRANSFORM_FLAG_ALL: int;
+  // enum AxisFlag
+  /** If set, allows to process the X-axis. */
+  static readonly AXIS_FLAG_X: int;
+  /** If set, allows to process the Y-axis. */
+  static readonly AXIS_FLAG_Y: int;
+  /** If set, allows to process the Z-axis. */
+  static readonly AXIS_FLAG_Z: int;
+  /** If set, allows to process the all axes. */
+  static readonly AXIS_FLAG_ALL: int;
+}

package/typings/classes/Crypto.d.ts

@@ -0,0 +1,41 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides access to advanced cryptographic functionalities. */
+declare class Crypto extends RefCounted {
+  /**
+   * Compares two {@link PackedByteArray}s for equality without leaking timing information in order to prevent timing attacks.
+   * See this blog post (https://paragonie.com/blog/2015/11/preventing-timing-attacks-on-string-comparison-with-double-hmac-strategy) for more information.
+   */
+  constant_time_compare(trusted: PackedByteArray | Array<unknown>, received: PackedByteArray | Array<unknown>): boolean;
+  /**
+   * Decrypt the given `ciphertext` with the provided private `key`.
+   * **Note:** The maximum size of accepted ciphertext is limited by the key size.
+   */
+  decrypt(key: CryptoKey, ciphertext: PackedByteArray | Array<unknown>): PackedByteArray;
+  /**
+   * Encrypt the given `plaintext` with the provided public `key`.
+   * **Note:** The maximum size of accepted plaintext is limited by the key size.
+   */
+  encrypt(key: CryptoKey, plaintext: PackedByteArray | Array<unknown>): PackedByteArray;
+  /** Generates a {@link PackedByteArray} of cryptographically secure random bytes with given `size`. */
+  generate_random_bytes(size: int): PackedByteArray;
+  /**
+   * Generates an RSA {@link CryptoKey} that can be used for creating self-signed certificates and passed to {@link StreamPeerTLS.accept_stream}.
+   */
+  generate_rsa(size: int): CryptoKey;
+  /**
+   * Generates a self-signed {@link X509Certificate} from the given {@link CryptoKey} and `issuer_name`. The certificate validity will be defined by `not_before` and `not_after` (first valid date and last valid date). The `issuer_name` must contain at least "CN=" (common name, i.e. the domain name), "O=" (organization, i.e. your company name), "C=" (country, i.e. 2 lettered ISO-3166 code of the country the organization is based in).
+   * A small example to generate an RSA key and an X509 self-signed certificate.
+   */
+  generate_self_signed_certificate(key: CryptoKey, issuer_name?: string | NodePath, not_before?: string | NodePath, not_after?: string | NodePath): X509Certificate;
+  /**
+   * Generates an HMAC (https://en.wikipedia.org/wiki/HMAC) digest of `msg` using `key`. The `hash_type` parameter is the hashing algorithm that is used for the inner and outer hashes.
+   * Currently, only {@link HashingContext.HASH_SHA256} and {@link HashingContext.HASH_SHA1} are supported.
+   */
+  hmac_digest(hash_type: int, key: PackedByteArray | Array<unknown>, msg: PackedByteArray | Array<unknown>): PackedByteArray;
+  /** Sign a given `hash` of type `hash_type` with the provided private `key`. */
+  sign(hash_type: int, hash: PackedByteArray | Array<unknown>, key: CryptoKey): PackedByteArray;
+  /** Verify that a given `signature` for `hash` of type `hash_type` against the provided public `key`. */
+  verify(hash_type: int, hash: PackedByteArray | Array<unknown>, signature: PackedByteArray | Array<unknown>, key: CryptoKey): boolean;
+}

package/typings/classes/CryptoKey.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A cryptographic key (RSA or elliptic-curve). */
+declare class CryptoKey extends Resource {
+  /** Returns `true` if this CryptoKey only has the public part, and not the private one. */
+  is_public_only(): boolean;
+  /**
+   * Loads a key from `path`. If `public_only` is `true`, only the public key will be loaded.
+   * **Note:** `path` should be a "*.pub" file if `public_only` is `true`, a "*.key" file otherwise.
+   */
+  load(path: string | NodePath, public_only?: boolean): int;
+  /**
+   * Loads a key from the given `string_key`. If `public_only` is `true`, only the public key will be loaded.
+   */
+  load_from_string(string_key: string | NodePath, public_only?: boolean): int;
+  /**
+   * Saves a key to the given `path`. If `public_only` is `true`, only the public key will be saved.
+   * **Note:** `path` should be a "*.pub" file if `public_only` is `true`, a "*.key" file otherwise.
+   */
+  save(path: string | NodePath, public_only?: boolean): int;
+  /**
+   * Returns a string containing the key in PEM format. If `public_only` is `true`, only the public key will be included.
+   */
+  save_to_string(public_only?: boolean): string;
+}

package/typings/classes/Cubemap.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Six square textures representing the faces of a cube. Commonly used as a skybox. */
+declare class Cubemap extends ImageTextureLayered {
+  /** Creates a placeholder version of this resource ({@link PlaceholderCubemap}). */
+  create_placeholder(): Resource;
+}

package/typings/classes/CubemapArray.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An array of {@link Cubemap}s, stored together and with a single reference. */
+declare class CubemapArray extends ImageTextureLayered {
+  /** Creates a placeholder version of this resource ({@link PlaceholderCubemapArray}). */
+  create_placeholder(): Resource;
+}

package/typings/classes/Curve.d.ts

@@ -0,0 +1,96 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A mathematical curve. */
+declare class Curve extends Resource {
+  /** The number of points to include in the baked (i.e. cached) curve data. */
+  bake_resolution: int;
+  /** The maximum domain (x-coordinate) that points can have. */
+  max_domain: float;
+  /**
+   * The maximum value (y-coordinate) that points can have. Tangents can cause higher values between points.
+   */
+  max_value: float;
+  /** The minimum domain (x-coordinate) that points can have. */
+  min_domain: float;
+  /**
+   * The minimum value (y-coordinate) that points can have. Tangents can cause lower values between points.
+   */
+  min_value: float;
+  /** The number of points describing the curve. */
+  point_count: int;
+  set_bake_resolution(value: int): void;
+  get_bake_resolution(): int;
+  set_max_domain(value: float): void;
+  get_max_domain(): float;
+  set_max_value(value: float): void;
+  get_max_value(): float;
+  set_min_domain(value: float): void;
+  get_min_domain(): float;
+  set_min_value(value: float): void;
+  get_min_value(): float;
+  set_point_count(value: int): void;
+  get_point_count(): int;
+
+  /**
+   * Adds a point to the curve. For each side, if the `*_mode` is {@link TANGENT_LINEAR}, the `*_tangent` angle (in degrees) uses the slope of the curve halfway to the adjacent point. Allows custom assignments to the `*_tangent` angle if `*_mode` is set to {@link TANGENT_FREE}.
+   */
+  add_point(position: Vector2 | Vector2i, left_tangent?: float, right_tangent?: float, left_mode?: int, right_mode?: int): int;
+  /** Recomputes the baked cache of points for the curve. */
+  bake(): void;
+  /**
+   * Removes duplicate points, i.e. points that are less than 0.00001 units (engine epsilon value) away from their neighbor on the curve.
+   */
+  clean_dupes(): void;
+  /** Removes all points from the curve. */
+  clear_points(): void;
+  /** Returns the difference between {@link min_domain} and {@link max_domain}. */
+  get_domain_range(): float;
+  /** Returns the left {@link TangentMode} for the point at `index`. */
+  get_point_left_mode(index: int): int;
+  /** Returns the left tangent angle (in degrees) for the point at `index`. */
+  get_point_left_tangent(index: int): float;
+  /** Returns the curve coordinates for the point at `index`. */
+  get_point_position(index: int): Vector2;
+  /** Returns the right {@link TangentMode} for the point at `index`. */
+  get_point_right_mode(index: int): int;
+  /** Returns the right tangent angle (in degrees) for the point at `index`. */
+  get_point_right_tangent(index: int): float;
+  /** Returns the difference between {@link min_value} and {@link max_value}. */
+  get_value_range(): float;
+  /** Removes the point at `index` from the curve. */
+  remove_point(index: int): void;
+  /** Returns the Y value for the point that would exist at the X position `offset` along the curve. */
+  sample(offset: float): float;
+  /**
+   * Returns the Y value for the point that would exist at the X position `offset` along the curve using the baked cache. Bakes the curve's points if not already baked.
+   */
+  sample_baked(offset: float): float;
+  /** Sets the left {@link TangentMode} for the point at `index` to `mode`. */
+  set_point_left_mode(index: int, mode: int): void;
+  /** Sets the left tangent angle for the point at `index` to `tangent`. */
+  set_point_left_tangent(index: int, tangent: float): void;
+  /** Sets the offset from `0.5`. */
+  set_point_offset(index: int, offset: float): int;
+  /** Sets the right {@link TangentMode} for the point at `index` to `mode`. */
+  set_point_right_mode(index: int, mode: int): void;
+  /** Sets the right tangent angle for the point at `index` to `tangent`. */
+  set_point_right_tangent(index: int, tangent: float): void;
+  /** Assigns the vertical position `y` to the point at `index`. */
+  set_point_value(index: int, y: float): void;
+
+  /** Emitted when {@link max_domain} or {@link min_domain} is changed. */
+  domain_changed: Signal<[]>;
+  /** Emitted when {@link max_value} or {@link min_value} is changed. */
+  range_changed: Signal<[]>;
+
+  // enum TangentMode
+  /** The tangent on this side of the point is user-defined. */
+  static readonly TANGENT_FREE: int;
+  /**
+   * The curve calculates the tangent on this side of the point as the slope halfway towards the adjacent point.
+   */
+  static readonly TANGENT_LINEAR: int;
+  /** The total number of available tangent modes. */
+  static readonly TANGENT_MODE_COUNT: int;
+}

package/typings/classes/Curve2D.d.ts

@@ -0,0 +1,97 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Describes a Bézier curve in 2D space. */
+declare class Curve2D extends Resource {
+  /**
+   * The distance in pixels between two adjacent cached points. Changing it forces the cache to be recomputed the next time the {@link get_baked_points} or {@link get_baked_length} function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care.
+   */
+  bake_interval: float;
+  /** The number of points describing the curve. */
+  point_count: int;
+  set_bake_interval(value: float): void;
+  get_bake_interval(): float;
+  set_point_count(value: int): void;
+  get_point_count(): int;
+
+  /**
+   * Adds a point with the specified `position` relative to the curve's own position, with control points `in` and `out`. Appends the new point at the end of the point list.
+   * If `index` is given, the new point is inserted before the existing point identified by index `index`. Every existing point starting from `index` is shifted further down the list of points. The index must be greater than or equal to `0` and must not exceed the number of existing points in the line. See {@link point_count}.
+   */
+  add_point(position: Vector2 | Vector2i, in_?: Vector2 | Vector2i, out?: Vector2 | Vector2i, index?: int): void;
+  /** Removes all points from the curve. */
+  clear_points(): void;
+  /**
+   * Returns the total length of the curve, based on the cached points. Given enough density (see {@link bake_interval}), it should be approximate enough.
+   */
+  get_baked_length(): float;
+  /** Returns the cache of points as a {@link PackedVector2Array}. */
+  get_baked_points(): PackedVector2Array;
+  /**
+   * Returns the closest offset to `to_point`. This offset is meant to be used in {@link sample_baked}.
+   * `to_point` must be in this curve's local space.
+   */
+  get_closest_offset(to_point: Vector2 | Vector2i): float;
+  /**
+   * Returns the closest point on baked segments (in curve's local space) to `to_point`.
+   * `to_point` must be in this curve's local space.
+   */
+  get_closest_point(to_point: Vector2 | Vector2i): Vector2;
+  /**
+   * Returns the position of the control point leading to the vertex `idx`. The returned position is relative to the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0)`.
+   */
+  get_point_in(idx: int): Vector2;
+  /**
+   * Returns the position of the control point leading out of the vertex `idx`. The returned position is relative to the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0)`.
+   */
+  get_point_out(idx: int): Vector2;
+  /**
+   * Returns the position of the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0)`.
+   */
+  get_point_position(idx: int): Vector2;
+  /** Deletes the point `idx` from the curve. Sends an error to the console if `idx` is out of bounds. */
+  remove_point(idx: int): void;
+  /**
+   * Returns the position between the vertex `idx` and the vertex `idx + 1`, where `t` controls if the point is the first vertex (`t = 0.0`), the last vertex (`t = 1.0`), or in between. Values of `t` outside the range (`0.0 <= t <= 1.0`) give strange, but predictable results.
+   * If `idx` is out of bounds it is truncated to the first or last vertex, and `t` is ignored. If the curve has no points, the function sends an error to the console, and returns `(0, 0)`.
+   */
+  sample(idx: int, t: float): Vector2;
+  /**
+   * Returns a point within the curve at position `offset`, where `offset` is measured as a pixel distance along the curve.
+   * To do that, it finds the two cached points where the `offset` lies between, then interpolates the values. This interpolation is cubic if `cubic` is set to `true`, or linear if set to `false`.
+   * Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough).
+   */
+  sample_baked(offset?: float, cubic?: boolean): Vector2;
+  /**
+   * Similar to {@link sample_baked}, but returns {@link Transform2D} that includes a rotation along the curve, with {@link Transform2D.origin} as the point position and the {@link Transform2D.x} vector pointing in the direction of the path at that point. Returns an empty transform if the length of the curve is `0`.
+   */
+  sample_baked_with_rotation(offset?: float, cubic?: boolean): Transform2D;
+  /**
+   * Returns the position at the vertex `fofs`. It calls {@link sample} using the integer part of `fofs` as `idx`, and its fractional part as `t`.
+   */
+  samplef(fofs: float): Vector2;
+  /**
+   * Sets the position of the control point leading to the vertex `idx`. If the index is out of bounds, the function sends an error to the console. The position is relative to the vertex.
+   */
+  set_point_in(idx: int, position: Vector2 | Vector2i): void;
+  /**
+   * Sets the position of the control point leading out of the vertex `idx`. If the index is out of bounds, the function sends an error to the console. The position is relative to the vertex.
+   */
+  set_point_out(idx: int, position: Vector2 | Vector2i): void;
+  /**
+   * Sets the position for the vertex `idx`. If the index is out of bounds, the function sends an error to the console.
+   */
+  set_point_position(idx: int, position: Vector2 | Vector2i): void;
+  /**
+   * Returns a list of points along the curve, with a curvature controlled point density. That is, the curvier parts will have more points than the straighter parts.
+   * This approximation makes straight segments between each point, then subdivides those segments until the resulting shape is similar enough.
+   * `max_stages` controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care!
+   * `tolerance_degrees` controls how many degrees the midpoint of a segment may deviate from the real curve, before the segment has to be subdivided.
+   */
+  tessellate(max_stages?: int, tolerance_degrees?: float): PackedVector2Array;
+  /**
+   * Returns a list of points along the curve, with almost uniform density. `max_stages` controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care!
+   * `tolerance_length` controls the maximal distance between two neighboring points, before the segment has to be subdivided.
+   */
+  tessellate_even_length(max_stages?: int, tolerance_length?: float): PackedVector2Array;
+}

package/typings/classes/Curve3D.d.ts

@@ -0,0 +1,129 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Describes a Bézier curve in 3D space. */
+declare class Curve3D extends Resource {
+  /**
+   * The distance in meters between two adjacent cached points. Changing it forces the cache to be recomputed the next time the {@link get_baked_points} or {@link get_baked_length} function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care.
+   */
+  bake_interval: float;
+  /**
+   * If `true`, and the curve has more than 2 control points, the last point and the first one will be connected in a loop.
+   */
+  closed: boolean;
+  /** The number of points describing the curve. */
+  point_count: int;
+  /**
+   * If `true`, the curve will bake up vectors used for orientation. This is used when {@link PathFollow3D.rotation_mode} is set to {@link PathFollow3D.ROTATION_ORIENTED}. Changing it forces the cache to be recomputed.
+   */
+  up_vector_enabled: boolean;
+  set_bake_interval(value: float): void;
+  get_bake_interval(): float;
+  set_closed(value: boolean): void;
+  is_closed(): boolean;
+  set_point_count(value: int): void;
+  get_point_count(): int;
+  set_up_vector_enabled(value: boolean): void;
+  is_up_vector_enabled(): boolean;
+
+  /**
+   * Adds a point with the specified `position` relative to the curve's own position, with control points `in` and `out`. Appends the new point at the end of the point list.
+   * If `index` is given, the new point is inserted before the existing point identified by index `index`. Every existing point starting from `index` is shifted further down the list of points. The index must be greater than or equal to `0` and must not exceed the number of existing points in the line. See {@link point_count}.
+   */
+  add_point(position: Vector3 | Vector3i, in_?: Vector3 | Vector3i, out?: Vector3 | Vector3i, index?: int): void;
+  /** Removes all points from the curve. */
+  clear_points(): void;
+  /**
+   * Returns the total length of the curve, based on the cached points. Given enough density (see {@link bake_interval}), it should be approximate enough.
+   */
+  get_baked_length(): float;
+  /** Returns the cache of points as a {@link PackedVector3Array}. */
+  get_baked_points(): PackedVector3Array;
+  /** Returns the cache of tilts as a {@link PackedFloat32Array}. */
+  get_baked_tilts(): PackedFloat32Array;
+  /**
+   * Returns the cache of up vectors as a {@link PackedVector3Array}.
+   * If {@link up_vector_enabled} is `false`, the cache will be empty.
+   */
+  get_baked_up_vectors(): PackedVector3Array;
+  /**
+   * Returns the closest offset to `to_point`. This offset is meant to be used in {@link sample_baked} or {@link sample_baked_up_vector}.
+   * `to_point` must be in this curve's local space.
+   */
+  get_closest_offset(to_point: Vector3 | Vector3i): float;
+  /**
+   * Returns the closest point on baked segments (in curve's local space) to `to_point`.
+   * `to_point` must be in this curve's local space.
+   */
+  get_closest_point(to_point: Vector3 | Vector3i): Vector3;
+  /**
+   * Returns the position of the control point leading to the vertex `idx`. The returned position is relative to the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0, 0)`.
+   */
+  get_point_in(idx: int): Vector3;
+  /**
+   * Returns the position of the control point leading out of the vertex `idx`. The returned position is relative to the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0, 0)`.
+   */
+  get_point_out(idx: int): Vector3;
+  /**
+   * Returns the position of the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0, 0)`.
+   */
+  get_point_position(idx: int): Vector3;
+  /**
+   * Returns the tilt angle in radians for the point `idx`. If the index is out of bounds, the function sends an error to the console, and returns `0`.
+   */
+  get_point_tilt(idx: int): float;
+  /** Deletes the point `idx` from the curve. Sends an error to the console if `idx` is out of bounds. */
+  remove_point(idx: int): void;
+  /**
+   * Returns the position between the vertex `idx` and the vertex `idx + 1`, where `t` controls if the point is the first vertex (`t = 0.0`), the last vertex (`t = 1.0`), or in between. Values of `t` outside the range (`0.0 >= t <=1`) give strange, but predictable results.
+   * If `idx` is out of bounds it is truncated to the first or last vertex, and `t` is ignored. If the curve has no points, the function sends an error to the console, and returns `(0, 0, 0)`.
+   */
+  sample(idx: int, t: float): Vector3;
+  /**
+   * Returns a point within the curve at position `offset`, where `offset` is measured as a distance in 3D units along the curve. To do that, it finds the two cached points where the `offset` lies between, then interpolates the values. This interpolation is cubic if `cubic` is set to `true`, or linear if set to `false`.
+   * Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough).
+   */
+  sample_baked(offset?: float, cubic?: boolean): Vector3;
+  /**
+   * Returns an up vector within the curve at position `offset`, where `offset` is measured as a distance in 3D units along the curve. To do that, it finds the two cached up vectors where the `offset` lies between, then interpolates the values. If `apply_tilt` is `true`, an interpolated tilt is applied to the interpolated up vector.
+   * If the curve has no up vectors, the function sends an error to the console, and returns `(0, 1, 0)`.
+   */
+  sample_baked_up_vector(offset: float, apply_tilt?: boolean): Vector3;
+  /**
+   * Returns a {@link Transform3D} with `origin` as point position, `basis.x` as sideway vector, `basis.y` as up vector, `basis.z` as forward vector. When the curve length is 0, there is no reasonable way to calculate the rotation, all vectors aligned with global space axes. See also {@link sample_baked}.
+   */
+  sample_baked_with_rotation(offset?: float, cubic?: boolean, apply_tilt?: boolean): Transform3D;
+  /**
+   * Returns the position at the vertex `fofs`. It calls {@link sample} using the integer part of `fofs` as `idx`, and its fractional part as `t`.
+   */
+  samplef(fofs: float): Vector3;
+  /**
+   * Sets the position of the control point leading to the vertex `idx`. If the index is out of bounds, the function sends an error to the console. The position is relative to the vertex.
+   */
+  set_point_in(idx: int, position: Vector3 | Vector3i): void;
+  /**
+   * Sets the position of the control point leading out of the vertex `idx`. If the index is out of bounds, the function sends an error to the console. The position is relative to the vertex.
+   */
+  set_point_out(idx: int, position: Vector3 | Vector3i): void;
+  /**
+   * Sets the position for the vertex `idx`. If the index is out of bounds, the function sends an error to the console.
+   */
+  set_point_position(idx: int, position: Vector3 | Vector3i): void;
+  /**
+   * Sets the tilt angle in radians for the point `idx`. If the index is out of bounds, the function sends an error to the console.
+   * The tilt controls the rotation along the look-at axis an object traveling the path would have. In the case of a curve controlling a {@link PathFollow3D}, this tilt is an offset over the natural tilt the {@link PathFollow3D} calculates.
+   */
+  set_point_tilt(idx: int, tilt: float): void;
+  /**
+   * Returns a list of points along the curve, with a curvature controlled point density. That is, the curvier parts will have more points than the straighter parts.
+   * This approximation makes straight segments between each point, then subdivides those segments until the resulting shape is similar enough.
+   * `max_stages` controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care!
+   * `tolerance_degrees` controls how many degrees the midpoint of a segment may deviate from the real curve, before the segment has to be subdivided.
+   */
+  tessellate(max_stages?: int, tolerance_degrees?: float): PackedVector3Array;
+  /**
+   * Returns a list of points along the curve, with almost uniform density. `max_stages` controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care!
+   * `tolerance_length` controls the maximal distance between two neighboring points, before the segment has to be subdivided.
+   */
+  tessellate_even_length(max_stages?: int, tolerance_length?: float): PackedVector3Array;
+}