typescript-to-gdscript 0.1.0

package/typings/classes/SkeletonIK3D.d.ts

@@ -0,0 +1,83 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A node used to rotate all bones of a {@link Skeleton3D} bone chain a way that places the end bone at a desired 3D position.
+ */
+declare class SkeletonIK3D extends SkeletonModifier3D {
+  /**
+   * Interpolation value for how much the IK results are applied to the current skeleton bone chain. A value of `1.0` will overwrite all skeleton bone transforms completely while a value of `0.0` will visually disable the SkeletonIK.
+   */
+  interpolation: float;
+  /**
+   * Secondary target position (first is {@link target} property or {@link target_node}) for the IK chain. Use magnet position (pole target) to control the bending of the IK chain. Only works if the bone chain has more than 2 bones. The middle chain bone position will be linearly interpolated with the magnet position.
+   */
+  magnet: Vector3;
+  /**
+   * Number of iteration loops used by the IK solver to produce more accurate (and elegant) bone chain results.
+   */
+  max_iterations: int;
+  /**
+   * The minimum distance between bone and goal target. If the distance is below this value, the IK solver stops further iterations.
+   */
+  min_distance: float;
+  /**
+   * If `true` overwrites the rotation of the tip bone with the rotation of the {@link target} (or {@link target_node} if defined).
+   */
+  override_tip_basis: boolean;
+  /** The name of the current root bone, the first bone in the IK chain. */
+  root_bone: string;
+  /**
+   * First target of the IK chain where the tip bone is placed and, if {@link override_tip_basis} is `true`, how the tip bone is rotated. If a {@link target_node} path is available the nodes transform is used instead and this property is ignored.
+   */
+  target: Transform3D;
+  /**
+   * Target node {@link NodePath} for the IK chain. If available, the node's current {@link Transform3D} is used instead of the {@link target} property.
+   */
+  target_node: NodePath;
+  /**
+   * The name of the current tip bone, the last bone in the IK chain placed at the {@link target} transform (or {@link target_node} if defined).
+   */
+  tip_bone: string;
+  /**
+   * If `true`, instructs the IK solver to consider the secondary magnet target (pole target) when calculating the bone chain. Use the magnet position (pole target) to control the bending of the IK chain.
+   */
+  use_magnet: boolean;
+  set_interpolation(value: float): void;
+  get_interpolation(): float;
+  set_magnet_position(value: Vector3 | Vector3i): void;
+  get_magnet_position(): Vector3;
+  set_max_iterations(value: int): void;
+  get_max_iterations(): int;
+  set_min_distance(value: float): void;
+  get_min_distance(): float;
+  set_override_tip_basis(value: boolean): void;
+  is_override_tip_basis(): boolean;
+  set_root_bone(value: string): void;
+  get_root_bone(): string;
+  set_target_transform(value: Transform3D | Projection): void;
+  get_target_transform(): Transform3D;
+  set_target_node(value: NodePath | string): void;
+  get_target_node(): NodePath;
+  set_tip_bone(value: string): void;
+  get_tip_bone(): string;
+  set_use_magnet(value: boolean): void;
+  is_using_magnet(): boolean;
+
+  /**
+   * Returns the parent {@link Skeleton3D} node that was present when SkeletonIK entered the scene tree. Returns `null` if the parent node was not a {@link Skeleton3D} node when SkeletonIK3D entered the scene tree.
+   */
+  get_parent_skeleton(): Skeleton3D | null;
+  /**
+   * Returns `true` if SkeletonIK is applying IK effects on continues frames to the {@link Skeleton3D} bones. Returns `false` if SkeletonIK is stopped or {@link start} was used with the `one_time` parameter set to `true`.
+   */
+  is_running(): boolean;
+  /**
+   * Starts applying IK effects on each frame to the {@link Skeleton3D} bones but will only take effect starting on the next frame. If `one_time` is `true`, this will take effect immediately but also reset on the next frame.
+   */
+  start(one_time?: boolean): void;
+  /**
+   * Stops applying IK effects on each frame to the {@link Skeleton3D} bones and also calls {@link Skeleton3D.clear_bones_global_pose_override} to remove existing overrides on all bones.
+   */
+  stop(): void;
+}

package/typings/classes/SkeletonModification2D.d.ts

