@ringozz/godot 0.1.0

package/gen/classes/ShapeCast3D.ts

@@ -0,0 +1,181 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { GodotArray, RID } from '../heap-types/index.ts';
+import type { Color, Vector3 } from '../value-types/index.ts';
+import type { CollisionObject3D } from './CollisionObject3D.ts';
+import type { Object } from './Object.ts';
+import type { Resource } from './Resource.ts';
+import type { Shape3D } from './Shape3D.ts';
+
+/**
+ * Shape casting allows to detect collision objects by sweeping its {@link shape} along the cast direction determined by {@link targetPosition}. This is similar to {@link RayCast3D}, but it allows for sweeping a region of space, rather than just a straight line. {@link ShapeCast3D} can detect multiple collision objects. It is useful for things like wide laser beams or snapping a simple shape to a floor.
+ * Immediate collision overlaps can be done with the {@link targetPosition} set to `Vector3(0, 0, 0)` and by calling {@link forceShapecastUpdate} within the same physics frame. This helps to overcome some limitations of {@link Area3D} when used as an instantaneous detection area, as collision information isn't immediately available to it.
+ * **Note:** Shape casting is more computationally expensive than ray casting.
+ */
+export class ShapeCast3D extends Node3D {
+    constructor(name = 699) { super(name); }
+
+    /**
+     * This method does nothing.
+     */
+    resourceChanged(resource: Resource): void { _C(this, 10089, resource); }
+
+    /**
+     * Returns whether any object is intersecting with the shape's vector (considering the vector length).
+     */
+    isColliding(): boolean { return _C(this, 7841) as boolean; }
+
+    /**
+     * The number of collisions detected at the point of impact. Use this to iterate over multiple collisions as provided by {@link getCollider}, {@link getColliderShape}, {@link getCollisionPoint}, and {@link getCollisionNormal} methods.
+     */
+    getCollisionCount(): number { return _C(this, 4197) as number; }
+
+    /**
+     * 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.
+     */
+    forceShapecastUpdate(): void { _C(this, 3535); }
+
+    /**
+     * 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 isColliding} returns `false`).
+     */
+    getCollider(index: number): Object | null { return _C(this, 4188, index) as Object | null; }
+
+    /**
+     * Returns the {@link RID} of the collided object of one of the multiple collisions at `index`.
+     */
+    getColliderRid(index: number): RID { return _C(this, 4190, index) as 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 isColliding} returns `false`).
+     */
+    getColliderShape(index: number): number { return _C(this, 4191, index) as number; }
+
+    /**
+     * 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.
+     */
+    getCollisionPoint(index: number): Vector3 { return _C(this, 4210, index) as Vector3; }
+
+    /**
+     * Returns the normal of one of the multiple collisions at `index` of the intersecting object.
+     */
+    getCollisionNormal(index: number): Vector3 { return _C(this, 4208, index) as Vector3; }
+
+    /**
+     * Returns the fraction from this cast's origin to its {@link targetPosition} of how far the shape can move without triggering a collision, as a value between `0.0` and `1.0`.
+     */
+    getClosestCollisionSafeFraction(): number { return _C(this, 4169) as number; }
+
+    /**
+     * Returns the fraction from this cast's origin to its {@link targetPosition} 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 getClosestCollisionSafeFraction}, however shape casting is calculated in discrete steps, so the precise point of collision can occur between two calculated positions.
+     */
+    getClosestCollisionUnsafeFraction(): number { return _C(this, 4170) as number; }
+
+    /**
+     * Adds a collision exception so the shape does not report collisions with the specified {@link RID}.
+     */
+    addExceptionRid(rid: RID): void { _C(this, 1213, rid); }
+
+    /**
+     * Adds a collision exception so the shape does not report collisions with the specified node.
+     */
+    addException(node: CollisionObject3D): void { _C(this, 1212, node); }
+
+    /**
+     * Removes a collision exception so the shape does report collisions with the specified {@link RID}.
+     */
+    removeExceptionRid(rid: RID): void { _C(this, 9909, rid); }
+
+    /**
+     * Removes a collision exception so the shape does report collisions with the specified node.
+     */
+    removeException(node: CollisionObject3D): void { _C(this, 9908, node); }
+
+    /**
+     * Removes all collision exceptions for this shape.
+     */
+    clearExceptions(): void { _C(this, 2262); }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link collisionMask}, given a `layerNumber` between 1 and 32.
+     */
+    setCollisionMaskValue(layerNumber: number, value: boolean): void { _C(this, 10895, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link collisionMask} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getCollisionMaskValue(layerNumber: number): boolean { return _C(this, 4206, layerNumber) as boolean; }
+
+    /**
+     * If `true`, collisions will be reported.
+     */
+    get enabled(): boolean { return _C(this, 7935) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * The shape to be used for collision queries.
+     */
+    get shape(): Shape3D { return _C(this, 6370) as Shape3D; }
+    set shape(v: Shape3D) { _C(this, 12717, v); }
+
+    /**
+     * If `true`, the parent node will be excluded from collision detection.
+     */
+    get excludeParent(): boolean { return _C(this, 4699) as boolean; }
+    set excludeParent(v: boolean) { _C(this, 11315, v); }
+
+    /**
+     * The shape's destination point, relative to this node's {@link Node3D.position}.
+     */
+    get targetPosition(): Vector3 { return _C(this, 6702) as Vector3; }
+    set targetPosition(v: Vector3) { _C(this, 13007, v); }
+
+    /**
+     * The collision margin for the shape. A larger margin helps detecting collisions more consistently, at the cost of precision.
+     */
+    get margin(): number { return _C(this, 5441) as number; }
+    set margin(v: number) { _C(this, 11969, v); }
+
+    /**
+     * The number of intersections can be limited with this parameter, to reduce the processing time.
+     */
+    get maxResults(): number { return _C(this, 5483) as number; }
+    set maxResults(v: number) { _C(this, 12006, v); }
+
+    /**
+     * 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.
+     */
+    get collisionMask(): number { return _C(this, 4205) as number; }
+    set collisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * Returns the complete collision information from the collision sweep. The data returned is the same as in the {@link PhysicsDirectSpaceState3D.getRestInfo} method.
+     */
+    get collisionResult(): GodotArray { return _C(this, 4215) as GodotArray; }
+
+    /**
+     * If `true`, collisions with {@link Area3D}s will be reported.
+     */
+    get collideWithAreas(): boolean { return _C(this, 7839) as boolean; }
+    set collideWithAreas(v: boolean) { _C(this, 10884, v); }
+
+    /**
+     * If `true`, collisions with {@link PhysicsBody3D}s will be reported.
+     */
+    get collideWithBodies(): boolean { return _C(this, 7840) as boolean; }
+    set collideWithBodies(v: boolean) { _C(this, 10885, v); }
+
+    /**
+     * 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/shapeColor} is used.
+     */
+    get debugShapeCustomColor(): Color { return _C(this, 4437) as Color; }
+    set debugShapeCustomColor(v: Color) { _C(this, 11050, v); }
+
+    static readonly name = _R(699, ShapeCast3D);
+}

package/gen/classes/Shortcut.ts

@@ -0,0 +1,60 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { InputEvent } from './InputEvent.ts';
+
+/**
+ * Shortcuts (also known as hotkeys) are containers of {@link InputEvent} resources. They are commonly used to interact with a {@link Control} element from an {@link InputEvent}.
+ * One shortcut can contain multiple {@link InputEvent} resources, making it possible to trigger one action with multiple different inputs.
+ * **Example:** Capture the `Ctrl + S` shortcut using a {@link Shortcut} resource:
+ *
+ *
+ * ```gdscript
+ *
+ * extends Node
+ *
+ * var save_shortcut = Shortcut.new()
+ * func _ready():
+ * 	var key_event = InputEventKey.new()
+ * 	key_event.keycode = KEY_S
+ * 	key_event.ctrl_pressed = true
+ * 	key_event.command_or_control_autoremap = true # Swaps Ctrl for Command on Mac.
+ * 	save_shortcut.events = [key_event]
+ *
+ * func _input(event):
+ * 	if save_shortcut.matches_event(event) and event.is_pressed() and not event.is_echo():
+ * 		print("Save shortcut pressed!")
+ * 		get_viewport().set_input_as_handled()
+ *
+ * ```
+ */
+export class Shortcut extends Resource {
+    constructor(name = 700) { super(name); }
+
+    /**
+     * Returns whether {@link events} contains an {@link InputEvent} which is valid.
+     */
+    hasValidEvent(): boolean { return _C(this, 7483) as boolean; }
+
+    /**
+     * Returns whether any {@link InputEvent} in {@link events} equals `event`. This uses {@link InputEvent.isMatch} to compare events.
+     */
+    matchesEvent(event: InputEvent): boolean { return _C(this, 8791, event) as boolean; }
+
+    /**
+     * Returns the shortcut's first valid {@link InputEvent} as a {@link String}.
+     */
+    getAsText(): string { return _C(this, 3798) as string; }
+
+    /**
+     * 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}.
+     */
+    get events(): GodotArray { return _C(this, 4691) as GodotArray; }
+    set events(v: GodotArray) { _C(this, 11308, v); }
+
+    static readonly name = _R(700, Shortcut);
+}

package/gen/classes/Skeleton2D.ts

@@ -0,0 +1,67 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { RID, Signal } from '../heap-types/index.ts';
+import type { Transform2D } from '../value-types/index.ts';
+import type { Bone2D } from './Bone2D.ts';
+import type { SkeletonModificationStack2D } from './SkeletonModificationStack2D.ts';
+
+/**
+ * {@link Skeleton2D} parents a hierarchy of {@link Bone2D} nodes. It holds a reference to each {@link Bone2D}'s rest pose and acts as a single point of access to its bones.
+ * To set up different types of inverse kinematics for the given Skeleton2D, a {@link SkeletonModificationStack2D} should be created. The inverse kinematics be applied by increasing {@link SkeletonModificationStack2D.modificationCount} and creating the desired number of modifications.
+ */
+export class Skeleton2D extends Node2D {
+    constructor(name = 701) { super(name); }
+
+    /**
+     * Returns the number of {@link Bone2D} nodes in the node hierarchy parented by Skeleton2D.
+     */
+    getBoneCount(): number { return _C(this, 3961) as number; }
+
+    /**
+     * 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.
+     */
+    getBone(idx: number): Bone2D { return _C(this, 3953, idx) as Bone2D; }
+
+    /**
+     * Returns the {@link RID} of a Skeleton2D instance.
+     */
+    getSkeleton(): RID { return _C(this, 6405) as RID; }
+
+    /**
+     * Sets the {@link SkeletonModificationStack2D} attached to this skeleton.
+     */
+    setModificationStack(modificationStack: SkeletonModificationStack2D): void { _C(this, 12079, modificationStack); }
+
+    /**
+     * Returns the {@link SkeletonModificationStack2D} attached to this skeleton, if one exists.
+     */
+    getModificationStack(): SkeletonModificationStack2D { return _C(this, 5572) as SkeletonModificationStack2D; }
+
+    /**
+     * Executes all the modifications on the {@link SkeletonModificationStack2D}, if the Skeleton2D has one assigned.
+     */
+    executeModifications(delta: number, executionMode: number): void { _C(this, 3181, delta, executionMode); }
+
+    /**
+     * Sets the local pose transform, `overridePose`, for the bone at `boneIdx`.
+     * `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 `boneIdx`!
+     */
+    setBoneLocalPoseOverride(boneIdx: number, overridePose: Transform2D, strength: number, persistent: boolean): void { _C(this, 10708, boneIdx, overridePose, strength, persistent); }
+
+    /**
+     * Returns the local pose override transform for `boneIdx`.
+     */
+    getBoneLocalPoseOverride(boneIdx: number): Transform2D { return _C(this, 3969, boneIdx) as Transform2D; }
+
+    /**
+     * Emitted when the {@link Bone2D} setup attached to this skeletons changes. This is primarily used internally within the skeleton.
+     */
+    get boneSetupChanged(): Signal<() => void> { return _G(this, 1888) as Signal<() => void>; }
+    set boneSetupChanged(v: (() => void) | null) { _G(this, 1888, v); }
+
+    static readonly name = _R(701, Skeleton2D);
+}

package/gen/classes/Skeleton3D.ts

@@ -0,0 +1,359 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { GodotArray, PackedInt32Array, RID, Signal, StringName, Variant } from '../heap-types/index.ts';
+import type { Quaternion, Transform3D, Vector3 } from '../value-types/index.ts';
+import type { Skin } from './Skin.ts';
+import type { SkinReference } from './SkinReference.ts';
+
+/**
+ * {@link Skeleton3D} provides an interface for managing a hierarchy of bones, including pose, rest and animation (see {@link Animation}). It can also use ragdoll physics.
+ * The overall transform of a bone with respect to the skeleton is determined by bone pose. Bone rest defines the initial transform of the bone pose.
+ * Note that "global pose" below refers to the overall transform of the bone with respect to skeleton, so it is not the actual global/world transform of the bone.
+ */
+export class Skeleton3D extends Node3D {
+    constructor(name = 702) { super(name); }
+
+    /**
+     * 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.
+     */
+    addBone(name: string): number { return _C(this, 1187, name) as number; }
+
+    /**
+     * Returns the bone index that matches `name` as its name. Returns `-1` if no bone with this name exists.
+     */
+    findBone(name: string): number { return _C(this, 3283, name) as number; }
+
+    /**
+     * Returns the name of the bone at index `boneIdx`.
+     */
+    getBoneName(boneIdx: number): string { return _C(this, 3972, boneIdx) as string; }
+
+    /**
+     * Sets the bone name, `name`, for the bone at `boneIdx`.
+     */
+    setBoneName(boneIdx: number, name: string): void { _C(this, 10710, boneIdx, name); }
+
+    /**
+     * Returns the metadata with the given `key` for the bone at index `boneIdx`.
+     */
+    getBoneMeta(boneIdx: number, key: StringName): Variant { return _C(this, 3970, boneIdx, key) as Variant; }
+
+    /**
+     * Returns the list of all metadata keys for the bone at index `boneIdx`.
+     */
+    getBoneMetaList(boneIdx: number): GodotArray<StringName> { return _C(this, 3971, boneIdx) as GodotArray<StringName>; }
+
+    /**
+     * Returns `true` if the bone at index `boneIdx` has metadata with the given `key`.
+     */
+    hasBoneMeta(boneIdx: number, key: StringName): boolean { return _C(this, 7369, boneIdx, key) as boolean; }
+
+    /**
+     * Sets the metadata with the given `key` to `value` for the bone at index `boneIdx`.
+     */
+    setBoneMeta(boneIdx: number, key: StringName, value: Variant): void { _C(this, 10709, boneIdx, key, value); }
+
+    /**
+     * 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.
+     */
+    getConcatenatedBoneNames(): StringName { return _C(this, 4254) as StringName; }
+
+    /**
+     * Returns the bone index which is the parent of the bone at `boneIdx`. If -1, then bone has no parent.
+     * **Note:** The parent bone returned will always be less than `boneIdx`.
+     */
+    getBoneParent(boneIdx: number): number { return _C(this, 3973, boneIdx) as number; }
+
+    /**
+     * Sets the bone index `parentIdx` as the parent of the bone at `boneIdx`. If -1, then bone has no parent.
+     * **Note:** `parentIdx` must be less than `boneIdx`.
+     */
+    setBoneParent(boneIdx: number, parentIdx: number): void { _C(this, 10711, boneIdx, parentIdx); }
+
+    /**
+     * Returns the number of bones in the skeleton.
+     */
+    getBoneCount(): number { return _C(this, 3961) as number; }
+
+    /**
+     * 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.
+     */
+    getVersion(): number { return _C(this, 7041) as number; }
+
+    /**
+     * Unparents the bone at `boneIdx` and sets its rest position to that of its parent prior to being reset.
+     */
+    unparentBoneAndRest(boneIdx: number): void { _C(this, 14483, boneIdx); }
+
+    /**
+     * Returns an array containing the bone indexes of all the child node of the passed in bone, `boneIdx`.
+     */
+    getBoneChildren(boneIdx: number): PackedInt32Array { return _C(this, 3960, boneIdx) as PackedInt32Array; }
+
+    /**
+     * 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.
+     */
+    getParentlessBones(): PackedInt32Array { return _C(this, 5826) as PackedInt32Array; }
+
+    /**
+     * Returns the rest transform for a bone `boneIdx`.
+     */
+    getBoneRest(boneIdx: number): Transform3D { return _C(this, 3979, boneIdx) as Transform3D; }
+
+    /**
+     * Sets the rest transform for bone `boneIdx`.
+     */
+    setBoneRest(boneIdx: number, rest: Transform3D): void { _C(this, 10717, boneIdx, rest); }
+
+    /**
+     * Returns the global rest transform for `boneIdx`.
+     */
+    getBoneGlobalRest(boneIdx: number): Transform3D { return _C(this, 3965, boneIdx) as Transform3D; }
+
+    createSkinFromRestTransforms(): Skin { return _C(this, 2571) as Skin; }
+
+    /**
+     * Binds the given Skin to the Skeleton.
+     */
+    registerSkin(skin: Skin): SkinReference { return _C(this, 9858, skin) as SkinReference; }
+
+    /**
+     * Returns all bones in the skeleton to their rest poses.
+     */
+    localizeRests(): void { _C(this, 8698); }
+
+    /**
+     * Clear all the bones in this skeleton.
+     */
+    clearBones(): void { _C(this, 2238); }
+
+    /**
+     * 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}.
+     */
+    getBonePose(boneIdx: number): Transform3D { return _C(this, 3975, boneIdx) as Transform3D; }
+
+    /**
+     * Sets the pose transform, `pose`, for the bone at `boneIdx`.
+     */
+    setBonePose(boneIdx: number, pose: Transform3D): void { _C(this, 10713, boneIdx, pose); }
+
+    /**
+     * Sets the pose position of the bone at `boneIdx` to `position`. `position` is a {@link Vector3} describing a position local to the {@link Skeleton3D} node.
+     */
+    setBonePosePosition(boneIdx: number, position: Vector3): void { _C(this, 10714, boneIdx, position); }
+
+    /**
+     * Sets the pose rotation of the bone at `boneIdx` 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.
+     */
+    setBonePoseRotation(boneIdx: number, rotation: Quaternion): void { _C(this, 10715, boneIdx, rotation); }
+
+    /**
+     * Sets the pose scale of the bone at `boneIdx` to `scale`.
+     */
+    setBonePoseScale(boneIdx: number, scale: Vector3): void { _C(this, 10716, boneIdx, scale); }
+
+    /**
+     * Returns the pose position of the bone at `boneIdx`. The returned {@link Vector3} is in the local coordinate space of the {@link Skeleton3D} node.
+     */
+    getBonePosePosition(boneIdx: number): Vector3 { return _C(this, 3976, boneIdx) as Vector3; }
+
+    /**
+     * Returns the pose rotation of the bone at `boneIdx`. The returned {@link Quaternion} is local to the bone with respect to the rotation of any parent bones.
+     */
+    getBonePoseRotation(boneIdx: number): Quaternion { return _C(this, 3977, boneIdx) as Quaternion; }
+
+    /**
+     * Returns the pose scale of the bone at `boneIdx`.
+     */
+    getBonePoseScale(boneIdx: number): Vector3 { return _C(this, 3978, boneIdx) as Vector3; }
+
+    /**
+     * Sets the bone pose to rest for `boneIdx`.
+     */
+    resetBonePose(boneIdx: number): void { _C(this, 10065, boneIdx); }
+
+    /**
+     * Sets all bone poses to rests.
+     */
+    resetBonePoses(): void { _C(this, 10066); }
+
+    /**
+     * Returns whether the bone pose for the bone at `boneIdx` is enabled.
+     */
+    isBoneEnabled(boneIdx: number): boolean { return _C(this, 7800, boneIdx) as boolean; }
+
+    /**
+     * Disables the pose for the bone at `boneIdx` if `false`, enables the bone pose if `true`.
+     */
+    setBoneEnabled(boneIdx: number, enabled?: boolean /* = true */): void { _C(this, 10703, boneIdx, enabled); }
+
+    /**
+     * 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}.
+     */
+    getBoneGlobalPose(boneIdx: number): Transform3D { return _C(this, 3962, boneIdx) as Transform3D; }
+
+    /**
+     * Sets the global pose transform, `pose`, for the bone at `boneIdx`.
+     * **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 setBonePose} with precalculation.
+     */
+    setBoneGlobalPose(boneIdx: number, pose: Transform3D): void { _C(this, 10704, boneIdx, pose); }
+
+    /**
+     * Force updates the bone transforms/poses for all bones in the skeleton.
+     */
+    forceUpdateAllBoneTransforms(): void { _C(this, 3538); }
+
+    /**
+     * Force updates the bone transform for the bone at `boneIdx` and all of its children.
+     */
+    forceUpdateBoneChildTransform(boneIdx: number): void { _C(this, 3539, boneIdx); }
+
+    /**
+     * 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: number /* double */): void { _C(this, 1346, delta); }
+
+    /**
+     * Removes the global pose override on all bones in the skeleton.
+     */
+    clearBonesGlobalPoseOverride(): void { _C(this, 2239); }
+
+    /**
+     * Sets the global pose transform, `pose`, for the bone at `boneIdx`.
+     * `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.affineInverse} of the node's {@link Node3D.globalTransform} by the desired world transform.
+     */
+    setBoneGlobalPoseOverride(boneIdx: number, pose: Transform3D, amount: number, persistent?: boolean /* = false */): void { _C(this, 10705, boneIdx, pose, amount, persistent); }
+
+    /**
+     * Returns the global pose override transform for `boneIdx`.
+     */
+    getBoneGlobalPoseOverride(boneIdx: number): Transform3D { return _C(this, 3964, boneIdx) as 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.
+     */
+    getBoneGlobalPoseNoOverride(boneIdx: number): Transform3D { return _C(this, 3963, boneIdx) as Transform3D; }
+
+    /**
+     * Tells the {@link PhysicalBone3D} nodes in the Skeleton to stop simulating.
+     */
+    physicalBonesStopSimulation(): void { _C(this, 9403); }
+
+    /**
+     * 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.
+     */
+    physicalBonesStartSimulation(bones?: GodotArray<StringName> /* = [] */): void { _C(this, 9402, bones); }
+
+    /**
+     * Adds a collision exception to the physical bone.
+     * Works just like the {@link RigidBody3D} node.
+     */
+    physicalBonesAddCollisionException(exception: RID): void { _C(this, 9400, exception); }
+
+    /**
+     * Removes a collision exception to the physical bone.
+     * Works just like the {@link RigidBody3D} node.
+     */
+    physicalBonesRemoveCollisionException(exception: RID): void { _C(this, 9401, exception); }
+
+    /**
+     * 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.
+     */
+    get motionScale(): number { return _C(this, 5583) as number; }
+    set motionScale(v: number) { _C(this, 12090, v); }
+
+    /**
+     * 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.
+     */
+    get showRestOnly(): boolean { return _C(this, 8306) as boolean; }
+    set showRestOnly(v: boolean) { _C(this, 12737, v); }
+
+    /**
+     * Sets the processing timing for the Modifier.
+     */
+    get modifierCallbackModeProcess(): ModifierCallbackModeProcess { return _C(this, 5574) as ModifierCallbackModeProcess; }
+    set modifierCallbackModeProcess(v: ModifierCallbackModeProcess) { _C(this, 12080, v); }
+
+    /**
+     * 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 physicalBonesStartSimulation}, 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}.
+     */
+    get animatePhysicalBones(): boolean { return _C(this, 3758) as boolean; }
+    set animatePhysicalBones(v: boolean) { _C(this, 10501, v); }
+
+    /**
+     * 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 = 50;
+
+    /**
+     * Emitted when the rest is updated.
+     */
+    get restUpdated(): Signal<() => void> { return _G(this, 10097) as Signal<() => void>; }
+    set restUpdated(v: (() => void) | null) { _G(this, 10097, v); }
+
+    /**
+     * Emitted when the pose is updated.
+     * **Note:** During the update process, this signal is not fired, so modification by {@link SkeletonModifier3D} is not detected.
+     */
+    get poseUpdated(): Signal<() => void> { return _G(this, 9503) as Signal<() => void>; }
+    set poseUpdated(v: (() => void) | null) { _G(this, 9503, v); }
+
+    /**
+     * 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}.
+     */
+    get skeletonUpdated(): Signal<() => void> { return _G(this, 13629) as Signal<() => void>; }
+    set skeletonUpdated(v: (() => void) | null) { _G(this, 13629, v); }
+
+    /**
+     * Emitted when the bone at `boneIdx` is toggled with {@link setBoneEnabled}. Use {@link isBoneEnabled} to check the new value.
+     */
+    get boneEnabledChanged(): Signal<(boneIdx: number) => void> { return _G(this, 1882) as Signal<(boneIdx: number) => void>; }
+    set boneEnabledChanged(v: ((boneIdx: number) => void) | null) { _G(this, 1882, v); }
+
+    /**
+     * Emitted when the list of bones changes, such as when calling {@link addBone}, {@link setBoneParent}, {@link unparentBoneAndRest}, or {@link clearBones}.
+     */
+    get boneListChanged(): Signal<() => void> { return _G(this, 1885) as Signal<() => void>; }
+    set boneListChanged(v: (() => void) | null) { _G(this, 1885, v); }
+
+    /**
+     * Emitted when the value of {@link showRestOnly} changes.
+     */
+    get showRestOnlyChanged(): Signal<() => void> { return _G(this, 13586) as Signal<() => void>; }
+    set showRestOnlyChanged(v: (() => void) | null) { _G(this, 13586, v); }
+
+    static readonly name = _R(702, Skeleton3D);
+}
+
+export const ModifierCallbackModeProcess = {
+    /**
+     * Set a flag to process modification during physics frames (see {@link Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS}).
+     */
+    MODIFIER_CALLBACK_MODE_PROCESS_PHYSICS: 0,
+    /**
+     * Set a flag to process modification during process frames (see {@link Node.NOTIFICATION_INTERNAL_PROCESS}).
+     */
+    MODIFIER_CALLBACK_MODE_PROCESS_IDLE: 1,
+    /**
+     * Do not process modification. Use {@link advance} to process the modification manually.
+     */
+    MODIFIER_CALLBACK_MODE_PROCESS_MANUAL: 2,
+} as const;
+
+export type ModifierCallbackModeProcess = (typeof ModifierCallbackModeProcess)[keyof typeof ModifierCallbackModeProcess];
+