typescript-to-gdscript 0.1.0

package/typings/classes/ShapeCast2D.d.ts

@@ -0,0 +1,107 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D shape that sweeps a region of space to detect {@link CollisionObject2D}s. */
+declare class ShapeCast2D extends Node2D {
+  /** If `true`, collisions with {@link Area2D}s will be reported. */
+  collide_with_areas: boolean;
+  /** If `true`, collisions with {@link PhysicsBody2D}s will be reported. */
+  collide_with_bodies: boolean;
+  /**
+   * The shape's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * Returns the complete collision information from the collision sweep. The data returned is the same as in the {@link PhysicsDirectSpaceState2D.get_rest_info} method.
+   */
+  collision_result: Array<unknown>;
+  /** If `true`, collisions will be reported. */
+  enabled: boolean;
+  /** If `true`, the parent node will be excluded from collision detection. */
+  exclude_parent: boolean;
+  /**
+   * The collision margin for the shape. A larger margin helps detecting collisions more consistently, at the cost of precision.
+   */
+  margin: float;
+  /** The number of intersections can be limited with this parameter, to reduce the processing time. */
+  max_results: int;
+  /** The shape to be used for collision queries. */
+  shape: Shape2D | null;
+  /** The shape's destination point, relative to this node's {@link Node2D.position}. */
+  target_position: Vector2;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  get_collision_result(): Array<unknown>;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_exclude_parent_body(value: boolean): void;
+  get_exclude_parent_body(): boolean;
+  set_margin(value: float): void;
+  get_margin(): float;
+  set_max_results(value: int): void;
+  get_max_results(): int;
+  set_shape(value: Shape2D | null): void;
+  get_shape(): Shape2D | null;
+  set_target_position(value: Vector2 | Vector2i): void;
+  get_target_position(): Vector2;
+
+  /** Adds a collision exception so the shape does not report collisions with the specified node. */
+  add_exception(node: CollisionObject2D): void;
+  /** Adds a collision exception so the shape does not report collisions with the specified {@link RID}. */
+  add_exception_rid(rid: RID): void;
+  /** Removes all collision exceptions for this shape. */
+  clear_exceptions(): void;
+  /**
+   * Updates the collision information for the shape immediately, without waiting for the next `_physics_process` call. Use this method, for example, when the shape or its parent has changed state.
+   * **Note:** Setting {@link enabled} to `true` is not required for this to work.
+   */
+  force_shapecast_update(): void;
+  /**
+   * Returns the fraction from this cast's origin to its {@link target_position} of how far the shape can move without triggering a collision, as a value between `0.0` and `1.0`.
+   */
+  get_closest_collision_safe_fraction(): float;
+  /**
+   * Returns the fraction from this cast's origin to its {@link target_position} of how far the shape must move to trigger a collision, as a value between `0.0` and `1.0`.
+   * In ideal conditions this would be the same as {@link get_closest_collision_safe_fraction}, however shape casting is calculated in discrete steps, so the precise point of collision can occur between two calculated positions.
+   */
+  get_closest_collision_unsafe_fraction(): float;
+  /**
+   * Returns the collided {@link Object} of one of the multiple collisions at `index`, or `null` if no object is intersecting the shape (i.e. {@link is_colliding} returns `false`).
+   */
+  get_collider(index: int): GodotObject | null;
+  /** Returns the {@link RID} of the collided object of one of the multiple collisions at `index`. */
+  get_collider_rid(index: int): RID;
+  /**
+   * Returns the shape ID of the colliding shape of one of the multiple collisions at `index`, or `0` if no object is intersecting the shape (i.e. {@link is_colliding} returns `false`).
+   */
+  get_collider_shape(index: int): int;
+  /**
+   * The number of collisions detected at the point of impact. Use this to iterate over multiple collisions as provided by {@link get_collider}, {@link get_collider_shape}, {@link get_collision_point}, and {@link get_collision_normal} methods.
+   */
+  get_collision_count(): int;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_mask_value(layer_number: int): boolean;
+  /** Returns the normal of one of the multiple collisions at `index` of the intersecting object. */
+  get_collision_normal(index: int): Vector2;
+  /**
+   * Returns the collision point of one of the multiple collisions at `index` where the shape intersects the colliding object.
+   * **Note:** This point is in the **global** coordinate system.
+   */
+  get_collision_point(index: int): Vector2;
+  /** Returns whether any object is intersecting with the shape's vector (considering the vector length). */
+  is_colliding(): boolean;
+  /** Removes a collision exception so the shape does report collisions with the specified node. */
+  remove_exception(node: CollisionObject2D): void;
+  /** Removes a collision exception so the shape does report collisions with the specified {@link RID}. */
+  remove_exception_rid(rid: RID): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_mask_value(layer_number: int, value: boolean): void;
+}