@@ -0,0 +1,52 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for resources that operate on {@link Bone2D}s in a {@link Skeleton2D}. */
+declare class SkeletonModification2D extends Resource {
+  /**
+   * If `true`, the modification's {@link _execute} function will be called by the {@link SkeletonModificationStack2D}.
+   */
+  enabled: boolean;
+  /**
+   * The execution mode for the modification. This tells the modification stack when to execute the modification. Some modifications have settings that are only available in certain execution modes.
+   */
+  execution_mode: int;
+  set_enabled(value: boolean): void;
+  get_enabled(): boolean;
+  set_execution_mode(value: int): void;
+  get_execution_mode(): int;
+
+  /**
+   * Used for drawing **editor-only** modification gizmos. This function will only be called in the Godot editor and can be overridden to draw custom gizmos.
+   * **Note:** You will need to use the Skeleton2D from {@link SkeletonModificationStack2D.get_skeleton} and it's draw functions, as the {@link SkeletonModification2D} resource cannot draw on its own.
+   */
+  _draw_editor_gizmo(): void;
+  /**
+   * Executes the given modification. This is where the modification performs whatever function it is designed to do.
+   */
+  _execute(delta: float): void;
+  /** Called when the modification is setup. This is where the modification performs initialization. */
+  _setup_modification(modification_stack: SkeletonModificationStack2D): void;
+  /**
+   * Takes an angle and clamps it so it is within the passed-in `min` and `max` range. `invert` will inversely clamp the angle, clamping it to the range outside of the given bounds.
+   */
+  clamp_angle(angle: float, min: float, max: float, invert: boolean): float;
+  /**
+   * Returns whether this modification will call {@link _draw_editor_gizmo} in the Godot editor to draw modification-specific gizmos.
+   */
+  get_editor_draw_gizmo(): boolean;
+  /** Returns whether this modification has been successfully setup or not. */
+  get_is_setup(): boolean;
+  /**
+   * Returns the {@link SkeletonModificationStack2D} that this modification is bound to. Through the modification stack, you can access the Skeleton2D the modification is operating on.
+   */
+  get_modification_stack(): SkeletonModificationStack2D | null;
+  /**
+   * Sets whether this modification will call {@link _draw_editor_gizmo} in the Godot editor to draw modification-specific gizmos.
+   */
+  set_editor_draw_gizmo(draw_gizmo: boolean): void;
+  /**
+   * Manually allows you to set the setup state of the modification. This function should only rarely be used, as the {@link SkeletonModificationStack2D} the modification is bound to should handle setting the modification up.
+   */
+  set_is_setup(is_setup: boolean): void;
+}

package/typings/classes/SkeletonModification2DCCDIK.d.ts

