typescript-to-gdscript 0.1.0

package/typings/classes/AnimationMixer.d.ts

@@ -0,0 +1,226 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for {@link AnimationPlayer} and {@link AnimationTree}. */
+declare class AnimationMixer extends Node {
+  /** If `true`, the {@link AnimationMixer} will be processing. */
+  active: boolean;
+  /**
+   * The number of possible simultaneous sounds for each of the assigned AudioStreamPlayers.
+   * For example, if this value is `32` and the animation has two audio tracks, the two {@link AudioStreamPlayer}s assigned can play simultaneously up to `32` voices each.
+   */
+  audio_max_polyphony: int;
+  /**
+   * Ordinarily, tracks can be set to {@link Animation.UPDATE_DISCRETE} to update infrequently, usually when using nearest interpolation.
+   * However, when blending with {@link Animation.UPDATE_CONTINUOUS} several results are considered. The {@link callback_mode_discrete} specify it explicitly. See also {@link AnimationCallbackModeDiscrete}.
+   * To make the blended results look good, it is recommended to set this to {@link ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS} to update every frame during blending. Other values exist for compatibility and they are fine if there is no blending, but not so, may produce artifacts.
+   */
+  callback_mode_discrete: int;
+  /** The call mode used for "Call Method" tracks. */
+  callback_mode_method: int;
+  /** The process notification in which to update animations. */
+  callback_mode_process: int;
+  /**
+   * If `true`, the blending uses the deterministic algorithm. The total weight is not normalized and the result is accumulated with an initial value (`0` or a `"RESET"` animation if present).
+   * This means that if the total amount of blending is `0.0`, the result is equal to the `"RESET"` animation.
+   * If the number of tracks between the blended animations is different, the animation with the missing track is treated as if it had the initial value.
+   * If `false`, The blend does not use the deterministic algorithm. The total weight is normalized and always `1.0`. If the number of tracks between the blended animations is different, nothing is done about the animation that is missing a track.
+   * **Note:** In {@link AnimationTree}, the blending with {@link AnimationNodeAdd2}, {@link AnimationNodeAdd3}, {@link AnimationNodeSub2} or the weight greater than `1.0` may produce unexpected results.
+   * For example, if {@link AnimationNodeAdd2} blends two nodes with the amount `1.0`, then total weight is `2.0` but it will be normalized to make the total amount `1.0` and the result will be equal to {@link AnimationNodeBlend2} with the amount `0.5`.
+   */
+  deterministic: boolean;
+  /**
+   * This is used by the editor. If set to `true`, the scene will be saved with the effects of the reset animation (the animation with the key `"RESET"`) applied as if it had been seeked to time 0, with the editor keeping the values that the scene had before saving.
+   * This makes it more convenient to preview and edit animations in the editor, as changes to the scene will not be saved as long as they are set in the reset animation.
+   */
+  reset_on_save: boolean;
+  /**
+   * If `true`, {@link get_root_motion_position} value is extracted as a local translation value before blending. In other words, it is treated like the translation is done after the rotation.
+   */
+  root_motion_local: boolean;
+  /**
+   * The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. The {@link root_motion_track} uses the same format as {@link Animation.track_set_path}, but note that a bone must be specified.
+   * If the track has type {@link Animation.TYPE_POSITION_3D}, {@link Animation.TYPE_ROTATION_3D}, or {@link Animation.TYPE_SCALE_3D} the transformation will be canceled visually, and the animation will appear to stay in place. See also {@link get_root_motion_position}, {@link get_root_motion_rotation}, {@link get_root_motion_scale}, and {@link RootMotionView}.
+   */
+  root_motion_track: NodePath;
+  /** The node which node path references will travel from. */
+  root_node: NodePath;
+  set_active(value: boolean): void;
+  is_active(): boolean;
+  set_audio_max_polyphony(value: int): void;
+  get_audio_max_polyphony(): int;
+  set_callback_mode_discrete(value: int): void;
+  get_callback_mode_discrete(): int;
+  set_callback_mode_method(value: int): void;
+  get_callback_mode_method(): int;
+  set_callback_mode_process(value: int): void;
+  get_callback_mode_process(): int;
+  set_deterministic(value: boolean): void;
+  is_deterministic(): boolean;
+  set_reset_on_save_enabled(value: boolean): void;
+  is_reset_on_save_enabled(): boolean;
+  set_root_motion_local(value: boolean): void;
+  is_root_motion_local(): boolean;
+  set_root_motion_track(value: NodePath | string): void;
+  get_root_motion_track(): NodePath;
+  set_root_node(value: NodePath | string): void;
+  get_root_node(): NodePath;
+
+  /** A virtual function for processing after getting a key during playback. */
+  _post_process_key_value(animation: Animation, track: int, value: unknown, object_id: int, object_sub_idx: int): unknown;
+  /**
+   * Adds `library` to the animation player, under the key `name`.
+   * AnimationMixer has a global library by default with an empty string as key. For adding an animation to the global library:
+   */
+  add_animation_library(name: string, library: AnimationLibrary): int;
+  /** Manually advance the animations by the specified time (in seconds). */
+  advance(delta: float): void;
+  /**
+   * If the animation track specified by `name` has an option {@link Animation.UPDATE_CAPTURE}, stores current values of the objects indicated by the track path as a cache. If there is already a captured cache, the old cache is discarded.
+   * After this it will interpolate with current animation blending result during the playback process for the time specified by `duration`, working like a crossfade.
+   * You can specify `trans_type` as the curve for the interpolation. For better results, it may be appropriate to specify {@link Tween.TRANS_LINEAR} for cases where the first key of the track begins with a non-zero value or where the key value does not change, and {@link Tween.TRANS_QUAD} for cases where the key value changes linearly.
+   */
+  capture(name: string, duration: float, trans_type: int, ease_type: int): void;
+  /**
+   * {@link AnimationMixer} caches animated nodes. It may not notice if a node disappears; {@link clear_caches} forces it to update the cache again.
+   */
+  clear_caches(): void;
+  /** Returns the key of `animation` or an empty {@link StringName} if not found. */
+  find_animation(animation: Animation): string;
+  /**
+   * Returns the key for the {@link AnimationLibrary} that contains `animation` or an empty {@link StringName} if not found.
+   */
+  find_animation_library(animation: Animation): string;
+  /**
+   * Returns the {@link Animation} with the key `name`. If the animation does not exist, `null` is returned and an error is logged.
+   */
+  get_animation(name: string): Animation | null;
+  /**
+   * Returns the first {@link AnimationLibrary} with key `name` or `null` if not found.
+   * To get the {@link AnimationMixer}'s global animation library, use `get_animation_library("")`.
+   */
+  get_animation_library(name: string): AnimationLibrary | null;
+  /** Returns the list of stored library keys. */
+  get_animation_library_list(): Array<string>;
+  /** Returns the list of stored animation keys. */
+  get_animation_list(): PackedStringArray;
+  /**
+   * Retrieve the motion delta of position with the {@link root_motion_track} as a {@link Vector3} that can be used elsewhere.
+   * If {@link root_motion_track} is not a path to a track of type {@link Animation.TYPE_POSITION_3D}, returns `Vector3(0, 0, 0)`.
+   * See also {@link root_motion_track} and {@link RootMotionView}.
+   * The most basic example is applying position to {@link CharacterBody3D}:
+   * By using this in combination with {@link get_root_motion_rotation_accumulator}, you can apply the root motion position more correctly to account for the rotation of the node.
+   * If {@link root_motion_local} is `true`, returns the pre-multiplied translation value with the inverted rotation.
+   * In this case, the code can be written as follows:
+   */
+  get_root_motion_position(): Vector3;
+  /**
+   * Retrieve the blended value of the position tracks with the {@link root_motion_track} as a {@link Vector3} that can be used elsewhere.
+   * This is useful in cases where you want to respect the initial key values of the animation.
+   * For example, if an animation with only one key `Vector3(0, 0, 0)` is played in the previous frame and then an animation with only one key `Vector3(1, 0, 1)` is played in the next frame, the difference can be calculated as follows:
+   * However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
+   */
+  get_root_motion_position_accumulator(): Vector3;
+  /**
+   * Retrieve the motion delta of rotation with the {@link root_motion_track} as a {@link Quaternion} that can be used elsewhere.
+   * If {@link root_motion_track} is not a path to a track of type {@link Animation.TYPE_ROTATION_3D}, returns `Quaternion(0, 0, 0, 1)`.
+   * See also {@link root_motion_track} and {@link RootMotionView}.
+   * The most basic example is applying rotation to {@link CharacterBody3D}:
+   */
+  get_root_motion_rotation(): Quaternion;
+  /**
+   * Retrieve the blended value of the rotation tracks with the {@link root_motion_track} as a {@link Quaternion} that can be used elsewhere.
+   * This is necessary to apply the root motion position correctly, taking rotation into account. See also {@link get_root_motion_position}.
+   * Also, this is useful in cases where you want to respect the initial key values of the animation.
+   * For example, if an animation with only one key `Quaternion(0, 0, 0, 1)` is played in the previous frame and then an animation with only one key `Quaternion(0, 0.707, 0, 0.707)` is played in the next frame, the difference can be calculated as follows:
+   * However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
+   */
+  get_root_motion_rotation_accumulator(): Quaternion;
+  /**
+   * Retrieve the motion delta of scale with the {@link root_motion_track} as a {@link Vector3} that can be used elsewhere.
+   * If {@link root_motion_track} is not a path to a track of type {@link Animation.TYPE_SCALE_3D}, returns `Vector3(0, 0, 0)`.
+   * See also {@link root_motion_track} and {@link RootMotionView}.
+   * The most basic example is applying scale to {@link CharacterBody3D}:
+   */
+  get_root_motion_scale(): Vector3;
+  /**
+   * Retrieve the blended value of the scale tracks with the {@link root_motion_track} as a {@link Vector3} that can be used elsewhere.
+   * For example, if an animation with only one key `Vector3(1, 1, 1)` is played in the previous frame and then an animation with only one key `Vector3(2, 2, 2)` is played in the next frame, the difference can be calculated as follows:
+   * However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
+   */
+  get_root_motion_scale_accumulator(): Vector3;
+  /** Returns `true` if the {@link AnimationMixer} stores an {@link Animation} with key `name`. */
+  has_animation(name: string): boolean;
+  /** Returns `true` if the {@link AnimationMixer} stores an {@link AnimationLibrary} with key `name`. */
+  has_animation_library(name: string): boolean;
+  /** Removes the {@link AnimationLibrary} associated with the key `name`. */
+  remove_animation_library(name: string): void;
+  /** Moves the {@link AnimationLibrary} associated with the key `name` to the key `newname`. */
+  rename_animation_library(name: string, newname: string): void;
+
+  /**
+   * Notifies when an animation finished playing.
+   * **Note:** This signal is not emitted if an animation is looping.
+   */
+  animation_finished: Signal<[string]>;
+  /** Notifies when the animation libraries have changed. */
+  animation_libraries_updated: Signal<[]>;
+  /** Notifies when an animation list is changed. */
+  animation_list_changed: Signal<[]>;
+  /**
+   * Notifies when an animation starts playing.
+   * **Note:** This signal is not emitted if an animation is looping.
+   */
+  animation_started: Signal<[string]>;
+  /**
+   * Notifies when the caches have been cleared, either automatically, or manually via {@link clear_caches}.
+   */
+  caches_cleared: Signal<[]>;
+  /** Notifies when the blending result related have been applied to the target objects. */
+  mixer_applied: Signal<[]>;
+  /** Notifies when the property related process have been updated. */
+  mixer_updated: Signal<[]>;
+
+  // enum AnimationCallbackModeProcess
+  /**
+   * Process animation during physics frames (see {@link Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS}). This is especially useful when animating physics bodies.
+   */
+  static readonly ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS: int;
+  /** Process animation during process frames (see {@link Node.NOTIFICATION_INTERNAL_PROCESS}). */
+  static readonly ANIMATION_CALLBACK_MODE_PROCESS_IDLE: int;
+  /** Do not process animation. Use {@link advance} to process the animation manually. */
+  static readonly ANIMATION_CALLBACK_MODE_PROCESS_MANUAL: int;
+  // enum AnimationCallbackModeMethod
+  /**
+   * Batch method calls during the animation process, then do the calls after events are processed. This avoids bugs involving deleting nodes or modifying the AnimationPlayer while playing.
+   */
+  static readonly ANIMATION_CALLBACK_MODE_METHOD_DEFERRED: int;
+  /** Make method calls immediately when reached in the animation. */
+  static readonly ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE: int;
+  // enum AnimationCallbackModeDiscrete
+  /**
+   * An {@link Animation.UPDATE_DISCRETE} track value takes precedence when blending {@link Animation.UPDATE_CONTINUOUS} or {@link Animation.UPDATE_CAPTURE} track values and {@link Animation.UPDATE_DISCRETE} track values.
+   */
+  static readonly ANIMATION_CALLBACK_MODE_DISCRETE_DOMINANT: int;
+  /**
+   * An {@link Animation.UPDATE_CONTINUOUS} or {@link Animation.UPDATE_CAPTURE} track value takes precedence when blending the {@link Animation.UPDATE_CONTINUOUS} or {@link Animation.UPDATE_CAPTURE} track values and the {@link Animation.UPDATE_DISCRETE} track values. This is the default behavior for {@link AnimationPlayer}.
+   */
+  static readonly ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE: int;
+  /**
+   * Always treat the {@link Animation.UPDATE_DISCRETE} track value as {@link Animation.UPDATE_CONTINUOUS} with {@link Animation.INTERPOLATION_NEAREST}. This is the default behavior for {@link AnimationTree}.
+   * If a value track has un-interpolatable type key values, it is internally converted to use {@link ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE} with {@link Animation.UPDATE_DISCRETE}.
+   * Un-interpolatable type list:
+   * - {@link @GlobalScope.TYPE_NIL}
+   * - {@link @GlobalScope.TYPE_NODE_PATH}
+   * - {@link @GlobalScope.TYPE_RID}
+   * - {@link @GlobalScope.TYPE_OBJECT}
+   * - {@link @GlobalScope.TYPE_CALLABLE}
+   * - {@link @GlobalScope.TYPE_SIGNAL}
+   * - {@link @GlobalScope.TYPE_DICTIONARY}
+   * - {@link @GlobalScope.TYPE_PACKED_BYTE_ARRAY}
+   * {@link @GlobalScope.TYPE_BOOL} and {@link @GlobalScope.TYPE_INT} are treated as {@link @GlobalScope.TYPE_FLOAT} during blending and rounded when the result is retrieved.
+   * It is same for arrays and vectors with them such as {@link @GlobalScope.TYPE_PACKED_INT32_ARRAY} or {@link @GlobalScope.TYPE_VECTOR2I}, they are treated as {@link @GlobalScope.TYPE_PACKED_FLOAT32_ARRAY} or {@link @GlobalScope.TYPE_VECTOR2}. Also note that for arrays, the size is also interpolated.
+   * {@link @GlobalScope.TYPE_STRING} and {@link @GlobalScope.TYPE_STRING_NAME} are interpolated between character codes and lengths, but note that there is a difference in algorithm between interpolation between keys and interpolation by blending.
+   */
+  static readonly ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS: int;
+}

