typescript-to-gdscript 0.1.0

package/typings/classes/Basis.d.ts

@@ -0,0 +1,225 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3×3 matrix for representing 3D rotation and scale. */
+declare interface Basis {
+  /**
+   * The basis's X axis, and the column `0` of the matrix.
+   * On the identity basis, this vector points right ({@link Vector3.RIGHT}).
+   */
+  x: Vector3;
+  /**
+   * The basis's Y axis, and the column `1` of the matrix.
+   * On the identity basis, this vector points up ({@link Vector3.UP}).
+   */
+  y: Vector3;
+  /**
+   * The basis's Z axis, and the column `2` of the matrix.
+   * On the identity basis, this vector points back ({@link Vector3.BACK}).
+   */
+  z: Vector3;
+
+  /**
+   * Returns the determinant (https://en.wikipedia.org/wiki/Determinant) of this basis's matrix. For advanced math, this number can be used to determine a few attributes:
+   * - If the determinant is exactly `0.0`, the basis is not invertible (see {@link inverse}).
+   * - If the determinant is a negative number, the basis represents a negative scale.
+   * **Note:** If the basis's scale is the same for every axis, its determinant is always that scale by the power of 3.
+   */
+  determinant(): float;
+  /**
+   * Returns this basis's rotation as a {@link Vector3} of Euler angles (https://en.wikipedia.org/wiki/Euler_angles), in radians. For the returned value:
+   * - The {@link Vector3.x} contains the angle around the {@link x} axis (pitch);
+   * - The {@link Vector3.y} contains the angle around the {@link y} axis (yaw);
+   * - The {@link Vector3.z} contains the angle around the {@link z} axis (roll).
+   * The order of each consecutive rotation can be changed with `order` (see {@link EulerOrder} constants). By default, the YXZ convention is used ({@link EULER_ORDER_YXZ}): Z (roll) is calculated first, then X (pitch), and lastly Y (yaw). When using the opposite method {@link from_euler}, this order is reversed.
+   * **Note:** For this method to return correctly, the basis needs to be *orthonormal* (see {@link orthonormalized}).
+   * **Note:** Euler angles are much more intuitive but are not suitable for 3D math. Because of this, consider using the {@link get_rotation_quaternion} method instead, which returns a {@link Quaternion}.
+   * **Note:** In the Inspector dock, a basis's rotation is often displayed in Euler angles (in degrees), as is the case with the {@link Node3D.rotation} property.
+   */
+  get_euler(order?: int): Vector3;
+  /**
+   * Returns this basis's rotation as a {@link Quaternion}.
+   * **Note:** Quaternions are much more suitable for 3D math but are less intuitive. For user interfaces, consider using the {@link get_euler} method, which returns Euler angles.
+   */
+  get_rotation_quaternion(): Quaternion;
+  /**
+   * Returns the length of each axis of this basis, as a {@link Vector3}. If the basis is not sheared, this value is the scaling factor. It is not affected by rotation.
+   * **Note:** If the value returned by {@link determinant} is negative, the scale is also negative.
+   */
+  get_scale(): Vector3;
+  /** Returns the inverse of this basis's matrix (https://en.wikipedia.org/wiki/Invertible_matrix). */
+  inverse(): Basis;
+  /**
+   * Returns `true` if this basis is conformal. A conformal basis is both *orthogonal* (the axes are perpendicular to each other) and *uniform* (the axes share the same length). This method can be especially useful during physics calculations.
+   */
+  is_conformal(): boolean;
+  /**
+   * Returns `true` if this basis and `b` are approximately equal, by calling {@link @GlobalScope.is_equal_approx} on all vector components.
+   */
+  is_equal_approx(b: Basis | Quaternion): boolean;
+  /**
+   * Returns `true` if this basis is finite, by calling {@link @GlobalScope.is_finite} on all vector components.
+   */
+  is_finite(): boolean;
+  /**
+   * Returns `true` if this basis is orthonormal. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the length of every axis is `1.0`). This method can be especially useful during physics calculations.
+   */
+  is_orthonormal(): boolean;
+  /**
+   * Returns the orthonormalized version of this basis. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the axes have a length of `1.0`), which also means it can only represent a rotation.
+   * It is often useful to call this method to avoid rounding errors on a rotating basis:
+   */
+  orthonormalized(): Basis;
+  /**
+   * Returns a copy of this basis rotated around the given `axis` by the given `angle` (in radians).
+   * The `axis` must be a normalized vector (see {@link Vector3.normalized}). If `angle` is positive, the basis is rotated counter-clockwise around the axis.
+   */
+  rotated(axis: Vector3 | Vector3i, angle: float): Basis;
+  /**
+   * Returns this basis with each axis's components scaled by the given `scale`'s components.
+   * The basis matrix's rows are multiplied by `scale`'s components. This operation is a global scale (relative to the parent).
+   */
+  scaled(scale: Vector3 | Vector3i): Basis;
+  /**
+   * Returns this basis with each axis scaled by the corresponding component in the given `scale`.
+   * The basis matrix's columns are multiplied by `scale`'s components. This operation is a local scale (relative to self).
+   */
+  scaled_local(scale: Vector3 | Vector3i): Basis;
+  /**
+   * Performs a spherical-linear interpolation with the `to` basis, given a `weight`. Both this basis and `to` should represent a rotation.
+   * **Example:** Smoothly rotate a {@link Node3D} to the target basis over time, with a {@link Tween}:
+   */
+  slerp(to: Basis | Quaternion, weight: float): Basis;
+  /**
+   * Returns the transposed dot product between `with` and the {@link x} axis (see {@link transposed}).
+   * This is equivalent to `basis.x.dot(vector)`.
+   */
+  tdotx(with_: Vector3 | Vector3i): float;
+  /**
+   * Returns the transposed dot product between `with` and the {@link y} axis (see {@link transposed}).
+   * This is equivalent to `basis.y.dot(vector)`.
+   */
+  tdoty(with_: Vector3 | Vector3i): float;
+  /**
+   * Returns the transposed dot product between `with` and the {@link z} axis (see {@link transposed}).
+   * This is equivalent to `basis.z.dot(vector)`.
+   */
+  tdotz(with_: Vector3 | Vector3i): float;
+  /**
+   * Returns the transposed version of this basis. This turns the basis matrix's columns into rows, and its rows into columns.
+   */
+  transposed(): Basis;
+
+  // Operator overloads
+  [__ops_ne]: { right: Basis; ret: boolean };
+  [__ops_mul]: { right: Basis; ret: Basis } | { right: Vector3; ret: Vector3 } | { right: float; ret: Basis } | { right: int; ret: Basis };
+  [__ops_div]: { right: float; ret: Basis } | { right: int; ret: Basis };
+  [__ops_eq]: { right: Basis; ret: boolean };
+
+  [__variant_converts]: Basis | Quaternion;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  clear: never;
+  duplicate: never;
+  duplicate_deep: never;
+  erase: never;
+  find_key: never;
+  get: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has: never;
+  has_all: never;
+  hash: never;
+  is_empty: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  set: never;
+  size: never;
+  sort: never;
+  values: never;
+}
+
+declare interface BasisConstructor {
+  readonly prototype: Basis;
+  /**
+   * Constructs a {@link Basis} identical to {@link IDENTITY}.
+   * **Note:** In C#, this constructs a {@link Basis} with all of its components set to {@link Vector3.ZERO}.
+   */
+  (): Basis;
+  /** Constructs a {@link Basis} as a copy of the given {@link Basis}. */
+  (from_: Basis): Basis;
+  /**
+   * Constructs a {@link Basis} that only represents rotation, rotated around the `axis` by the given `angle`, in radians. The axis must be a normalized vector.
+   * **Note:** This is the same as using {@link rotated} on the {@link IDENTITY} basis. With more than one angle consider using {@link from_euler}, instead.
+   */
+  (axis: Vector3, angle: float): Basis;
+  /**
+   * Constructs a {@link Basis} that only represents rotation from the given {@link Quaternion}.
+   * **Note:** Quaternions *only* store rotation, not scale. Because of this, conversions from {@link Basis} to {@link Quaternion} cannot always be reversed.
+   */
+  (from_: Quaternion): Basis;
+  /** Constructs a {@link Basis} from 3 axis vectors. These are the columns of the basis matrix. */
+  (x_axis: Vector3, y_axis: Vector3, z_axis: Vector3): Basis;
+  /**
+   * Constructs a new {@link Basis} that only represents rotation from the given {@link Vector3} of Euler angles (https://en.wikipedia.org/wiki/Euler_angles), in radians.
+   * - The {@link Vector3.x} should contain the angle around the {@link x} axis (pitch);
+   * - The {@link Vector3.y} should contain the angle around the {@link y} axis (yaw);
+   * - The {@link Vector3.z} should contain the angle around the {@link z} axis (roll).
+   * The order of each consecutive rotation can be changed with `order` (see {@link EulerOrder} constants). By default, the YXZ convention is used ({@link EULER_ORDER_YXZ}): the basis rotates first around the Y axis (yaw), then X (pitch), and lastly Z (roll). When using the opposite method {@link get_euler}, this order is reversed.
+   */
+  from_euler(euler: Vector3 | Vector3i, order?: int): Basis;
+  /**
+   * Constructs a new {@link Basis} that only represents scale, with no rotation or shear, from the given `scale` vector.
+   * **Note:** In linear algebra, the matrix of this basis is also known as a diagonal matrix (https://en.wikipedia.org/wiki/Diagonal_matrix).
+   */
+  from_scale(scale: Vector3 | Vector3i): Basis;
+  /**
+   * Creates a new {@link Basis} with a rotation such that the forward axis (-Z) points towards the `target` position.
+   * By default, the -Z axis (camera forward) is treated as forward (implies +X is right). If `use_model_front` is `true`, the +Z axis (asset front) is treated as forward (implies +X is left) and points toward the `target` position.
+   * The up axis (+Y) points as close to the `up` vector as possible while staying perpendicular to the forward axis. The returned basis is orthonormalized (see {@link orthonormalized}).
+   * The `target` and the `up` cannot be {@link Vector3.ZERO}, and shouldn't be colinear to avoid unintended rotation around local Z axis.
+   */
+  looking_at(target: Vector3 | Vector3i, up?: Vector3 | Vector3i, use_model_front?: boolean): Basis;
+
+  /**
+   * The identity {@link Basis}. This is an orthonormal basis with no rotation, no shear, and a scale of {@link Vector3.ONE}. This also means that:
+   * - The {@link x} points right ({@link Vector3.RIGHT});
+   * - The {@link y} points up ({@link Vector3.UP});
+   * - The {@link z} points back ({@link Vector3.BACK}).
+   * If a {@link Vector3} or another {@link Basis} is transformed (multiplied) by this constant, no transformation occurs.
+   * **Note:** In GDScript, this constant is equivalent to creating a [constructor Basis] without any arguments. It can be used to make your code clearer, and for consistency with C#.
+   */
+  readonly IDENTITY: Basis;
+  /**
+   * When any basis is multiplied by {@link FLIP_X}, it negates all components of the {@link x} axis (the X column).
+   * When {@link FLIP_X} is multiplied by any basis, it negates the {@link Vector3.x} component of all axes (the X row).
+   */
+  readonly FLIP_X: Basis;
+  /**
+   * When any basis is multiplied by {@link FLIP_Y}, it negates all components of the {@link y} axis (the Y column).
+   * When {@link FLIP_Y} is multiplied by any basis, it negates the {@link Vector3.y} component of all axes (the Y row).
+   */
+  readonly FLIP_Y: Basis;
+  /**
+   * When any basis is multiplied by {@link FLIP_Z}, it negates all components of the {@link z} axis (the Z column).
+   * When {@link FLIP_Z} is multiplied by any basis, it negates the {@link Vector3.z} component of all axes (the Z row).
+   */
+  readonly FLIP_Z: Basis;
+}
+declare const Basis: BasisConstructor;