@@ -0,0 +1,64 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A modification that uses CCDIK to manipulate a series of bones to reach a target in 2D. */
+declare class SkeletonModification2DCCDIK extends SkeletonModification2D {
+  /** The number of CCDIK joints in the CCDIK modification. */
+  ccdik_data_chain_length: int;
+  /**
+   * The NodePath to the node that is the target for the CCDIK modification. This node is what the CCDIK chain will attempt to rotate the bone chain to.
+   */
+  target_nodepath: NodePath;
+  /**
+   * The end position of the CCDIK chain. Typically, this should be a child of a {@link Bone2D} node attached to the final {@link Bone2D} in the CCDIK chain.
+   */
+  tip_nodepath: NodePath;
+  set_ccdik_data_chain_length(value: int): void;
+  get_ccdik_data_chain_length(): int;
+  set_target_node(value: NodePath | string): void;
+  get_target_node(): NodePath;
+  set_tip_node(value: NodePath | string): void;
+  get_tip_node(): NodePath;
+
+  /** Returns the {@link Bone2D} node assigned to the CCDIK joint at `joint_idx`. */
+  get_ccdik_joint_bone2d_node(joint_idx: int): NodePath;
+  /** Returns the index of the {@link Bone2D} node assigned to the CCDIK joint at `joint_idx`. */
+  get_ccdik_joint_bone_index(joint_idx: int): int;
+  /**
+   * Returns whether the CCDIK joint at `joint_idx` uses an inverted joint constraint. See {@link set_ccdik_joint_constraint_angle_invert} for details.
+   */
+  get_ccdik_joint_constraint_angle_invert(joint_idx: int): boolean;
+  /** Returns the maximum angle constraint for the joint at `joint_idx`. */
+  get_ccdik_joint_constraint_angle_max(joint_idx: int): float;
+  /** Returns the minimum angle constraint for the joint at `joint_idx`. */
+  get_ccdik_joint_constraint_angle_min(joint_idx: int): float;
+  /** Returns whether angle constraints on the CCDIK joint at `joint_idx` are enabled. */
+  get_ccdik_joint_enable_constraint(joint_idx: int): boolean;
+  /**
+   * Returns whether the joint at `joint_idx` is set to rotate from the joint, `true`, or to rotate from the tip, `false`. The default is to rotate from the tip.
+   */
+  get_ccdik_joint_rotate_from_joint(joint_idx: int): boolean;
+  /** Sets the {@link Bone2D} node assigned to the CCDIK joint at `joint_idx`. */
+  set_ccdik_joint_bone2d_node(joint_idx: int, bone2d_nodepath: NodePath | string): void;
+  /**
+   * Sets the bone index, `bone_idx`, of the CCDIK joint at `joint_idx`. When possible, this will also update the `bone2d_node` of the CCDIK joint based on data provided by the linked skeleton.
+   */
+  set_ccdik_joint_bone_index(joint_idx: int, bone_idx: int): void;
+  /**
+   * Sets whether the CCDIK joint at `joint_idx` uses an inverted joint constraint.
+   * An inverted joint constraint only constraints the CCDIK joint to the angles *outside of* the inputted minimum and maximum angles. For this reason, it is referred to as an inverted joint constraint, as it constraints the joint to the outside of the inputted values.
+   */
+  set_ccdik_joint_constraint_angle_invert(joint_idx: int, invert: boolean): void;
+  /** Sets the maximum angle constraint for the joint at `joint_idx`. */
+  set_ccdik_joint_constraint_angle_max(joint_idx: int, angle_max: float): void;
+  /** Sets the minimum angle constraint for the joint at `joint_idx`. */
+  set_ccdik_joint_constraint_angle_min(joint_idx: int, angle_min: float): void;
+  /**
+   * Determines whether angle constraints on the CCDIK joint at `joint_idx` are enabled. When `true`, constraints will be enabled and taken into account when solving.
+   */
+  set_ccdik_joint_enable_constraint(joint_idx: int, enable_constraint: boolean): void;
+  /**
+   * Sets whether the joint at `joint_idx` is set to rotate from the joint, `true`, or to rotate from the tip, `false`.
+   */
+  set_ccdik_joint_rotate_from_joint(joint_idx: int, rotate_from_joint: boolean): void;
+}

package/typings/classes/SkeletonModification2DFABRIK.d.ts

@@ -0,0 +1,40 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A modification that uses FABRIK to manipulate a series of {@link Bone2D} nodes to reach a target. */
+declare class SkeletonModification2DFABRIK extends SkeletonModification2D {
+  /** The number of FABRIK joints in the FABRIK modification. */
+  fabrik_data_chain_length: int;
+  /**
+   * The NodePath to the node that is the target for the FABRIK modification. This node is what the FABRIK chain will attempt to rotate the bone chain to.
+   */
+  target_nodepath: NodePath;
+  set_fabrik_data_chain_length(value: int): void;
+  get_fabrik_data_chain_length(): int;
+  set_target_node(value: NodePath | string): void;
+  get_target_node(): NodePath;
+
+  /** Returns the {@link Bone2D} node assigned to the FABRIK joint at `joint_idx`. */
+  get_fabrik_joint_bone2d_node(joint_idx: int): NodePath;
+  /** Returns the index of the {@link Bone2D} node assigned to the FABRIK joint at `joint_idx`. */
+  get_fabrik_joint_bone_index(joint_idx: int): int;
+  /** Returns the magnet position vector for the joint at `joint_idx`. */
+  get_fabrik_joint_magnet_position(joint_idx: int): Vector2;
+  /**
+   * Returns whether the joint is using the target's rotation rather than allowing FABRIK to rotate the joint. This option only applies to the tip/final joint in the chain.
+   */
+  get_fabrik_joint_use_target_rotation(joint_idx: int): boolean;
+  /** Sets the {@link Bone2D} node assigned to the FABRIK joint at `joint_idx`. */
+  set_fabrik_joint_bone2d_node(joint_idx: int, bone2d_nodepath: NodePath | string): void;
+  /**
+   * Sets the bone index, `bone_idx`, of the FABRIK joint at `joint_idx`. When possible, this will also update the `bone2d_node` of the FABRIK joint based on data provided by the linked skeleton.
+   */
+  set_fabrik_joint_bone_index(joint_idx: int, bone_idx: int): void;
+  /** Sets the magnet position vector for the joint at `joint_idx`. */
+  set_fabrik_joint_magnet_position(joint_idx: int, magnet_position: Vector2 | Vector2i): void;
+  /**
+   * Sets whether the joint at `joint_idx` will use the target node's rotation rather than letting FABRIK rotate the node.
+   * **Note:** This option only works for the tip/final joint in the chain. For all other nodes, this option will be ignored.
+   */
+  set_fabrik_joint_use_target_rotation(joint_idx: int, use_target_rotation: boolean): void;
+}