package/typings/classes/AnimationNode.d.ts

@@ -0,0 +1,116 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for {@link AnimationTree} nodes. Not related to scene nodes. */
+declare class AnimationNode extends Resource {
+  /** If `true`, filtering is enabled. */
+  filter_enabled: boolean;
+  set_filter_enabled(value: boolean): void;
+  is_filter_enabled(): boolean;
+
+  /**
+   * When inheriting from {@link AnimationRootNode}, implement this virtual method to override the text caption for this animation node.
+   */
+  _get_caption(): string;
+  /**
+   * When inheriting from {@link AnimationRootNode}, implement this virtual method to return a child animation node by its `name`.
+   */
+  _get_child_by_name(name: string): AnimationNode | null;
+  /**
+   * When inheriting from {@link AnimationRootNode}, implement this virtual method to return all child animation nodes in order as a `name: node` dictionary.
+   */
+  _get_child_nodes(): Dictionary;
+  /**
+   * When inheriting from {@link AnimationRootNode}, implement this virtual method to return the default value of a `parameter`. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees.
+   */
+  _get_parameter_default_value(parameter: string): unknown;
+  /**
+   * When inheriting from {@link AnimationRootNode}, implement this virtual method to return a list of the properties on this animation node. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees. Format is similar to {@link Object.get_property_list}.
+   */
+  _get_parameter_list(): Array<unknown>;
+  /**
+   * When inheriting from {@link AnimationRootNode}, implement this virtual method to return whether the blend tree editor should display filter editing on this animation node.
+   */
+  _has_filter(): boolean;
+  /**
+   * When inheriting from {@link AnimationRootNode}, implement this virtual method to return whether the `parameter` is read-only. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees.
+   */
+  _is_parameter_read_only(parameter: string): boolean;
+  /**
+   * When inheriting from {@link AnimationRootNode}, implement this virtual method to run some code when this animation node is processed. The `time` parameter is a relative delta, unless `seek` is `true`, in which case it is absolute.
+   * Here, call the {@link blend_input}, {@link blend_node} or {@link blend_animation} functions. You can also use {@link get_parameter} and {@link set_parameter} to modify local memory.
+   * This function should return the delta.
+   */
+  _process(time: float, seek: boolean, is_external_seeking: boolean, test_only: boolean): float;
+  /**
+   * Adds an input to the animation node. This is only useful for animation nodes created for use in an {@link AnimationNodeBlendTree}. If the addition fails, returns `false`.
+   */
+  add_input(name: string | NodePath): boolean;
+  /**
+   * Blends an animation by `blend` amount (name must be valid in the linked {@link AnimationPlayer}). A `time` and `delta` may be passed, as well as whether `seeked` happened.
+   * A `looped_flag` is used by internal processing immediately after the loop.
+   */
+  blend_animation(animation: string, time: float, delta: float, seeked: boolean, is_external_seeking: boolean, blend: float, looped_flag: int): void;
+  /**
+   * Blends an input. This is only useful for animation nodes created for an {@link AnimationNodeBlendTree}. The `time` parameter is a relative delta, unless `seek` is `true`, in which case it is absolute. A filter mode may be optionally passed.
+   */
+  blend_input(input_index: int, time: float, seek: boolean, is_external_seeking: boolean, blend: float, filter: int, sync?: boolean, test_only?: boolean): float;
+  /**
+   * Blend another animation node (in case this animation node contains child animation nodes). This function is only useful if you inherit from {@link AnimationRootNode} instead, otherwise editors will not display your animation node for addition.
+   */
+  blend_node(name: string, node: AnimationNode, time: float, seek: boolean, is_external_seeking: boolean, blend: float, filter: int, sync?: boolean, test_only?: boolean): float;
+  /** Returns the input index which corresponds to `name`. If not found, returns `-1`. */
+  find_input(name: string | NodePath): int;
+  /**
+   * Amount of inputs in this animation node, only useful for animation nodes that go into {@link AnimationNodeBlendTree}.
+   */
+  get_input_count(): int;
+  /** Gets the name of an input by index. */
+  get_input_name(input: int): string;
+  /**
+   * Gets the value of a parameter. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees.
+   */
+  get_parameter(name: string): unknown;
+  /**
+   * Returns the object id of the {@link AnimationTree} that owns this node.
+   * **Note:** This method should only be called from within the {@link AnimationNodeExtension._process_animation_node} method, and will return an invalid id otherwise.
+   */
+  get_processing_animation_tree_instance_id(): int;
+  /** Returns `true` if the given path is filtered. */
+  is_path_filtered(path: NodePath | string): boolean;
+  /** Returns `true` if this animation node is being processed in test-only mode. */
+  is_process_testing(): boolean;
+  /** Removes an input, call this only when inactive. */
+  remove_input(index: int): void;
+  /** Adds or removes a path for the filter. */
+  set_filter_path(path: NodePath | string, enable: boolean): void;
+  /** Sets the name of the input at the given `input` index. If the setting fails, returns `false`. */
+  set_input_name(input: int, name: string | NodePath): boolean;
+  /**
+   * Sets a custom parameter. These are used as local memory, because resources can be reused across the tree or scenes.
+   */
+  set_parameter(name: string, value: unknown): void;
+
+  /**
+   * Emitted by nodes that inherit from this class and that have an internal tree when one of their animation nodes removes. The animation nodes that emit this signal are {@link AnimationNodeBlendSpace1D}, {@link AnimationNodeBlendSpace2D}, {@link AnimationNodeStateMachine}, and {@link AnimationNodeBlendTree}.
+   */
+  animation_node_removed: Signal<[int, string]>;
+  /**
+   * Emitted by nodes that inherit from this class and that have an internal tree when one of their animation node names changes. The animation nodes that emit this signal are {@link AnimationNodeBlendSpace1D}, {@link AnimationNodeBlendSpace2D}, {@link AnimationNodeStateMachine}, and {@link AnimationNodeBlendTree}.
+   */
+  animation_node_renamed: Signal<[int, string, string]>;
+  /**
+   * Emitted by nodes that inherit from this class and that have an internal tree when one of their animation nodes changes. The animation nodes that emit this signal are {@link AnimationNodeBlendSpace1D}, {@link AnimationNodeBlendSpace2D}, {@link AnimationNodeStateMachine}, {@link AnimationNodeBlendTree} and {@link AnimationNodeTransition}.
+   */
+  tree_changed: Signal<[]>;
+
+  // enum FilterAction
+  /** Do not use filtering. */
+  static readonly FILTER_IGNORE: int;
+  /** Paths matching the filter will be allowed to pass. */
+  static readonly FILTER_PASS: int;
+  /** Paths matching the filter will be discarded. */
+  static readonly FILTER_STOP: int;
+  /** Paths matching the filter will be blended (by the blend value). */
+  static readonly FILTER_BLEND: int;
+}