package/typings/classes/BitMap.d.ts

@@ -0,0 +1,42 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Boolean matrix. */
+declare class BitMap extends Resource {
+  /**
+   * Returns an image of the same size as the bitmap and with an {@link Image.Format} of type {@link Image.FORMAT_L8}. `true` bits of the bitmap are being converted into white pixels, and `false` bits into black.
+   */
+  convert_to_image(): Image;
+  /** Creates a bitmap with the specified size, filled with `false`. */
+  create(size: Vector2i | Vector2): void;
+  /**
+   * Creates a bitmap that matches the given image dimensions, every element of the bitmap is set to `false` if the alpha value of the image at that position is equal to `threshold` or less, and `true` in other case.
+   */
+  create_from_image_alpha(image: Image, threshold?: float): void;
+  /** Returns bitmap's value at the specified position. */
+  get_bit(x: int, y: int): boolean;
+  /** Returns bitmap's value at the specified position. */
+  get_bitv(position: Vector2i | Vector2): boolean;
+  /** Returns bitmap's dimensions. */
+  get_size(): Vector2i;
+  /** Returns the number of bitmap elements that are set to `true`. */
+  get_true_bit_count(): int;
+  /**
+   * Applies morphological dilation or erosion to the bitmap. If `pixels` is positive, dilation is applied to the bitmap. If `pixels` is negative, erosion is applied to the bitmap. `rect` defines the area where the morphological operation is applied. Pixels located outside the `rect` are unaffected by {@link grow_mask}.
+   */
+  grow_mask(pixels: int, rect: Rect2i | Rect2): void;
+  /**
+   * Creates an {@link Array} of polygons covering a rectangular portion of the bitmap. It uses a marching squares algorithm, followed by Ramer-Douglas-Peucker (RDP) reduction of the number of vertices. Each polygon is described as a {@link PackedVector2Array} of its vertices.
+   * To get polygons covering the whole bitmap, pass:
+   * `epsilon` is passed to RDP to control how accurately the polygons cover the bitmap: a lower `epsilon` corresponds to more points in the polygons.
+   */
+  opaque_to_polygons(rect: Rect2i | Rect2, epsilon?: float): Array<PackedVector2Array>;
+  /** Resizes the image to `new_size`. */
+  resize(new_size: Vector2i | Vector2): void;
+  /** Sets the bitmap's element at the specified position, to the specified value. */
+  set_bit(x: int, y: int, bit: boolean): void;
+  /** Sets a rectangular portion of the bitmap to the specified value. */
+  set_bit_rect(rect: Rect2i | Rect2, bit: boolean): void;
+  /** Sets the bitmap's element at the specified position, to the specified value. */
+  set_bitv(position: Vector2i | Vector2, bit: boolean): void;
+}