package/typings/classes/SkeletonModification2DJiggle.d.ts

@@ -0,0 +1,97 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A modification that jiggles {@link Bone2D} nodes as they move towards a target. */
+declare class SkeletonModification2DJiggle extends SkeletonModification2D {
+  /**
+   * The default amount of damping applied to the Jiggle joints, if they are not overridden. Higher values lead to more of the calculated velocity being applied.
+   */
+  damping: float;
+  /** The default amount of gravity applied to the Jiggle joints, if they are not overridden. */
+  gravity: Vector2;
+  /** The amount of Jiggle joints in the Jiggle modification. */
+  jiggle_data_chain_length: int;
+  /**
+   * The default amount of mass assigned to the Jiggle joints, if they are not overridden. Higher values lead to faster movements and more overshooting.
+   */
+  mass: float;
+  /**
+   * The default amount of stiffness assigned to the Jiggle joints, if they are not overridden. Higher values act more like springs, quickly moving into the correct position.
+   */
+  stiffness: float;
+  /**
+   * The NodePath to the node that is the target for the Jiggle modification. This node is what the Jiggle chain will attempt to rotate the bone chain to.
+   */
+  target_nodepath: NodePath;
+  /**
+   * Whether the gravity vector, {@link gravity}, should be applied to the Jiggle joints, assuming they are not overriding the default settings.
+   */
+  use_gravity: boolean;
+  set_damping(value: float): void;
+  get_damping(): float;
+  set_gravity(value: Vector2 | Vector2i): void;
+  get_gravity(): Vector2;
+  set_jiggle_data_chain_length(value: int): void;
+  get_jiggle_data_chain_length(): int;
+  set_mass(value: float): void;
+  get_mass(): float;
+  set_stiffness(value: float): void;
+  get_stiffness(): float;
+  set_target_node(value: NodePath | string): void;
+  get_target_node(): NodePath;
+  set_use_gravity(value: boolean): void;
+  get_use_gravity(): boolean;
+
+  /** Returns the collision mask used by the Jiggle modifier when collisions are enabled. */
+  get_collision_mask(): int;
+  /** Returns the {@link Bone2D} node assigned to the Jiggle joint at `joint_idx`. */
+  get_jiggle_joint_bone2d_node(joint_idx: int): NodePath;
+  /** Returns the index of the {@link Bone2D} node assigned to the Jiggle joint at `joint_idx`. */
+  get_jiggle_joint_bone_index(joint_idx: int): int;
+  /** Returns the amount of damping of the Jiggle joint at `joint_idx`. */
+  get_jiggle_joint_damping(joint_idx: int): float;
+  /**
+   * Returns a {@link Vector2} representing the amount of gravity the Jiggle joint at `joint_idx` is influenced by.
+   */
+  get_jiggle_joint_gravity(joint_idx: int): Vector2;
+  /** Returns the amount of mass of the jiggle joint at `joint_idx`. */
+  get_jiggle_joint_mass(joint_idx: int): float;
+  /**
+   * Returns a boolean that indicates whether the joint at `joint_idx` is overriding the default Jiggle joint data defined in the modification.
+   */
+  get_jiggle_joint_override(joint_idx: int): boolean;
+  /** Returns the stiffness of the Jiggle joint at `joint_idx`. */
+  get_jiggle_joint_stiffness(joint_idx: int): float;
+  /** Returns a boolean that indicates whether the joint at `joint_idx` is using gravity or not. */
+  get_jiggle_joint_use_gravity(joint_idx: int): boolean;
+  /** Returns whether the jiggle modifier is taking physics colliders into account when solving. */
+  get_use_colliders(): boolean;
+  /**
+   * Sets the collision mask that the Jiggle modifier will use when reacting to colliders, if the Jiggle modifier is set to take colliders into account.
+   */
+  set_collision_mask(collision_mask: int): void;
+  /** Sets the {@link Bone2D} node assigned to the Jiggle joint at `joint_idx`. */
+  set_jiggle_joint_bone2d_node(joint_idx: int, bone2d_node: NodePath | string): void;
+  /**
+   * Sets the bone index, `bone_idx`, of the Jiggle joint at `joint_idx`. When possible, this will also update the `bone2d_node` of the Jiggle joint based on data provided by the linked skeleton.
+   */
+  set_jiggle_joint_bone_index(joint_idx: int, bone_idx: int): void;
+  /** Sets the amount of damping of the Jiggle joint at `joint_idx`. */
+  set_jiggle_joint_damping(joint_idx: int, damping: float): void;
+  /** Sets the gravity vector of the Jiggle joint at `joint_idx`. */
+  set_jiggle_joint_gravity(joint_idx: int, gravity: Vector2 | Vector2i): void;
+  /** Sets the of mass of the Jiggle joint at `joint_idx`. */
+  set_jiggle_joint_mass(joint_idx: int, mass: float): void;
+  /**
+   * Sets whether the Jiggle joint at `joint_idx` should override the default Jiggle joint settings. Setting this to `true` will make the joint use its own settings rather than the default ones attached to the modification.
+   */
+  set_jiggle_joint_override(joint_idx: int, override: boolean): void;
+  /** Sets the of stiffness of the Jiggle joint at `joint_idx`. */
+  set_jiggle_joint_stiffness(joint_idx: int, stiffness: float): void;
+  /** Sets whether the Jiggle joint at `joint_idx` should use gravity. */
+  set_jiggle_joint_use_gravity(joint_idx: int, use_gravity: boolean): void;
+  /**
+   * If `true`, the Jiggle modifier will take colliders into account, keeping them from entering into these collision objects.
+   */
+  set_use_colliders(use_colliders: boolean): void;
+}