package/typings/classes/AnimationNodeAdd2.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Blends two animations additively inside of an {@link AnimationNodeBlendTree}. */
+declare class AnimationNodeAdd2 extends AnimationNodeSync {
+}

package/typings/classes/AnimationNodeAdd3.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Blends two of three animations additively inside of an {@link AnimationNodeBlendTree}. */
+declare class AnimationNodeAdd3 extends AnimationNodeSync {
+}

package/typings/classes/AnimationNodeAnimation.d.ts

@@ -0,0 +1,64 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An input animation for an {@link AnimationNodeBlendTree}. */
+declare class AnimationNodeAnimation extends AnimationRootNode {
+  /**
+   * If `true`, on receiving a request to play an animation from the start, the first frame is not drawn, but only processed, and playback starts from the next frame.
+   * See also the notes of {@link AnimationPlayer.play}.
+   */
+  advance_on_start: boolean;
+  /**
+   * Animation to use as an output. It is one of the animations provided by {@link AnimationTree.anim_player}.
+   */
+  animation: string;
+  /**
+   * If {@link use_custom_timeline} is `true`, override the loop settings of the original {@link Animation} resource with the value.
+   * **Note:** If the {@link Animation.loop_mode} isn't set to looping, the {@link Animation.track_set_interpolation_loop_wrap} option will not be respected. If you cannot get the expected behavior, consider duplicating the {@link Animation} resource and changing the loop settings.
+   */
+  loop_mode: int;
+  /** Determines the playback direction of the animation. */
+  play_mode: int;
+  /**
+   * If {@link use_custom_timeline} is `true`, offset the start position of the animation.
+   * This is useful for adjusting which foot steps first in 3D walking animations.
+   */
+  start_offset: float;
+  /**
+   * If `true`, scales the time so that the length specified in {@link timeline_length} is one cycle.
+   * This is useful for matching the periods of walking and running animations.
+   * If `false`, the original animation length is respected. If you set the loop to {@link loop_mode}, the animation will loop in {@link timeline_length}.
+   */
+  stretch_time_scale: boolean;
+  /**
+   * The length of the custom timeline.
+   * If {@link stretch_time_scale} is `true`, scales the animation to this length.
+   */
+  timeline_length: float;
+  /**
+   * If `true`, {@link AnimationNode} provides an animation based on the {@link Animation} resource with some parameters adjusted.
+   */
+  use_custom_timeline: boolean;
+  set_advance_on_start(value: boolean): void;
+  is_advance_on_start(): boolean;
+  set_animation(value: string): void;
+  get_animation(): string;
+  set_loop_mode(value: int): void;
+  get_loop_mode(): int;
+  set_play_mode(value: int): void;
+  get_play_mode(): int;
+  set_start_offset(value: float): void;
+  get_start_offset(): float;
+  set_stretch_time_scale(value: boolean): void;
+  is_stretching_time_scale(): boolean;
+  set_timeline_length(value: float): void;
+  get_timeline_length(): float;
+  set_use_custom_timeline(value: boolean): void;
+  is_using_custom_timeline(): boolean;
+
+  // enum PlayMode
+  /** Plays animation in forward direction. */
+  static readonly PLAY_MODE_FORWARD: int;
+  /** Plays animation in backward direction. */
+  static readonly PLAY_MODE_BACKWARD: int;
+}