package/typings/classes/BlitMaterial.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A material that processes blit calls to a DrawableTexture. */
+declare class BlitMaterial extends Material {
+  /** The manner in which the newly blitted texture is blended with the original DrawableTexture. */
+  blend_mode: int;
+  set_blend_mode(value: int): void;
+  get_blend_mode(): int;
+
+  // enum BlendMode
+  /** Mix blending mode. Colors are assumed to be independent of the alpha (opacity) value. */
+  static readonly BLEND_MODE_MIX: int;
+  /** Additive blending mode. */
+  static readonly BLEND_MODE_ADD: int;
+  /** Subtractive blending mode. */
+  static readonly BLEND_MODE_SUB: int;
+  /** Multiplicative blending mode. */
+  static readonly BLEND_MODE_MUL: int;
+  /** No blending mode, direct color copy. */
+  static readonly BLEND_MODE_DISABLED: int;
+}

package/typings/classes/Bone2D.d.ts

@@ -0,0 +1,45 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A joint used with {@link Skeleton2D} to control and animate other nodes. */
+declare class Bone2D extends Node2D {
+  /**
+   * Rest transform of the bone. You can reset the node's transforms to this value using {@link apply_rest}.
+   */
+  rest: Transform2D;
+  set_rest(value: Transform2D): void;
+  get_rest(): Transform2D;
+
+  /**
+   * Resets the bone to the rest pose. This is equivalent to setting {@link Node2D.transform} to {@link rest}.
+   */
+  apply_rest(): void;
+  /**
+   * Returns whether this {@link Bone2D} is going to autocalculate its length and bone angle using its first {@link Bone2D} child node, if one exists. If there are no {@link Bone2D} children, then it cannot autocalculate these values and will print a warning.
+   */
+  get_autocalculate_length_and_angle(): boolean;
+  /**
+   * Returns the angle of the bone in the {@link Bone2D}.
+   * **Note:** This is different from the {@link Bone2D}'s rotation. The bone's angle is the rotation of the bone shown by the gizmo, which is unaffected by the {@link Bone2D}'s {@link Node2D.transform}.
+   */
+  get_bone_angle(): float;
+  /** Returns the node's index as part of the entire skeleton. See {@link Skeleton2D}. */
+  get_index_in_skeleton(): int;
+  /** Returns the length of the bone in the {@link Bone2D} node. */
+  get_length(): float;
+  /**
+   * Returns the node's {@link rest} {@link Transform2D} if it doesn't have a parent, or its rest pose relative to its parent.
+   */
+  get_skeleton_rest(): Transform2D;
+  /**
+   * When set to `true`, the {@link Bone2D} node will attempt to automatically calculate the bone angle and length using the first child {@link Bone2D} node, if one exists. If none exist, the {@link Bone2D} cannot automatically calculate these values and will print a warning.
+   */
+  set_autocalculate_length_and_angle(auto_calculate: boolean): void;
+  /**
+   * Sets the bone angle for the {@link Bone2D}. This is typically set to the rotation from the {@link Bone2D} to a child {@link Bone2D} node.
+   * **Note:** This is different from the {@link Bone2D}'s rotation. The bone's angle is the rotation of the bone shown by the gizmo, which is unaffected by the {@link Bone2D}'s {@link Node2D.transform}.
+   */
+  set_bone_angle(angle: float): void;
+  /** Sets the length of the bone in the {@link Bone2D}. */
+  set_length(length: float): void;
+}