package/typings/classes/ShapeCast3D.d.ts

@@ -0,0 +1,116 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D shape that sweeps a region of space to detect {@link CollisionObject3D}s. */
+declare class ShapeCast3D extends Node3D {
+  /** If `true`, collisions with {@link Area3D}s will be reported. */
+  collide_with_areas: boolean;
+  /** If `true`, collisions with {@link PhysicsBody3D}s will be reported. */
+  collide_with_bodies: boolean;
+  /**
+   * The shape's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * Returns the complete collision information from the collision sweep. The data returned is the same as in the {@link PhysicsDirectSpaceState3D.get_rest_info} method.
+   */
+  collision_result: Array<unknown>;
+  /**
+   * The custom color to use to draw the shape in the editor and at run-time if **Visible Collision Shapes** is enabled in the **Debug** menu. This color will be highlighted at run-time if the {@link ShapeCast3D} is colliding with something.
+   * If set to `Color(0.0, 0.0, 0.0)` (by default), the color set in {@link ProjectSettings.debug/shapes/collision/shape_color} is used.
+   */
+  debug_shape_custom_color: Color;
+  /** If `true`, collisions will be reported. */
+  enabled: boolean;
+  /** If `true`, the parent node will be excluded from collision detection. */
+  exclude_parent: boolean;
+  /**
+   * The collision margin for the shape. A larger margin helps detecting collisions more consistently, at the cost of precision.
+   */
+  margin: float;
+  /** The number of intersections can be limited with this parameter, to reduce the processing time. */
+  max_results: int;
+  /** The shape to be used for collision queries. */
+  shape: Shape3D | null;
+  /** The shape's destination point, relative to this node's {@link Node3D.position}. */
+  target_position: Vector3;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  get_collision_result(): Array<unknown>;
+  set_debug_shape_custom_color(value: Color): void;
+  get_debug_shape_custom_color(): Color;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_exclude_parent_body(value: boolean): void;
+  get_exclude_parent_body(): boolean;
+  set_margin(value: float): void;
+  get_margin(): float;
+  set_max_results(value: int): void;
+  get_max_results(): int;
+  set_shape(value: Shape3D | null): void;
+  get_shape(): Shape3D | null;
+  set_target_position(value: Vector3 | Vector3i): void;
+  get_target_position(): Vector3;
+
+  /** Adds a collision exception so the shape does not report collisions with the specified node. */
+  add_exception(node: CollisionObject3D): void;
+  /** Adds a collision exception so the shape does not report collisions with the specified {@link RID}. */
+  add_exception_rid(rid: RID): void;
+  /** Removes all collision exceptions for this shape. */
+  clear_exceptions(): void;
+  /**
+   * Updates the collision information for the shape immediately, without waiting for the next `_physics_process` call. Use this method, for example, when the shape or its parent has changed state.
+   * **Note:** Setting {@link enabled} to `true` is not required for this to work.
+   */
+  force_shapecast_update(): void;
+  /**
+   * Returns the fraction from this cast's origin to its {@link target_position} of how far the shape can move without triggering a collision, as a value between `0.0` and `1.0`.
+   */
+  get_closest_collision_safe_fraction(): float;
+  /**
+   * Returns the fraction from this cast's origin to its {@link target_position} of how far the shape must move to trigger a collision, as a value between `0.0` and `1.0`.
+   * In ideal conditions this would be the same as {@link get_closest_collision_safe_fraction}, however shape casting is calculated in discrete steps, so the precise point of collision can occur between two calculated positions.
+   */
+  get_closest_collision_unsafe_fraction(): float;
+  /**
+   * Returns the collided {@link Object} of one of the multiple collisions at `index`, or `null` if no object is intersecting the shape (i.e. {@link is_colliding} returns `false`).
+   */
+  get_collider(index: int): GodotObject | null;
+  /** Returns the {@link RID} of the collided object of one of the multiple collisions at `index`. */
+  get_collider_rid(index: int): RID;
+  /**
+   * Returns the shape ID of the colliding shape of one of the multiple collisions at `index`, or `0` if no object is intersecting the shape (i.e. {@link is_colliding} returns `false`).
+   */
+  get_collider_shape(index: int): int;
+  /**
+   * The number of collisions detected at the point of impact. Use this to iterate over multiple collisions as provided by {@link get_collider}, {@link get_collider_shape}, {@link get_collision_point}, and {@link get_collision_normal} methods.
+   */
+  get_collision_count(): int;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_mask_value(layer_number: int): boolean;
+  /** Returns the normal of one of the multiple collisions at `index` of the intersecting object. */
+  get_collision_normal(index: int): Vector3;
+  /**
+   * Returns the collision point of one of the multiple collisions at `index` where the shape intersects the colliding object.
+   * **Note:** This point is in the **global** coordinate system.
+   */
+  get_collision_point(index: int): Vector3;
+  /** Returns whether any object is intersecting with the shape's vector (considering the vector length). */
+  is_colliding(): boolean;
+  /** Removes a collision exception so the shape does report collisions with the specified node. */
+  remove_exception(node: CollisionObject3D): void;
+  /** Removes a collision exception so the shape does report collisions with the specified {@link RID}. */
+  remove_exception_rid(rid: RID): void;
+  /** This method does nothing. */
+  resource_changed(resource: Resource): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_mask_value(layer_number: int, value: boolean): void;
+}