package/typings/classes/SkeletonModification2DLookAt.d.ts

@@ -0,0 +1,48 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A modification that rotates a {@link Bone2D} node to look at a target. */
+declare class SkeletonModification2DLookAt extends SkeletonModification2D {
+  /** The {@link Bone2D} node that the modification will operate on. */
+  bone2d_node: NodePath;
+  /** The index of the {@link Bone2D} node that the modification will operate on. */
+  bone_index: int;
+  /**
+   * The NodePath to the node that is the target for the LookAt modification. This node is what the modification will rotate the {@link Bone2D} to.
+   */
+  target_nodepath: NodePath;
+  set_bone2d_node(value: NodePath | string): void;
+  get_bone2d_node(): NodePath;
+  set_bone_index(value: int): void;
+  get_bone_index(): int;
+  set_target_node(value: NodePath | string): void;
+  get_target_node(): NodePath;
+
+  /** Returns the amount of additional rotation that is applied after the LookAt modification executes. */
+  get_additional_rotation(): float;
+  /** Returns whether the constraints to this modification are inverted or not. */
+  get_constraint_angle_invert(): boolean;
+  /** Returns the constraint's maximum allowed angle. */
+  get_constraint_angle_max(): float;
+  /** Returns the constraint's minimum allowed angle. */
+  get_constraint_angle_min(): float;
+  /** Returns `true` if the LookAt modification is using constraints. */
+  get_enable_constraint(): boolean;
+  /**
+   * Sets the amount of additional rotation that is to be applied after executing the modification. This allows for offsetting the results by the inputted rotation amount.
+   */
+  set_additional_rotation(rotation: float): void;
+  /**
+   * When `true`, the modification will use an inverted joint constraint.
+   * An inverted joint constraint only constraints the {@link Bone2D} to the angles *outside of* the inputted minimum and maximum angles. For this reason, it is referred to as an inverted joint constraint, as it constraints the joint to the outside of the inputted values.
+   */
+  set_constraint_angle_invert(invert: boolean): void;
+  /** Sets the constraint's maximum allowed angle. */
+  set_constraint_angle_max(angle_max: float): void;
+  /** Sets the constraint's minimum allowed angle. */
+  set_constraint_angle_min(angle_min: float): void;
+  /**
+   * Sets whether this modification will use constraints or not. When `true`, constraints will be applied when solving the LookAt modification.
+   */
+  set_enable_constraint(enable_constraint: boolean): void;
+}

package/typings/classes/SkeletonModification2DPhysicalBones.d.ts