package/typings/classes/BoneAttachment3D.d.ts

@@ -0,0 +1,39 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * А node that dynamically copies or overrides the 3D transform of a bone in its parent {@link Skeleton3D}.
+ */
+declare class BoneAttachment3D extends Node3D {
+  /** The index of the attached bone. */
+  bone_idx: int;
+  /** The name of the attached bone. */
+  bone_name: string;
+  /** The {@link NodePath} to the external {@link Skeleton3D} node. */
+  external_skeleton: NodePath;
+  /**
+   * Whether the {@link BoneAttachment3D} node will override the bone pose of the bone it is attached to. When set to `true`, the {@link BoneAttachment3D} node can change the pose of the bone. When set to `false`, the {@link BoneAttachment3D} will always be set to the bone's transform.
+   * **Note:** This override performs interruptively in the skeleton update process using signals due to the old design. It may cause unintended behavior when used at the same time with {@link SkeletonModifier3D}.
+   */
+  override_pose: boolean;
+  /**
+   * <member name="use_external_skeleton" type="bool" setter="set_use_external_skeleton" getter="get_use_external_skeleton" default="false">
+   * Whether the {@link BoneAttachment3D} node will use an external {@link Skeleton3D} node rather than attempting to use its parent node as the {@link Skeleton3D}. When set to `true`, the {@link BoneAttachment3D} node will use the external {@link Skeleton3D} node set in {@link external_skeleton}.
+   */
+  physics_interpolation_mode: int;
+  set_bone_idx(value: int): void;
+  get_bone_idx(): int;
+  set_bone_name(value: string | NodePath): void;
+  get_bone_name(): string;
+  set_external_skeleton(value: NodePath | string): void;
+  get_external_skeleton(): NodePath;
+  set_override_pose(value: boolean): void;
+  get_override_pose(): boolean;
+
+  /** Returns the parent or external {@link Skeleton3D} node if it exists, otherwise returns `null`. */
+  get_skeleton(): Skeleton3D | null;
+  /**
+   * A function that is called automatically when the {@link Skeleton3D} is updated. This function is where the {@link BoneAttachment3D} node updates its position so it is correctly bound when it is *not* set to override the bone pose.
+   */
+  on_skeleton_update(): void;
+}