package/typings/classes/Shortcut.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A shortcut for binding input. */
+declare class Shortcut extends Resource {
+  /**
+   * The shortcut's {@link InputEvent} array.
+   * Generally the {@link InputEvent} used is an {@link InputEventKey}, though it can be any {@link InputEvent}, including an {@link InputEventAction}.
+   */
+  events: Array<unknown>;
+  set_events(value: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  get_events(): Array<unknown>;
+
+  /** Returns the shortcut's first valid {@link InputEvent} as a {@link String}. */
+  get_as_text(): string;
+  /** Returns whether {@link events} contains an {@link InputEvent} which is valid. */
+  has_valid_event(): boolean;
+  /**
+   * Returns whether any {@link InputEvent} in {@link events} equals `event`. This uses {@link InputEvent.is_match} to compare events.
+   */
+  matches_event(event: InputEvent): boolean;
+}

package/typings/classes/Signal.d.ts

@@ -0,0 +1,86 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Override: GodotSignal — typed connect, disconnect, emit for bare Signal variables.
+ * For Signal<[...]> properties on classes, gd-helpers.d.ts already provides typed versions.
+ */
+declare class Signal<T extends any[] = any[]> {
+  /**
+   * Connects this signal to the specified `callable`. Optional `flags` can be also added to configure the connection's behavior (see {@link Object.ConnectFlags} constants). You can provide additional arguments to the connected `callable` by using {@link Callable.bind}.
+   * A signal can only be connected once to the same {@link Callable}. If the signal is already connected, this method returns {@link ERR_INVALID_PARAMETER} and generates an error, unless the signal is connected with {@link Object.CONNECT_REFERENCE_COUNTED}. To prevent this, use {@link is_connected} first to check for existing connections.
+   * **Note:** If the `callable`'s object is freed, the connection will be lost.
+   */
+  connect(callable: (...args: T) => void): void;
+  /**
+   * Disconnects this signal from the specified {@link Callable}. If the connection does not exist, generates an error. Use {@link is_connected} to make sure that the connection exists.
+   */
+  disconnect(callable: (...args: T) => void): void;
+  /**
+   * Emits this signal. All {@link Callable}s connected to this signal will be triggered. This method supports a variable number of arguments, so parameters can be passed as a comma separated list.
+   */
+  emit(...args: T): void;
+  /**
+   * Returns an {@link Array} of connections for this signal. Each connection is represented as a {@link Dictionary} that contains three entries:
+   * - `signal` is a reference to this signal;
+   * - `callable` is a reference to the connected {@link Callable};
+   * - `flags` is a combination of {@link Object.ConnectFlags}.
+   */
+  get_connections(): Array<unknown>;
+  /** Returns the name of this signal. */
+  get_name(): string;
+  /** Returns the object emitting this signal. */
+  get_object(): GodotObject | null;
+  /** Returns the ID of the object emitting this signal (see {@link Object.get_instance_id}). */
+  get_object_id(): int;
+  /** Returns `true` if any {@link Callable} is connected to this signal. */
+  has_connections(): boolean;
+  /** Returns `true` if the specified {@link Callable} is connected to this signal. */
+  is_connected(callable: (...args: T) => void): boolean;
+  /**
+   * Returns `true` if this {@link Signal} has no object and the signal name is empty. Equivalent to `signal == Signal()`.
+   */
+  is_null(): boolean;
+
+  // Operator overloads
+  [__ops_ne]: { right: Signal; ret: boolean };
+  [__ops_eq]: { right: Signal; ret: boolean };
+
+  [__variant_converts]: Signal;
+
+  // 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;
+}

package/typings/classes/Skeleton2D.d.ts

@@ -0,0 +1,35 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** The parent of a hierarchy of {@link Bone2D}s, used to create a 2D skeletal animation. */
+declare class Skeleton2D extends Node2D {
+  /**
+   * Executes all the modifications on the {@link SkeletonModificationStack2D}, if the Skeleton2D has one assigned.
+   */
+  execute_modifications(delta: float, execution_mode: int): void;
+  /**
+   * Returns a {@link Bone2D} from the node hierarchy parented by Skeleton2D. The object to return is identified by the parameter `idx`. Bones are indexed by descending the node hierarchy from top to bottom, adding the children of each branch before moving to the next sibling.
+   */
+  get_bone(idx: int): Bone2D | null;
+  /** Returns the number of {@link Bone2D} nodes in the node hierarchy parented by Skeleton2D. */
+  get_bone_count(): int;
+  /** Returns the local pose override transform for `bone_idx`. */
+  get_bone_local_pose_override(bone_idx: int): Transform2D;
+  /** Returns the {@link SkeletonModificationStack2D} attached to this skeleton, if one exists. */
+  get_modification_stack(): SkeletonModificationStack2D | null;
+  /** Returns the {@link RID} of a Skeleton2D instance. */
+  get_skeleton(): RID;
+  /**
+   * Sets the local pose transform, `override_pose`, for the bone at `bone_idx`.
+   * `strength` is the interpolation strength that will be used when applying the pose, and `persistent` determines if the applied pose will remain.
+   * **Note:** The pose transform needs to be a local transform relative to the {@link Bone2D} node at `bone_idx`!
+   */
+  set_bone_local_pose_override(bone_idx: int, override_pose: Transform2D, strength: float, persistent: boolean): void;
+  /** Sets the {@link SkeletonModificationStack2D} attached to this skeleton. */
+  set_modification_stack(modification_stack: SkeletonModificationStack2D): void;
+
+  /**
+   * Emitted when the {@link Bone2D} setup attached to this skeletons changes. This is primarily used internally within the skeleton.
+   */
+  bone_setup_changed: Signal<[]>;
+}

package/typings/classes/Skeleton3D.d.ts

@@ -0,0 +1,225 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node containing a bone hierarchy, used to create a 3D skeletal animation. */
+declare class Skeleton3D extends Node3D {
+  /**
+   * If you follow the recommended workflow and explicitly have {@link PhysicalBoneSimulator3D} as a child of {@link Skeleton3D}, you can control whether it is affected by raycasting without running {@link physical_bones_start_simulation}, by its {@link SkeletonModifier3D.active}.
+   * However, for old (deprecated) configurations, {@link Skeleton3D} has an internal virtual {@link PhysicalBoneSimulator3D} for compatibility. This property controls the internal virtual {@link PhysicalBoneSimulator3D}'s {@link SkeletonModifier3D.active}.
+   */
+  animate_physical_bones: boolean;
+  /** Sets the processing timing for the Modifier. */
+  modifier_callback_mode_process: int;
+  /**
+   * Multiplies the 3D position track animation.
+   * **Note:** Unless this value is `1.0`, the key value in animation will not match the actual position value.
+   */
+  motion_scale: float;
+  /**
+   * If `true`, forces the bones in their default rest pose, regardless of their values. In the editor, this also prevents the bones from being edited.
+   */
+  show_rest_only: boolean;
+  set_animate_physical_bones(value: boolean): void;
+  get_animate_physical_bones(): boolean;
+  set_modifier_callback_mode_process(value: int): void;
+  get_modifier_callback_mode_process(): int;
+  set_motion_scale(value: float): void;
+  get_motion_scale(): float;
+  set_show_rest_only(value: boolean): void;
+  is_show_rest_only(): boolean;
+
+  /**
+   * Adds a new bone with the given name. Returns the new bone's index, or `-1` if this method fails.
+   * **Note:** Bone names should be unique, non empty, and cannot include the `:` and `/` characters.
+   */
+  add_bone(name: string | NodePath): int;
+  /**
+   * Manually advance the child {@link SkeletonModifier3D}s by the specified time (in seconds).
+   * **Note:** The `delta` is temporarily accumulated in the {@link Skeleton3D}, and the deferred process uses the accumulated value to process the modification.
+   */
+  advance(delta: float): void;
+  /** Clear all the bones in this skeleton. */
+  clear_bones(): void;
+  /** Removes the global pose override on all bones in the skeleton. */
+  clear_bones_global_pose_override(): void;
+  create_skin_from_rest_transforms(): Skin;
+  /**
+   * Returns the bone index that matches `name` as its name. Returns `-1` if no bone with this name exists.
+   */
+  find_bone(name: string | NodePath): int;
+  /** Force updates the bone transforms/poses for all bones in the skeleton. */
+  force_update_all_bone_transforms(): void;
+  /** Force updates the bone transform for the bone at `bone_idx` and all of its children. */
+  force_update_bone_child_transform(bone_idx: int): void;
+  /**
+   * Returns an array containing the bone indexes of all the child node of the passed in bone, `bone_idx`.
+   */
+  get_bone_children(bone_idx: int): PackedInt32Array;
+  /** Returns the number of bones in the skeleton. */
+  get_bone_count(): int;
+  /**
+   * Returns the overall transform of the specified bone, with respect to the skeleton. Being relative to the skeleton frame, this is not the actual "global" transform of the bone.
+   * **Note:** This is the global pose you set to the skeleton in the process, the final global pose can get overridden by modifiers in the deferred process, if you want to access the final global pose, use {@link SkeletonModifier3D.modification_processed}.
+   */
+  get_bone_global_pose(bone_idx: int): Transform3D;
+  /**
+   * Returns the overall transform of the specified bone, with respect to the skeleton, but without any global pose overrides. Being relative to the skeleton frame, this is not the actual "global" transform of the bone.
+   */
+  get_bone_global_pose_no_override(bone_idx: int): Transform3D;
+  /** Returns the global pose override transform for `bone_idx`. */
+  get_bone_global_pose_override(bone_idx: int): Transform3D;
+  /** Returns the global rest transform for `bone_idx`. */
+  get_bone_global_rest(bone_idx: int): Transform3D;
+  /** Returns the metadata with the given `key` for the bone at index `bone_idx`. */
+  get_bone_meta(bone_idx: int, key: string): unknown;
+  /** Returns the list of all metadata keys for the bone at index `bone_idx`. */
+  get_bone_meta_list(bone_idx: int): Array<string>;
+  /** Returns the name of the bone at index `bone_idx`. */
+  get_bone_name(bone_idx: int): string;
+  /**
+   * Returns the bone index which is the parent of the bone at `bone_idx`. If -1, then bone has no parent.
+   * **Note:** The parent bone returned will always be less than `bone_idx`.
+   */
+  get_bone_parent(bone_idx: int): int;
+  /**
+   * Returns the pose transform of the specified bone.
+   * **Note:** This is the pose you set to the skeleton in the process, the final pose can get overridden by modifiers in the deferred process, if you want to access the final pose, use {@link SkeletonModifier3D.modification_processed}.
+   */
+  get_bone_pose(bone_idx: int): Transform3D;
+  /**
+   * Returns the pose position of the bone at `bone_idx`. The returned {@link Vector3} is in the local coordinate space of the {@link Skeleton3D} node.
+   */
+  get_bone_pose_position(bone_idx: int): Vector3;
+  /**
+   * Returns the pose rotation of the bone at `bone_idx`. The returned {@link Quaternion} is local to the bone with respect to the rotation of any parent bones.
+   */
+  get_bone_pose_rotation(bone_idx: int): Quaternion;
+  /** Returns the pose scale of the bone at `bone_idx`. */
+  get_bone_pose_scale(bone_idx: int): Vector3;
+  /** Returns the rest transform for a bone `bone_idx`. */
+  get_bone_rest(bone_idx: int): Transform3D;
+  /**
+   * Returns all bone names concatenated with commas (`,`) as a single {@link StringName}.
+   * It is useful to set it as a hint for the enum property.
+   */
+  get_concatenated_bone_names(): string;
+  /**
+   * Returns an array with all of the bones that are parentless. Another way to look at this is that it returns the indexes of all the bones that are not dependent or modified by other bones in the Skeleton.
+   */
+  get_parentless_bones(): PackedInt32Array;
+  /**
+   * Returns the number of times the bone hierarchy has changed within this skeleton, including renames.
+   * The Skeleton version is not serialized: only use within a single instance of Skeleton3D.
+   * Use for invalidating caches in IK solvers and other nodes which process bones.
+   */
+  get_version(): int;
+  /** Returns `true` if the bone at index `bone_idx` has metadata with the given `key`. */
+  has_bone_meta(bone_idx: int, key: string): boolean;
+  /** Returns whether the bone pose for the bone at `bone_idx` is enabled. */
+  is_bone_enabled(bone_idx: int): boolean;
+  /** Returns all bones in the skeleton to their rest poses. */
+  localize_rests(): void;
+  /**
+   * Adds a collision exception to the physical bone.
+   * Works just like the {@link RigidBody3D} node.
+   */
+  physical_bones_add_collision_exception(exception: RID): void;
+  /**
+   * Removes a collision exception to the physical bone.
+   * Works just like the {@link RigidBody3D} node.
+   */
+  physical_bones_remove_collision_exception(exception: RID): void;
+  /**
+   * Tells the {@link PhysicalBone3D} nodes in the Skeleton to start simulating and reacting to the physics world.
+   * Optionally, a list of bone names can be passed-in, allowing only the passed-in bones to be simulated.
+   */
+  physical_bones_start_simulation(bones?: Array<string>): void;
+  /** Tells the {@link PhysicalBone3D} nodes in the Skeleton to stop simulating. */
+  physical_bones_stop_simulation(): void;
+  /** Binds the given Skin to the Skeleton. */
+  register_skin(skin: Skin): SkinReference;
+  /** Sets the bone pose to rest for `bone_idx`. */
+  reset_bone_pose(bone_idx: int): void;
+  /** Sets all bone poses to rests. */
+  reset_bone_poses(): void;
+  /** Disables the pose for the bone at `bone_idx` if `false`, enables the bone pose if `true`. */
+  set_bone_enabled(bone_idx: int, enabled?: boolean): void;
+  /**
+   * Sets the global pose transform, `pose`, for the bone at `bone_idx`.
+   * **Note:** If other bone poses have been changed, this method executes a dirty poses recalculation and will cause performance to deteriorate. If you know that multiple global poses will be applied, consider using {@link set_bone_pose} with precalculation.
+   */
+  set_bone_global_pose(bone_idx: int, pose: Transform3D | Projection): void;
+  /**
+   * Sets the global pose transform, `pose`, for the bone at `bone_idx`.
+   * `amount` is the interpolation strength that will be used when applying the pose, and `persistent` determines if the applied pose will remain.
+   * **Note:** The pose transform needs to be a global pose! To convert a world transform from a {@link Node3D} to a global bone pose, multiply the {@link Transform3D.affine_inverse} of the node's {@link Node3D.global_transform} by the desired world transform.
+   */
+  set_bone_global_pose_override(bone_idx: int, pose: Transform3D | Projection, amount: float, persistent?: boolean): void;
+  /** Sets the metadata with the given `key` to `value` for the bone at index `bone_idx`. */
+  set_bone_meta(bone_idx: int, key: string, value: unknown): void;
+  /** Sets the bone name, `name`, for the bone at `bone_idx`. */
+  set_bone_name(bone_idx: int, name: string | NodePath): void;
+  /**
+   * Sets the bone index `parent_idx` as the parent of the bone at `bone_idx`. If -1, then bone has no parent.
+   * **Note:** `parent_idx` must be less than `bone_idx`.
+   */
+  set_bone_parent(bone_idx: int, parent_idx: int): void;
+  /** Sets the pose transform, `pose`, for the bone at `bone_idx`. */
+  set_bone_pose(bone_idx: int, pose: Transform3D | Projection): void;
+  /**
+   * Sets the pose position of the bone at `bone_idx` to `position`. `position` is a {@link Vector3} describing a position local to the {@link Skeleton3D} node.
+   */
+  set_bone_pose_position(bone_idx: int, position: Vector3 | Vector3i): void;
+  /**
+   * Sets the pose rotation of the bone at `bone_idx` to `rotation`. `rotation` is a {@link Quaternion} describing a rotation in the bone's local coordinate space with respect to the rotation of any parent bones.
+   */
+  set_bone_pose_rotation(bone_idx: int, rotation: Quaternion | Basis): void;
+  /** Sets the pose scale of the bone at `bone_idx` to `scale`. */
+  set_bone_pose_scale(bone_idx: int, scale: Vector3 | Vector3i): void;
+  /** Sets the rest transform for bone `bone_idx`. */
+  set_bone_rest(bone_idx: int, rest: Transform3D | Projection): void;
+  /**
+   * Unparents the bone at `bone_idx` and sets its rest position to that of its parent prior to being reset.
+   */
+  unparent_bone_and_rest(bone_idx: int): void;
+
+  /**
+   * Emitted when the bone at `bone_idx` is toggled with {@link set_bone_enabled}. Use {@link is_bone_enabled} to check the new value.
+   */
+  bone_enabled_changed: Signal<[int]>;
+  /**
+   * Emitted when the list of bones changes, such as when calling {@link add_bone}, {@link set_bone_parent}, {@link unparent_bone_and_rest}, or {@link clear_bones}.
+   */
+  bone_list_changed: Signal<[]>;
+  /**
+   * Emitted when the pose is updated.
+   * **Note:** During the update process, this signal is not fired, so modification by {@link SkeletonModifier3D} is not detected.
+   */
+  pose_updated: Signal<[]>;
+  /** Emitted when the rest is updated. */
+  rest_updated: Signal<[]>;
+  /** Emitted when the value of {@link show_rest_only} changes. */
+  show_rest_only_changed: Signal<[]>;
+  /**
+   * Emitted when the final pose has been calculated will be applied to the skin in the update process.
+   * This means that all {@link SkeletonModifier3D} processing is complete. In order to detect the completion of the processing of each {@link SkeletonModifier3D}, use {@link SkeletonModifier3D.modification_processed}.
+   */
+  skeleton_updated: Signal<[]>;
+
+  // enum ModifierCallbackModeProcess
+  /**
+   * Set a flag to process modification during physics frames (see {@link Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS}).
+   */
+  static readonly MODIFIER_CALLBACK_MODE_PROCESS_PHYSICS: int;
+  /**
+   * Set a flag to process modification during process frames (see {@link Node.NOTIFICATION_INTERNAL_PROCESS}).
+   */
+  static readonly MODIFIER_CALLBACK_MODE_PROCESS_IDLE: int;
+  /** Do not process modification. Use {@link advance} to process the modification manually. */
+  static readonly MODIFIER_CALLBACK_MODE_PROCESS_MANUAL: int;
+
+  /**
+   * Notification received when this skeleton's pose needs to be updated. In that case, this is called only once per frame in a deferred process.
+   */
+  static readonly NOTIFICATION_UPDATE_SKELETON: int;
+}