@@ -0,0 +1,32 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A modification that applies the transforms of {@link PhysicalBone2D} nodes to {@link Bone2D} nodes. */
+declare class SkeletonModification2DPhysicalBones extends SkeletonModification2D {
+  /** The number of {@link PhysicalBone2D} nodes linked in this modification. */
+  physical_bone_chain_length: int;
+  set_physical_bone_chain_length(value: int): void;
+  get_physical_bone_chain_length(): int;
+
+  /**
+   * Empties the list of {@link PhysicalBone2D} nodes and populates it with all {@link PhysicalBone2D} nodes that are children of the {@link Skeleton2D}.
+   */
+  fetch_physical_bones(): void;
+  /** Returns the {@link PhysicalBone2D} node at `joint_idx`. */
+  get_physical_bone_node(joint_idx: int): NodePath;
+  /**
+   * Sets the {@link PhysicalBone2D} node at `joint_idx`.
+   * **Note:** This is just the index used for this modification, not the bone index used in the {@link Skeleton2D}.
+   */
+  set_physical_bone_node(joint_idx: int, physicalbone2d_node: NodePath | string): void;
+  /**
+   * Tell the {@link PhysicalBone2D} nodes to start simulating and interacting with the physics world.
+   * Optionally, an array of bone names can be passed to this function, and that will cause only {@link PhysicalBone2D} nodes with those names to start simulating.
+   */
+  start_simulation(bones?: Array<string>): void;
+  /**
+   * Tell the {@link PhysicalBone2D} nodes to stop simulating and interacting with the physics world.
+   * Optionally, an array of bone names can be passed to this function, and that will cause only {@link PhysicalBone2D} nodes with those names to stop simulating.
+   */
+  stop_simulation(bones?: Array<string>): void;
+}

package/typings/classes/SkeletonModification2DStackHolder.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A modification that holds and executes a {@link SkeletonModificationStack2D}. */
+declare class SkeletonModification2DStackHolder extends SkeletonModification2D {
+  /** Returns the {@link SkeletonModificationStack2D} that this modification is holding. */
+  get_held_modification_stack(): SkeletonModificationStack2D | null;
+  /**
+   * Sets the {@link SkeletonModificationStack2D} that this modification is holding. This modification stack will then be executed when this modification is executed.
+   */
+  set_held_modification_stack(held_modification_stack: SkeletonModificationStack2D): void;
+}

package/typings/classes/SkeletonModification2DTwoBoneIK.d.ts

@@ -0,0 +1,57 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A modification that rotates two bones using the law of cosines to reach the target. */
+declare class SkeletonModification2DTwoBoneIK extends SkeletonModification2D {
+  /**
+   * If `true`, the bones in the modification will bend outward as opposed to inwards when contracting. If `false`, the bones will bend inwards when contracting.
+   */
+  flip_bend_direction: boolean;
+  /**
+   * The maximum distance the target can be at. If the target is farther than this distance, the modification will solve as if it's at this maximum distance. When set to `0`, the modification will solve without distance constraints.
+   */
+  target_maximum_distance: float;
+  /**
+   * The minimum distance the target can be at. If the target is closer than this distance, the modification will solve as if it's at this minimum distance. When set to `0`, the modification will solve without distance constraints.
+   */
+  target_minimum_distance: float;
+  /**
+   * The NodePath to the node that is the target for the TwoBoneIK modification. This node is what the modification will use when bending the {@link Bone2D} nodes.
+   */
+  target_nodepath: NodePath;
+  set_flip_bend_direction(value: boolean): void;
+  get_flip_bend_direction(): boolean;
+  set_target_maximum_distance(value: float): void;
+  get_target_maximum_distance(): float;
+  set_target_minimum_distance(value: float): void;
+  get_target_minimum_distance(): float;
+  set_target_node(value: NodePath | string): void;
+  get_target_node(): NodePath;
+
+  /** Returns the {@link Bone2D} node that is being used as the first bone in the TwoBoneIK modification. */
+  get_joint_one_bone2d_node(): NodePath;
+  /**
+   * Returns the index of the {@link Bone2D} node that is being used as the first bone in the TwoBoneIK modification.
+   */
+  get_joint_one_bone_idx(): int;
+  /**
+   * Returns the {@link Bone2D} node that is being used as the second bone in the TwoBoneIK modification.
+   */
+  get_joint_two_bone2d_node(): NodePath;
+  /**
+   * Returns the index of the {@link Bone2D} node that is being used as the second bone in the TwoBoneIK modification.
+   */
+  get_joint_two_bone_idx(): int;
+  /** Sets the {@link Bone2D} node that is being used as the first bone in the TwoBoneIK modification. */
+  set_joint_one_bone2d_node(bone2d_node: NodePath | string): void;
+  /**
+   * Sets the index of the {@link Bone2D} node that is being used as the first bone in the TwoBoneIK modification.
+   */
+  set_joint_one_bone_idx(bone_idx: int): void;
+  /** Sets the {@link Bone2D} node that is being used as the second bone in the TwoBoneIK modification. */
+  set_joint_two_bone2d_node(bone2d_node: NodePath | string): void;
+  /**
+   * Sets the index of the {@link Bone2D} node that is being used as the second bone in the TwoBoneIK modification.
+   */
+  set_joint_two_bone_idx(bone_idx: int): void;
+}