package/typings/classes/BoneConstraint3D.d.ts

@@ -0,0 +1,67 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that may modify Skeleton3D's bone with associating the two bones. */
+declare class BoneConstraint3D extends SkeletonModifier3D {
+  /** Clear all settings. */
+  clear_setting(): void;
+  /** Returns the apply amount of the setting at `index`. */
+  get_amount(index: int): float;
+  /** Returns the apply bone of the setting at `index`. This bone will be modified. */
+  get_apply_bone(index: int): int;
+  /** Returns the apply bone name of the setting at `index`. This bone will be modified. */
+  get_apply_bone_name(index: int): string;
+  /**
+   * Returns the reference bone of the setting at `index`.
+   * This bone will be only referenced and not modified by this modifier.
+   */
+  get_reference_bone(index: int): int;
+  /**
+   * Returns the reference bone name of the setting at `index`.
+   * This bone will be only referenced and not modified by this modifier.
+   */
+  get_reference_bone_name(index: int): string;
+  /**
+   * Returns the reference node path of the setting at `index`.
+   * This node will be only referenced and not modified by this modifier.
+   */
+  get_reference_node(index: int): NodePath;
+  /** Returns the reference target type of the setting at `index`. See also {@link ReferenceType}. */
+  get_reference_type(index: int): int;
+  /** Returns the number of settings in the modifier. */
+  get_setting_count(): int;
+  /** Sets the apply amount of the setting at `index` to `amount`. */
+  set_amount(index: int, amount: float): void;
+  /** Sets the apply bone of the setting at `index` to `bone`. This bone will be modified. */
+  set_apply_bone(index: int, bone: int): void;
+  /** Sets the apply bone of the setting at `index` to `bone_name`. This bone will be modified. */
+  set_apply_bone_name(index: int, bone_name: string | NodePath): void;
+  /**
+   * Sets the reference bone of the setting at `index` to `bone`.
+   * This bone will be only referenced and not modified by this modifier.
+   */
+  set_reference_bone(index: int, bone: int): void;
+  /**
+   * Sets the reference bone of the setting at `index` to `bone_name`.
+   * This bone will be only referenced and not modified by this modifier.
+   */
+  set_reference_bone_name(index: int, bone_name: string | NodePath): void;
+  /**
+   * Sets the reference node path of the setting at `index` to `node`.
+   * This node will be only referenced and not modified by this modifier.
+   */
+  set_reference_node(index: int, node: NodePath | string): void;
+  /** Sets the reference target type of the setting at `index` to `type`. See also {@link ReferenceType}. */
+  set_reference_type(index: int, type_: int): void;
+  /** Sets the number of settings in the modifier. */
+  set_setting_count(count: int): void;
+
+  // enum ReferenceType
+  /** The reference target is a bone. In this case, the reference target spaces is local space. */
+  static readonly REFERENCE_TYPE_BONE: int;
+  /**
+   * The reference target is a {@link Node3D}. In this case, the reference target spaces is model space.
+   * In other words, the reference target's coordinates are treated as if it were placed directly under {@link Skeleton3D} which parent of the {@link BoneConstraint3D}.
+   */
+  static readonly REFERENCE_TYPE_NODE: int;
+}