package/typings/classes/AnimationNodeBlend2.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Blends two animations linearly inside of an {@link AnimationNodeBlendTree}. */
+declare class AnimationNodeBlend2 extends AnimationNodeSync {
+}

package/typings/classes/AnimationNodeBlend3.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Blends two of three animations linearly inside of an {@link AnimationNodeBlendTree}. */
+declare class AnimationNodeBlend3 extends AnimationNodeSync {
+}

package/typings/classes/AnimationNodeBlendSpace1D.d.ts

@@ -0,0 +1,79 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A set of {@link AnimationRootNode}s placed on a virtual axis, crossfading between the two adjacent ones. Used by {@link AnimationTree}.
+ */
+declare class AnimationNodeBlendSpace1D extends AnimationRootNode {
+  /** Controls the interpolation between animations. */
+  blend_mode: int;
+  /** The blend space's axis's upper limit for the points' position. See {@link add_blend_point}. */
+  max_space: float;
+  /** The blend space's axis's lower limit for the points' position. See {@link add_blend_point}. */
+  min_space: float;
+  /** Position increment to snap to when moving a point on the axis. */
+  snap: float;
+  /**
+   * If `false`, the blended animations' frame are stopped when the blend value is `0`.
+   * If `true`, forcing the blended animations to advance frame.
+   */
+  sync: boolean;
+  /** Label of the virtual axis of the blend space. */
+  value_label: string;
+  set_blend_mode(value: int): void;
+  get_blend_mode(): int;
+  set_max_space(value: float): void;
+  get_max_space(): float;
+  set_min_space(value: float): void;
+  get_min_space(): float;
+  set_snap(value: float): void;
+  get_snap(): float;
+  set_use_sync(value: boolean): void;
+  is_using_sync(): boolean;
+  set_value_label(value: string | NodePath): void;
+  get_value_label(): string;
+
+  /**
+   * Adds a new point with `name` that represents a `node` on the virtual axis at a given position set by `pos`. You can insert it at a specific index using the `at_index` argument. If you use the default value for `at_index`, the point is inserted at the end of the blend points array.
+   * **Note:** If no name is provided, safe index is used as reference. In the future, empty names will be deprecated, so explicitly passing a name is recommended.
+   */
+  add_blend_point(node: AnimationRootNode, pos: float, at_index?: int, name?: string): void;
+  /**
+   * Returns the index of the blend point with the given `name`. Returns `-1` if no blend point with that name is found.
+   */
+  find_blend_point_by_name(name: string): int;
+  /** Returns the number of points on the blend axis. */
+  get_blend_point_count(): int;
+  /** Returns the name of the blend point at index `point`. */
+  get_blend_point_name(point: int): string;
+  /** Returns the {@link AnimationNode} referenced by the point at index `point`. */
+  get_blend_point_node(point: int): AnimationRootNode | null;
+  /** Returns the position of the point at index `point`. */
+  get_blend_point_position(point: int): float;
+  /** Removes the point at index `point` from the blend axis. */
+  remove_blend_point(point: int): void;
+  /**
+   * Swaps the blend points at indices `from_index` and `to_index`, exchanging their positions and properties.
+   */
+  reorder_blend_point(from_index: int, to_index: int): void;
+  /**
+   * Sets the name of the blend point at index `point`. If the name conflicts with an existing point, a unique name will be generated automatically.
+   */
+  set_blend_point_name(point: int, name: string): void;
+  /** Changes the {@link AnimationNode} referenced by the point at index `point`. */
+  set_blend_point_node(point: int, node: AnimationRootNode): void;
+  /** Updates the position of the point at index `point` on the blend axis. */
+  set_blend_point_position(point: int, pos: float): void;
+
+  // enum BlendMode
+  /** The interpolation between animations is linear. */
+  static readonly BLEND_MODE_INTERPOLATED: int;
+  /**
+   * The blend space plays the animation of the animation node which blending position is closest to. Useful for frame-by-frame 2D animations.
+   */
+  static readonly BLEND_MODE_DISCRETE: int;
+  /**
+   * Similar to {@link BLEND_MODE_DISCRETE}, but starts the new animation at the last animation's playback position.
+   */
+  static readonly BLEND_MODE_DISCRETE_CARRY: int;
+}