package/typings/classes/SkeletonModificationStack2D.d.ts

@@ -0,0 +1,46 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A resource that holds a stack of {@link SkeletonModification2D}s. */
+declare class SkeletonModificationStack2D extends Resource {
+  /**
+   * If `true`, the modification's in the stack will be called. This is handled automatically through the {@link Skeleton2D} node.
+   */
+  enabled: boolean;
+  /** The number of modifications in the stack. */
+  modification_count: int;
+  /**
+   * The interpolation strength of the modifications in stack. A value of `0` will make it where the modifications are not applied, a strength of `0.5` will be half applied, and a strength of `1` will allow the modifications to be fully applied and override the {@link Skeleton2D} {@link Bone2D} poses.
+   */
+  strength: float;
+  set_enabled(value: boolean): void;
+  get_enabled(): boolean;
+  set_modification_count(value: int): void;
+  get_modification_count(): int;
+  set_strength(value: float): void;
+  get_strength(): float;
+
+  /** Adds the passed-in {@link SkeletonModification2D} to the stack. */
+  add_modification(modification: SkeletonModification2D): void;
+  /** Deletes the {@link SkeletonModification2D} at the index position `mod_idx`, if it exists. */
+  delete_modification(mod_idx: int): void;
+  /** Enables all {@link SkeletonModification2D}s in the stack. */
+  enable_all_modifications(enabled: boolean): void;
+  /**
+   * Executes all of the {@link SkeletonModification2D}s in the stack that use the same execution mode as the passed-in `execution_mode`, starting from index `0` to {@link modification_count}.
+   * **Note:** The order of the modifications can matter depending on the modifications. For example, modifications on a spine should operate before modifications on the arms in order to get proper results.
+   */
+  execute(delta: float, execution_mode: int): void;
+  /** Returns a boolean that indicates whether the modification stack is setup and can execute. */
+  get_is_setup(): boolean;
+  /** Returns the {@link SkeletonModification2D} at the passed-in index, `mod_idx`. */
+  get_modification(mod_idx: int): SkeletonModification2D | null;
+  /** Returns the {@link Skeleton2D} node that the SkeletonModificationStack2D is bound to. */
+  get_skeleton(): Skeleton2D | null;
+  /** Sets the modification at `mod_idx` to the passed-in modification, `modification`. */
+  set_modification(mod_idx: int, modification: SkeletonModification2D): void;
+  /**
+   * Sets up the modification stack so it can execute. This function should be called by {@link Skeleton2D} and shouldn't be manually called unless you know what you are doing.
+   */
+  setup(): void;
+}

package/typings/classes/SkeletonModifier3D.d.ts