package/typings/classes/BoneMap.d.ts

@@ -0,0 +1,39 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Describes a mapping of bone names for retargeting {@link Skeleton3D} into common names defined by a {@link SkeletonProfile}.
+ */
+declare class BoneMap extends Resource {
+  /**
+   * A {@link SkeletonProfile} of the mapping target. Key names in the {@link BoneMap} are synchronized with it.
+   */
+  profile: SkeletonProfile | null;
+  set_profile(value: SkeletonProfile | null): void;
+  get_profile(): SkeletonProfile | null;
+
+  /**
+   * Returns a profile bone name having `skeleton_bone_name`. If not found, an empty {@link StringName} will be returned.
+   * In the retargeting process, the returned bone name is the bone name of the target skeleton.
+   */
+  find_profile_bone_name(skeleton_bone_name: string): string;
+  /**
+   * Returns a skeleton bone name is mapped to `profile_bone_name`.
+   * In the retargeting process, the returned bone name is the bone name of the source skeleton.
+   */
+  get_skeleton_bone_name(profile_bone_name: string): string;
+  /**
+   * Maps a skeleton bone name to `profile_bone_name`.
+   * In the retargeting process, the setting bone name is the bone name of the source skeleton.
+   */
+  set_skeleton_bone_name(profile_bone_name: string, skeleton_bone_name: string): void;
+
+  /**
+   * This signal is emitted when change the key value in the {@link BoneMap}. This is used to validate mapping and to update {@link BoneMap} editor.
+   */
+  bone_map_updated: Signal<[]>;
+  /**
+   * This signal is emitted when change the value in profile or change the reference of profile. This is used to update key names in the {@link BoneMap} and to redraw the {@link BoneMap} editor.
+   */
+  profile_updated: Signal<[]>;
+}

package/typings/classes/BoneTwistDisperser3D.d.ts