package/typings/classes/AnimationNodeBlendSpace2D.d.ts

@@ -0,0 +1,104 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A set of {@link AnimationRootNode}s placed on 2D coordinates, crossfading between the three adjacent ones. Used by {@link AnimationTree}.
+ */
+declare class AnimationNodeBlendSpace2D extends AnimationRootNode {
+  /**
+   * If `true`, the blend space is triangulated automatically. The mesh updates every time you add or remove points with {@link add_blend_point} and {@link remove_blend_point}.
+   */
+  auto_triangles: boolean;
+  /** Controls the interpolation between animations. */
+  blend_mode: int;
+  /** The blend space's X and Y axes' upper limit for the points' position. See {@link add_blend_point}. */
+  max_space: Vector2;
+  /** The blend space's X and Y axes' lower limit for the points' position. See {@link add_blend_point}. */
+  min_space: Vector2;
+  /** Position increment to snap to when moving a point. */
+  snap: Vector2;
+  /**
+   * If `false`, the blended animations' frame are stopped when the blend value is `0`.
+   * If `true`, forcing the blended animations to advance frame.
+   */
+  sync: boolean;
+  /** Name of the blend space's X axis. */
+  x_label: string;
+  /** Name of the blend space's Y axis. */
+  y_label: string;
+  set_auto_triangles(value: boolean): void;
+  get_auto_triangles(): boolean;
+  set_blend_mode(value: int): void;
+  get_blend_mode(): int;
+  set_max_space(value: Vector2 | Vector2i): void;
+  get_max_space(): Vector2;
+  set_min_space(value: Vector2 | Vector2i): void;
+  get_min_space(): Vector2;
+  set_snap(value: Vector2 | Vector2i): void;
+  get_snap(): Vector2;
+  set_use_sync(value: boolean): void;
+  is_using_sync(): boolean;
+  set_x_label(value: string | NodePath): void;
+  get_x_label(): string;
+  set_y_label(value: string | NodePath): void;
+  get_y_label(): string;
+
+  /**
+   * Adds a new point with `name` that represents a `node` at the position set by `pos`. You can insert it at a specific index using the `at_index` argument. If you use the default value for `at_index`, the point is inserted at the end of the blend points array.
+   * **Note:** If no name is provided, safe index is used as reference. In the future, empty names will be deprecated, so explicitly passing a name is recommended.
+   */
+  add_blend_point(node: AnimationRootNode, pos: Vector2 | Vector2i, at_index?: int, name?: string): void;
+  /**
+   * Creates a new triangle using three points `x`, `y`, and `z`. Triangles can overlap. You can insert the triangle at a specific index using the `at_index` argument. If you use the default value for `at_index`, the point is inserted at the end of the blend points array.
+   */
+  add_triangle(x: int, y: int, z: int, at_index?: int): void;
+  /**
+   * Returns the index of the blend point with the given `name`. Returns `-1` if no blend point with that name is found.
+   */
+  find_blend_point_by_name(name: string): int;
+  /** Returns the number of points in the blend space. */
+  get_blend_point_count(): int;
+  /** Returns the name of the blend point at index `point`. */
+  get_blend_point_name(point: int): string;
+  /** Returns the {@link AnimationRootNode} referenced by the point at index `point`. */
+  get_blend_point_node(point: int): AnimationRootNode | null;
+  /** Returns the position of the point at index `point`. */
+  get_blend_point_position(point: int): Vector2;
+  /** Returns the number of triangles in the blend space. */
+  get_triangle_count(): int;
+  /** Returns the position of the point at index `point` in the triangle of index `triangle`. */
+  get_triangle_point(triangle: int, point: int): int;
+  /** Removes the point at index `point` from the blend space. */
+  remove_blend_point(point: int): void;
+  /** Removes the triangle at index `triangle` from the blend space. */
+  remove_triangle(triangle: int): void;
+  /**
+   * Swaps the blend points at indices `from_index` and `to_index`, exchanging their positions and properties.
+   */
+  reorder_blend_point(from_index: int, to_index: int): void;
+  /**
+   * Sets the name of the blend point at index `point`. If the name conflicts with an existing point, a unique name will be generated automatically.
+   */
+  set_blend_point_name(point: int, name: string): void;
+  /** Changes the {@link AnimationNode} referenced by the point at index `point`. */
+  set_blend_point_node(point: int, node: AnimationRootNode): void;
+  /** Updates the position of the point at index `point` in the blend space. */
+  set_blend_point_position(point: int, pos: Vector2 | Vector2i): void;
+
+  /**
+   * Emitted every time the blend space's triangles are created, removed, or when one of their vertices changes position.
+   */
+  triangles_updated: Signal<[]>;
+
+  // enum BlendMode
+  /** The interpolation between animations is linear. */
+  static readonly BLEND_MODE_INTERPOLATED: int;
+  /**
+   * The blend space plays the animation of the animation node which blending position is closest to. Useful for frame-by-frame 2D animations.
+   */
+  static readonly BLEND_MODE_DISCRETE: int;
+  /**
+   * Similar to {@link BLEND_MODE_DISCRETE}, but starts the new animation at the last animation's playback position.
+   */
+  static readonly BLEND_MODE_DISCRETE_CARRY: int;
+}