@@ -0,0 +1,101 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that may modify a Skeleton3D's bones. */
+declare class SkeletonModifier3D extends Node3D {
+  /** If `true`, the {@link SkeletonModifier3D} will be processing. */
+  active: boolean;
+  /**
+   * Sets the influence of the modification.
+   * **Note:** This value is used by {@link Skeleton3D} to blend, so the {@link SkeletonModifier3D} should always apply only 100% of the result without interpolation.
+   */
+  influence: float;
+  set_active(value: boolean): void;
+  is_active(): boolean;
+  set_influence(value: float): void;
+  get_influence(): float;
+
+  /**
+   * Override this virtual method to implement a custom skeleton modifier. You should do things like get the {@link Skeleton3D}'s current pose and apply the pose here.
+   * {@link _process_modification} must not apply {@link influence} to bone poses because the {@link Skeleton3D} automatically applies influence to all bone poses set by the modifier.
+   */
+  _process_modification(): void;
+  /**
+   * Override this virtual method to implement a custom skeleton modifier. You should do things like get the {@link Skeleton3D}'s current pose and apply the pose here.
+   * {@link _process_modification_with_delta} must not apply {@link influence} to bone poses because the {@link Skeleton3D} automatically applies influence to all bone poses set by the modifier.
+   * `delta` is passed from parent {@link Skeleton3D}. See also {@link Skeleton3D.advance}.
+   * **Note:** This method may be called outside {@link Node._process} and {@link Node._physics_process} with `delta` is `0.0`, since the modification should be processed immediately after initialization of the {@link Skeleton3D}.
+   */
+  _process_modification_with_delta(delta: float): void;
+  /** Called when the skeleton is changed. */
+  _skeleton_changed(old_skeleton: Skeleton3D, new_skeleton: Skeleton3D): void;
+  /**
+   * Called when bone names and indices need to be validated, such as when entering the scene tree or changing skeleton.
+   */
+  _validate_bone_names(): void;
+  /** Returns the parent {@link Skeleton3D} node if it exists. Otherwise, returns `null`. */
+  get_skeleton(): Skeleton3D | null;
+
+  /**
+   * Notifies when the modification have been finished.
+   * **Note:** If you want to get the modified bone pose by the modifier, you must use {@link Skeleton3D.get_bone_pose} or {@link Skeleton3D.get_bone_global_pose} at the moment this signal is fired.
+   */
+  modification_processed: Signal<[]>;
+
+  // enum BoneAxis
+  /** Enumerated value for the +X axis. */
+  static readonly BONE_AXIS_PLUS_X: int;
+  /** Enumerated value for the -X axis. */
+  static readonly BONE_AXIS_MINUS_X: int;
+  /** Enumerated value for the +Y axis. */
+  static readonly BONE_AXIS_PLUS_Y: int;
+  /** Enumerated value for the -Y axis. */
+  static readonly BONE_AXIS_MINUS_Y: int;
+  /** Enumerated value for the +Z axis. */
+  static readonly BONE_AXIS_PLUS_Z: int;
+  /** Enumerated value for the -Z axis. */
+  static readonly BONE_AXIS_MINUS_Z: int;
+  // enum BoneDirection
+  /** Enumerated value for the +X axis. */
+  static readonly BONE_DIRECTION_PLUS_X: int;
+  /** Enumerated value for the -X axis. */
+  static readonly BONE_DIRECTION_MINUS_X: int;
+  /** Enumerated value for the +Y axis. */
+  static readonly BONE_DIRECTION_PLUS_Y: int;
+  /** Enumerated value for the -Y axis. */
+  static readonly BONE_DIRECTION_MINUS_Y: int;
+  /** Enumerated value for the +Z axis. */
+  static readonly BONE_DIRECTION_PLUS_Z: int;
+  /** Enumerated value for the -Z axis. */
+  static readonly BONE_DIRECTION_MINUS_Z: int;
+  /** Enumerated value for the axis from a parent bone to the child bone. */
+  static readonly BONE_DIRECTION_FROM_PARENT: int;
+  // enum SecondaryDirection
+  /** Enumerated value for the case when the axis is undefined. */
+  static readonly SECONDARY_DIRECTION_NONE: int;
+  /** Enumerated value for the +X axis. */
+  static readonly SECONDARY_DIRECTION_PLUS_X: int;
+  /** Enumerated value for the -X axis. */
+  static readonly SECONDARY_DIRECTION_MINUS_X: int;
+  /** Enumerated value for the +Y axis. */
+  static readonly SECONDARY_DIRECTION_PLUS_Y: int;
+  /** Enumerated value for the -Y axis. */
+  static readonly SECONDARY_DIRECTION_MINUS_Y: int;
+  /** Enumerated value for the +Z axis. */
+  static readonly SECONDARY_DIRECTION_PLUS_Z: int;
+  /** Enumerated value for the -Z axis. */
+  static readonly SECONDARY_DIRECTION_MINUS_Z: int;
+  /** Enumerated value for an optional axis. */
+  static readonly SECONDARY_DIRECTION_CUSTOM: int;
+  // enum RotationAxis
+  /** Enumerated value for the rotation of the X axis. */
+  static readonly ROTATION_AXIS_X: int;
+  /** Enumerated value for the rotation of the Y axis. */
+  static readonly ROTATION_AXIS_Y: int;
+  /** Enumerated value for the rotation of the Z axis. */
+  static readonly ROTATION_AXIS_Z: int;
+  /** Enumerated value for the unconstrained rotation. */
+  static readonly ROTATION_AXIS_ALL: int;
+  /** Enumerated value for an optional rotation axis. */
+  static readonly ROTATION_AXIS_CUSTOM: int;
+}