@@ -0,0 +1,126 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that propagates and disperses the child bone's twist to the parent bones. */
+declare class BoneTwistDisperser3D extends SkeletonModifier3D {
+  /**
+   * If `true`, the solver retrieves the bone axis from the bone pose every frame.
+   * If `false`, the solver retrieves the bone axis from the bone rest and caches it.
+   */
+  mutable_bone_axes: boolean;
+  /** The number of settings. */
+  setting_count: int;
+  set_mutable_bone_axes(value: boolean): void;
+  are_bone_axes_mutable(): boolean;
+  set_setting_count(value: int): void;
+  get_setting_count(): int;
+
+  /** Clears all settings. */
+  clear_settings(): void;
+  /** Returns the damping curve when {@link get_disperse_mode} is {@link DISPERSE_MODE_CUSTOM}. */
+  get_damping_curve(index: int): Curve | null;
+  /** Returns whether to use automatic amount assignment or to allow manual assignment. */
+  get_disperse_mode(index: int): int;
+  /** Returns the end bone index of the bone chain. */
+  get_end_bone(index: int): int;
+  /**
+   * Returns the tail direction of the end bone of the bone chain when {@link is_end_bone_extended} is `true`.
+   */
+  get_end_bone_direction(index: int): int;
+  /** Returns the end bone name of the bone chain. */
+  get_end_bone_name(index: int): string;
+  /** Returns the bone index at `joint` in the bone chain's joint list. */
+  get_joint_bone(index: int, joint: int): int;
+  /** Returns the bone name at `joint` in the bone chain's joint list. */
+  get_joint_bone_name(index: int, joint: int): string;
+  /** Returns the joint count of the bone chain's joint list. */
+  get_joint_count(index: int): int;
+  /**
+   * Returns the twist amount at `joint` in the bone chain's joint list when {@link get_disperse_mode} is {@link DISPERSE_MODE_CUSTOM}.
+   */
+  get_joint_twist_amount(index: int, joint: int): float;
+  /**
+   * Returns the reference bone to extract twist of the setting at `index`.
+   * This bone is either the end of the chain or its parent, depending on {@link is_end_bone_extended}.
+   */
+  get_reference_bone(index: int): int;
+  /**
+   * Returns the reference bone name to extract twist of the setting at `index`.
+   * This bone is either the end of the chain or its parent, depending on {@link is_end_bone_extended}.
+   */
+  get_reference_bone_name(index: int): string;
+  /** Returns the root bone index of the bone chain. */
+  get_root_bone(index: int): int;
+  /** Returns the root bone name of the bone chain. */
+  get_root_bone_name(index: int): string;
+  /**
+   * Returns the rotation to an arbitrary state before twisting for the current bone pose to extract the twist when {@link is_twist_from_rest} is `false`.
+   */
+  get_twist_from(index: int): Quaternion;
+  /**
+   * Returns the position at which to divide the segment between joints for weight assignment when {@link get_disperse_mode} is {@link DISPERSE_MODE_WEIGHTED}.
+   */
+  get_weight_position(index: int): float;
+  /** Returns `true` if the end bone is extended to have a tail. */
+  is_end_bone_extended(index: int): boolean;
+  /**
+   * Returns `true` if extracting the twist amount from the difference between the bone rest and the current bone pose.
+   */
+  is_twist_from_rest(index: int): boolean;
+  /** Sets the damping curve when {@link get_disperse_mode} is {@link DISPERSE_MODE_CUSTOM}. */
+  set_damping_curve(index: int, curve: Curve): void;
+  /** Sets whether to use automatic amount assignment or to allow manual assignment. */
+  set_disperse_mode(index: int, disperse_mode: int): void;
+  /** Sets the end bone index of the bone chain. */
+  set_end_bone(index: int, bone: int): void;
+  /** Sets the end bone tail direction of the bone chain when {@link is_end_bone_extended} is `true`. */
+  set_end_bone_direction(index: int, bone_direction: int): void;
+  /**
+   * Sets the end bone name of the bone chain.
+   * **Note:** The end bone must be a child of the root bone.
+   */
+  set_end_bone_name(index: int, bone_name: string | NodePath): void;
+  /**
+   * If `enabled` is `true`, the end bone is extended to have a tail.
+   * If `enabled` is `false`, {@link get_reference_bone} becomes a parent of the end bone and it uses the vector to the end bone as a twist axis.
+   */
+  set_extend_end_bone(index: int, enabled: boolean): void;
+  /**
+   * Sets the twist amount at `joint` in the bone chain's joint list when {@link get_disperse_mode} is {@link DISPERSE_MODE_CUSTOM}.
+   */
+  set_joint_twist_amount(index: int, joint: int, twist_amount: float): void;
+  /** Sets the root bone index of the bone chain. */
+  set_root_bone(index: int, bone: int): void;
+  /** Sets the root bone name of the bone chain. */
+  set_root_bone_name(index: int, bone_name: string | NodePath): void;
+  /**
+   * Sets the rotation to an arbitrary state before twisting for the current bone pose to extract the twist when {@link is_twist_from_rest} is `false`.
+   * In other words, by calling {@link set_twist_from} by {@link SkeletonModifier3D.modification_processed} of a specific {@link SkeletonModifier3D}, you can extract only the twists generated by modifiers processed after that but before this {@link BoneTwistDisperser3D}.
+   */
+  set_twist_from(index: int, from_: Quaternion | Basis): void;
+  /**
+   * If `enabled` is `true`, it extracts the twist amount from the difference between the bone rest and the current bone pose.
+   * If `enabled` is `false`, it extracts the twist amount from the difference between {@link get_twist_from} and the current bone pose. See also {@link set_twist_from}.
+   */
+  set_twist_from_rest(index: int, enabled: boolean): void;
+  /**
+   * Sets the position at which to divide the segment between joints for weight assignment when {@link get_disperse_mode} is {@link DISPERSE_MODE_WEIGHTED}.
+   * For example, when `weight_position` is `0.5`, if two bone segments with a length of `1.0` exist between three joints, weights are assigned to each joint from root to end at ratios of `0.5`, `1.0`, and `0.5`. Then amounts become `0.25`, `0.75`, and `1.0` respectively.
+   */
+  set_weight_position(index: int, weight_position: float): void;
+
+  // enum DisperseMode
+  /**
+   * Assign amounts so that they monotonically increase from `0.0` to `1.0`, ensuring all weights are equal. For example, with five joints, the amounts would be `0.2`, `0.4`, `0.6`, `0.8`, and `1.0` starting from the root bone.
+   */
+  static readonly DISPERSE_MODE_EVEN: int;
+  /**
+   * Assign amounts so that they monotonically increase from `0.0` to `1.0`, based on the length of the bones between joint segments. See also {@link set_weight_position}.
+   */
+  static readonly DISPERSE_MODE_WEIGHTED: int;
+  /**
+   * You can assign arbitrary amounts to the joint list. See also {@link set_joint_twist_amount}.
+   * When {@link is_end_bone_extended} is `false`, a child of the reference bone exists solely to determine the twist axis, so its custom amount has absolutely no effect at all.
+   */
+  static readonly DISPERSE_MODE_CUSTOM: int;
+}

package/typings/classes/BoxContainer.d.ts

@@ -0,0 +1,36 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container that arranges its child controls horizontally or vertically. */
+declare class BoxContainer extends Container {
+  /**
+   * The alignment of the container's children (must be one of {@link ALIGNMENT_BEGIN}, {@link ALIGNMENT_CENTER}, or {@link ALIGNMENT_END}).
+   */
+  alignment: int;
+  /**
+   * If `true`, the {@link BoxContainer} will arrange its children vertically, rather than horizontally.
+   * Can't be changed when using {@link HBoxContainer} and {@link VBoxContainer}.
+   */
+  vertical: boolean;
+  set_alignment(value: int): void;
+  get_alignment(): int;
+  set_vertical(value: boolean): void;
+  is_vertical(): boolean;
+
+  /**
+   * Adds a {@link Control} node to the box as a spacer. If `begin` is `true`, it will insert the {@link Control} node in front of all other children.
+   */
+  add_spacer(begin: boolean): Control;
+
+  // enum AlignmentMode
+  /**
+   * The child controls will be arranged at the beginning of the container, i.e. top if orientation is vertical, left if orientation is horizontal (right for RTL layout).
+   */
+  static readonly ALIGNMENT_BEGIN: int;
+  /** The child controls will be centered in the container. */
+  static readonly ALIGNMENT_CENTER: int;
+  /**
+   * The child controls will be arranged at the end of the container, i.e. bottom if orientation is vertical, right if orientation is horizontal (left for RTL layout).
+   */
+  static readonly ALIGNMENT_END: int;
+}