typescript-to-gdscript 0.1.0

package/typings/classes/AnimationNodeBlendTree.d.ts

@@ -0,0 +1,53 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A sub-tree of many type {@link AnimationNode}s used for complex animations. Used by {@link AnimationTree}.
+ */
+declare class AnimationNodeBlendTree extends AnimationRootNode {
+  /** The global offset of all sub animation nodes. */
+  graph_offset: Vector2;
+  set_graph_offset(value: Vector2 | Vector2i): void;
+  get_graph_offset(): Vector2;
+
+  /**
+   * Adds an {@link AnimationNode} at the given `position`. The `name` is used to identify the created sub animation node later.
+   */
+  add_node(name: string, node: AnimationNode, position?: Vector2 | Vector2i): void;
+  /**
+   * Connects the output of an {@link AnimationNode} as input for another {@link AnimationNode}, at the input port specified by `input_index`.
+   */
+  connect_node(input_node: string, input_index: int, output_node: string): void;
+  /** Disconnects the animation node connected to the specified input. */
+  disconnect_node(input_node: string, input_index: int): void;
+  /** Returns the sub animation node with the specified `name`. */
+  get_node(name: string): AnimationNode | null;
+  /** Returns a list containing the names of all sub animation nodes in this blend tree. */
+  get_node_list(): Array<string>;
+  /** Returns the position of the sub animation node with the specified `name`. */
+  get_node_position(name: string): Vector2;
+  /** Returns `true` if a sub animation node with specified `name` exists. */
+  has_node(name: string): boolean;
+  /** Removes a sub animation node. */
+  remove_node(name: string): void;
+  /** Changes the name of a sub animation node. */
+  rename_node(name: string, new_name: string): void;
+  /** Modifies the position of a sub animation node. */
+  set_node_position(name: string, position: Vector2 | Vector2i): void;
+
+  /** Emitted when the input port information is changed. */
+  node_changed: Signal<[string]>;
+
+  /** The connection was successful. */
+  static readonly CONNECTION_OK: int;
+  /** The input node is `null`. */
+  static readonly CONNECTION_ERROR_NO_INPUT: int;
+  /** The specified input port is out of range. */
+  static readonly CONNECTION_ERROR_NO_INPUT_INDEX: int;
+  /** The output node is `null`. */
+  static readonly CONNECTION_ERROR_NO_OUTPUT: int;
+  /** Input and output nodes are the same. */
+  static readonly CONNECTION_ERROR_SAME_NODE: int;
+  /** The specified connection already exists. */
+  static readonly CONNECTION_ERROR_CONNECTION_EXISTS: int;
+}

package/typings/classes/AnimationNodeExtension.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for extending {@link AnimationRootNode}s from GDScript, C#, or C++. */
+declare class AnimationNodeExtension extends AnimationNode {
+  /**
+   * A version of the {@link AnimationNode._process} method that is meant to be overridden by custom nodes. It returns a {@link PackedFloat32Array} with the processed animation data.
+   * The {@link PackedFloat64Array} parameter contains the playback information, containing the following values encoded as floating point numbers (in order): playback time and delta, start and end times, whether a seek was requested (encoded as a float greater than `0`), whether the seek request was externally requested (encoded as a float greater than `0`), the current {@link Animation.LoopedFlag} (encoded as a float), and the current blend weight.
+   * The function must return a {@link PackedFloat32Array} of the node's time info, containing the following values (in order): animation length, time position, delta, {@link Animation.LoopMode} (encoded as a float), whether the animation is about to end (encoded as a float greater than `0`) and whether the animation is infinite (encoded as a float greater than `0`). All values must be included in the returned array.
+   */
+  _process_animation_node(playback_info: PackedFloat64Array | Array<unknown>, test_only: boolean): PackedFloat32Array;
+  /**
+   * Returns the animation's remaining time for the given node info. For looping animations, it will only return the remaining time if `break_loop` is `true`, a large integer value will be returned otherwise.
+   */
+  static get_remaining_time(node_info: PackedFloat32Array | Array<unknown>, break_loop: boolean): float;
+  /** Returns `true` if the animation for the given `node_info` is looping. */
+  static is_looping(node_info: PackedFloat32Array | Array<unknown>): boolean;
+}

package/typings/classes/AnimationNodeOneShot.d.ts

@@ -0,0 +1,78 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Plays an animation once in an {@link AnimationNodeBlendTree}. */
+declare class AnimationNodeOneShot extends AnimationNodeSync {
+  /** If `true`, the sub-animation will abort if resumed with a reset after a prior interruption. */
+  abort_on_reset: boolean;
+  /**
+   * If `true`, the sub-animation will restart automatically after finishing.
+   * In other words, to start auto restarting, the animation must be played once with the {@link ONE_SHOT_REQUEST_FIRE} request. The {@link ONE_SHOT_REQUEST_ABORT} request stops the auto restarting, but it does not disable the {@link autorestart} itself. So, the {@link ONE_SHOT_REQUEST_FIRE} request will start auto restarting again.
+   */
+  autorestart: boolean;
+  /** The delay after which the automatic restart is triggered, in seconds. */
+  autorestart_delay: float;
+  /**
+   * If {@link autorestart} is `true`, a random additional delay (in seconds) between 0 and this value will be added to {@link autorestart_delay}.
+   */
+  autorestart_random_delay: float;
+  /**
+   * If `true`, breaks the loop at the end of the loop cycle for transition, even if the animation is looping.
+   */
+  break_loop_at_end: boolean;
+  /**
+   * Determines how cross-fading between animations is eased. If empty, the transition will be linear. Should be a unit {@link Curve}.
+   */
+  fadein_curve: Curve | null;
+  /**
+   * The fade-in duration. For example, setting this to `1.0` for a 5 second length animation will produce a cross-fade that starts at 0 second and ends at 1 second during the animation.
+   * **Note:** {@link AnimationNodeOneShot} transitions the current state after the fading has finished.
+   */
+  fadein_time: float;
+  /**
+   * Determines how cross-fading between animations is eased. If empty, the transition will be linear. Should be a unit {@link Curve}.
+   */
+  fadeout_curve: Curve | null;
+  /**
+   * The fade-out duration. For example, setting this to `1.0` for a 5 second length animation will produce a cross-fade that starts at 4 second and ends at 5 second during the animation.
+   * **Note:** {@link AnimationNodeOneShot} transitions the current state after the fading has finished.
+   */
+  fadeout_time: float;
+  /** The blend type. */
+  mix_mode: int;
+  set_abort_on_reset(value: boolean): void;
+  is_aborted_on_reset(): boolean;
+  set_autorestart(value: boolean): void;
+  has_autorestart(): boolean;
+  set_autorestart_delay(value: float): void;
+  get_autorestart_delay(): float;
+  set_autorestart_random_delay(value: float): void;
+  get_autorestart_random_delay(): float;
+  set_break_loop_at_end(value: boolean): void;
+  is_loop_broken_at_end(): boolean;
+  set_fadein_curve(value: Curve | null): void;
+  get_fadein_curve(): Curve | null;
+  set_fadein_time(value: float): void;
+  get_fadein_time(): float;
+  set_fadeout_curve(value: Curve | null): void;
+  get_fadeout_curve(): Curve | null;
+  set_fadeout_time(value: float): void;
+  get_fadeout_time(): float;
+  set_mix_mode(value: int): void;
+  get_mix_mode(): int;
+
+  // enum OneShotRequest
+  /** The default state of the request. Nothing is done. */
+  static readonly ONE_SHOT_REQUEST_NONE: int;
+  /** The request to play the animation connected to "shot" port. */
+  static readonly ONE_SHOT_REQUEST_FIRE: int;
+  /** The request to stop the animation connected to "shot" port. */
+  static readonly ONE_SHOT_REQUEST_ABORT: int;
+  /** The request to fade out the animation connected to "shot" port. */
+  static readonly ONE_SHOT_REQUEST_FADE_OUT: int;
+  // enum MixMode
+  /** Blends two animations. See also {@link AnimationNodeBlend2}. */
+  static readonly MIX_MODE_BLEND: int;
+  /** Blends two animations additively. See also {@link AnimationNodeAdd2}. */
+  static readonly MIX_MODE_ADD: int;
+}

package/typings/classes/AnimationNodeOutput.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** The animation output node of an {@link AnimationNodeBlendTree}. */
+declare class AnimationNodeOutput extends AnimationNode {
+}

package/typings/classes/AnimationNodeStateMachine.d.ts

@@ -0,0 +1,80 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A state machine with multiple {@link AnimationRootNode}s, used by {@link AnimationTree}. */
+declare class AnimationNodeStateMachine extends AnimationRootNode {
+  /**
+   * If `true`, allows teleport to the self state with {@link AnimationNodeStateMachinePlayback.travel}. When the reset option is enabled in {@link AnimationNodeStateMachinePlayback.travel}, the animation is restarted. If `false`, nothing happens on the teleportation to the self state.
+   */
+  allow_transition_to_self: boolean;
+  /**
+   * If `true`, treat the cross-fade to the start and end nodes as a blend with the RESET animation.
+   * In most cases, when additional cross-fades are performed in the parent {@link AnimationNode} of the state machine, setting this property to `false` and matching the cross-fade time of the parent {@link AnimationNode} and the state machine's start node and end node gives good results.
+   */
+  reset_ends: boolean;
+  /**
+   * This property can define the process of transitions for different use cases. See also {@link AnimationNodeStateMachine.StateMachineType}.
+   */
+  state_machine_type: int;
+  set_allow_transition_to_self(value: boolean): void;
+  is_allow_transition_to_self(): boolean;
+  set_reset_ends(value: boolean): void;
+  are_ends_reset(): boolean;
+  set_state_machine_type(value: int): void;
+  get_state_machine_type(): int;
+
+  /** Adds a new animation node to the graph. The `position` is used for display in the editor. */
+  add_node(name: string, node: AnimationNode, position?: Vector2 | Vector2i): void;
+  /** Adds a transition between the given animation nodes. */
+  add_transition(from_: string, to: string, transition: AnimationNodeStateMachineTransition): void;
+  /** Returns the draw offset of the graph. Used for display in the editor. */
+  get_graph_offset(): Vector2;
+  /** Returns the animation node with the given name. */
+  get_node(name: string): AnimationNode | null;
+  /** Returns a list containing the names of all animation nodes in this state machine. */
+  get_node_list(): Array<string>;
+  /** Returns the given animation node's name. */
+  get_node_name(node: AnimationNode): string;
+  /** Returns the given animation node's coordinates. Used for display in the editor. */
+  get_node_position(name: string): Vector2;
+  /** Returns the given transition. */
+  get_transition(idx: int): AnimationNodeStateMachineTransition | null;
+  /** Returns the number of connections in the graph. */
+  get_transition_count(): int;
+  /** Returns the given transition's start node. */
+  get_transition_from(idx: int): string;
+  /** Returns the given transition's end node. */
+  get_transition_to(idx: int): string;
+  /** Returns `true` if the graph contains the given animation node. */
+  has_node(name: string): boolean;
+  /** Returns `true` if there is a transition between the given animation nodes. */
+  has_transition(from_: string, to: string): boolean;
+  /** Deletes the given animation node from the graph. */
+  remove_node(name: string): void;
+  /** Deletes the transition between the two specified animation nodes. */
+  remove_transition(from_: string, to: string): void;
+  /** Deletes the given transition by index. */
+  remove_transition_by_index(idx: int): void;
+  /** Renames the given animation node. */
+  rename_node(name: string, new_name: string): void;
+  /** Replaces the given animation node with a new animation node. */
+  replace_node(name: string, node: AnimationNode): void;
+  /** Sets the draw offset of the graph. Used for display in the editor. */
+  set_graph_offset(offset: Vector2 | Vector2i): void;
+  /** Sets the animation node's coordinates. Used for display in the editor. */
+  set_node_position(name: string, position: Vector2 | Vector2i): void;
+
+  // enum StateMachineType
+  /**
+   * Seeking to the beginning is treated as playing from the start state. Transition to the end state is treated as exiting the state machine.
+   */
+  static readonly STATE_MACHINE_TYPE_ROOT: int;
+  /**
+   * Seeking to the beginning is treated as seeking to the beginning of the animation in the current state. Transition to the end state, or the absence of transitions in each state, is treated as exiting the state machine.
+   */
+  static readonly STATE_MACHINE_TYPE_NESTED: int;
+  /**
+   * This is a grouped state machine that can be controlled from a parent state machine. It does not work independently. There must be a state machine with {@link state_machine_type} of {@link STATE_MACHINE_TYPE_ROOT} or {@link STATE_MACHINE_TYPE_NESTED} in the parent or ancestor.
+   */
+  static readonly STATE_MACHINE_TYPE_GROUPED: int;
+}

package/typings/classes/AnimationNodeStateMachinePlayback.d.ts

@@ -0,0 +1,67 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides playback control for an {@link AnimationNodeStateMachine}. */
+declare class AnimationNodeStateMachinePlayback extends Resource {
+  resource_local_to_scene: boolean;
+
+  /**
+   * Returns the current state length.
+   * **Note:** It is possible that any {@link AnimationRootNode} can be nodes as well as animations. This means that there can be multiple animations within a single state. Which animation length has priority depends on the nodes connected inside it. Also, if a transition does not reset, the remaining length at that point will be returned.
+   */
+  get_current_length(): float;
+  /**
+   * Returns the currently playing animation state.
+   * **Note:** When using a cross-fade, the current state changes to the next state immediately after the cross-fade begins.
+   */
+  get_current_node(): string;
+  /** Returns the playback position within the current animation state. */
+  get_current_play_position(): float;
+  /**
+   * Returns the playback state length of the node from {@link get_fading_from_node}. Returns `0` if no animation fade is occurring.
+   */
+  get_fading_from_length(): float;
+  /** Returns the starting state of currently fading animation. */
+  get_fading_from_node(): string;
+  /**
+   * Returns the playback position of the node from {@link get_fading_from_node}. Returns `0` if no animation fade is occurring.
+   */
+  get_fading_from_play_position(): float;
+  /** Returns the length of the current fade animation. Returns `0` if no animation fade is occurring. */
+  get_fading_length(): float;
+  /**
+   * Returns the playback position of the current fade animation. Returns `0` if no animation fade is occurring.
+   */
+  get_fading_position(): float;
+  /** Returns the current travel path as computed internally by the A* algorithm. */
+  get_travel_path(): Array<string>;
+  /** Returns `true` if an animation is playing. */
+  is_playing(): boolean;
+  /**
+   * If there is a next path by travel or auto advance, immediately transitions from the current state to the next state.
+   */
+  next(): void;
+  /**
+   * Starts playing the given animation.
+   * If `reset` is `true`, the animation is played from the beginning.
+   */
+  start(node: string, reset?: boolean): void;
+  /** Stops the currently playing animation. */
+  stop(): void;
+  /**
+   * Transitions from the current state to another one, following the shortest path.
+   * If the path does not connect from the current state, the animation will play after the state teleports.
+   * If `reset_on_teleport` is `true`, the animation is played from the beginning when the travel cause a teleportation.
+   */
+  travel(to_node: string, reset_on_teleport?: boolean): void;
+
+  /**
+   * Emitted when the `state` finishes playback. If `state` is a state machine set to grouped mode, its signals are passed through with its name prefixed.
+   * If there is a crossfade, this will be fired when the influence of the {@link get_fading_from_node} animation is no longer present.
+   */
+  state_finished: Signal<[string]>;
+  /**
+   * Emitted when the `state` starts playback. If `state` is a state machine set to grouped mode, its signals are passed through with its name prefixed.
+   */
+  state_started: Signal<[string]>;
+}

package/typings/classes/AnimationNodeStateMachineTransition.d.ts

@@ -0,0 +1,83 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A transition within an {@link AnimationNodeStateMachine} connecting two {@link AnimationRootNode}s. */
+declare class AnimationNodeStateMachineTransition extends Resource {
+  /**
+   * Turn on auto advance when this condition is set. The provided name will become a boolean parameter on the {@link AnimationTree} that can be controlled from code (see Using AnimationTree ($DOCS_URL/tutorials/animation/animation_tree.html#controlling-from-code)). For example, if {@link AnimationTree.tree_root} is an {@link AnimationNodeStateMachine} and {@link advance_condition} is set to `"idle"`:
+   */
+  advance_condition: string;
+  /**
+   * Use an expression as a condition for state machine transitions. It is possible to create complex animation advance conditions for switching between states and gives much greater flexibility for creating complex state machines by directly interfacing with the script code.
+   */
+  advance_expression: string;
+  /**
+   * Determines whether the transition should be disabled, enabled when using {@link AnimationNodeStateMachinePlayback.travel}, or traversed automatically if the {@link advance_condition} and {@link advance_expression} checks are `true` (if assigned).
+   */
+  advance_mode: int;
+  /**
+   * If `true`, breaks the loop at the end of the loop cycle for transition, even if the animation is looping.
+   */
+  break_loop_at_end: boolean;
+  /**
+   * Lower priority transitions are preferred when travelling through the tree via {@link AnimationNodeStateMachinePlayback.travel} or {@link advance_mode} is set to {@link ADVANCE_MODE_AUTO}.
+   */
+  priority: int;
+  /** If `true`, the destination animation is played back from the beginning when switched. */
+  reset: boolean;
+  /** The transition type. */
+  switch_mode: int;
+  /**
+   * Ease curve for better control over cross-fade between this state and the next. Should be a unit {@link Curve}.
+   */
+  xfade_curve: Curve | null;
+  /**
+   * The time to cross-fade between this state and the next.
+   * **Note:** {@link AnimationNodeStateMachine} transitions the current state immediately after the start of the fading. The precise remaining time can only be inferred from the main animation. When {@link AnimationNodeOutput} is considered as the most upstream, so the {@link xfade_time} is not scaled depending on the downstream delta. See also {@link AnimationNodeOneShot.fadeout_time}.
+   */
+  xfade_time: float;
+  set_advance_condition(value: string): void;
+  get_advance_condition(): string;
+  set_advance_expression(value: string | NodePath): void;
+  get_advance_expression(): string;
+  set_advance_mode(value: int): void;
+  get_advance_mode(): int;
+  set_break_loop_at_end(value: boolean): void;
+  is_loop_broken_at_end(): boolean;
+  set_priority(value: int): void;
+  get_priority(): int;
+  set_reset(value: boolean): void;
+  is_reset(): boolean;
+  set_switch_mode(value: int): void;
+  get_switch_mode(): int;
+  set_xfade_curve(value: Curve | null): void;
+  get_xfade_curve(): Curve | null;
+  set_xfade_time(value: float): void;
+  get_xfade_time(): float;
+
+  /** Emitted when {@link advance_condition} is changed. */
+  advance_condition_changed: Signal<[]>;
+
+  // enum SwitchMode
+  /**
+   * Switch to the next state immediately. The current state will end and blend into the beginning of the new one.
+   */
+  static readonly SWITCH_MODE_IMMEDIATE: int;
+  /**
+   * Switch to the next state immediately, but will seek the new state to the playback position of the old state.
+   */
+  static readonly SWITCH_MODE_SYNC: int;
+  /**
+   * Wait for the current state playback to end, then switch to the beginning of the next state animation.
+   */
+  static readonly SWITCH_MODE_AT_END: int;
+  // enum AdvanceMode
+  /** Don't use this transition. */
+  static readonly ADVANCE_MODE_DISABLED: int;
+  /** Only use this transition during {@link AnimationNodeStateMachinePlayback.travel}. */
+  static readonly ADVANCE_MODE_ENABLED: int;
+  /**
+   * Automatically use this transition if the {@link advance_condition} and {@link advance_expression} checks are `true` (if assigned).
+   */
+  static readonly ADVANCE_MODE_AUTO: int;
+}

package/typings/classes/AnimationNodeSub2.d.ts

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

package/typings/classes/AnimationNodeSync.d.ts

@@ -0,0 +1,13 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for {@link AnimationNode}s with multiple input ports that must be synchronized. */
+declare class AnimationNodeSync extends AnimationNode {
+  /**
+   * 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;
+  set_use_sync(value: boolean): void;
+  is_using_sync(): boolean;
+}

package/typings/classes/AnimationNodeTimeScale.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A time-scaling animation node used in {@link AnimationTree}. */
+declare class AnimationNodeTimeScale extends AnimationNode {
+}

package/typings/classes/AnimationNodeTimeSeek.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A time-seeking animation node used in {@link AnimationTree}. */
+declare class AnimationNodeTimeSeek extends AnimationNode {
+  /**
+   * If `true`, some processes are executed to handle keys between seeks, such as calculating root motion and finding the nearest discrete key.
+   */
+  explicit_elapse: boolean;
+  set_explicit_elapse(value: boolean): void;
+  is_explicit_elapse(): boolean;
+}

package/typings/classes/AnimationNodeTransition.d.ts

@@ -0,0 +1,45 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A transition within an {@link AnimationTree} connecting two {@link AnimationNode}s. */
+declare class AnimationNodeTransition extends AnimationNodeSync {
+  /**
+   * If `true`, allows transition to the self state. When the reset option is enabled in input, the animation is restarted. If `false`, nothing happens on the transition to the self state.
+   */
+  allow_transition_to_self: boolean;
+  /** The number of enabled input ports for this animation node. */
+  input_count: int;
+  /**
+   * Determines how cross-fading between animations is eased. If empty, the transition will be linear. Should be a unit {@link Curve}.
+   */
+  xfade_curve: Curve | null;
+  /**
+   * Cross-fading time (in seconds) between each animation connected to the inputs.
+   * **Note:** {@link AnimationNodeTransition} transitions the current state immediately after the start of the fading. The precise remaining time can only be inferred from the main animation. When {@link AnimationNodeOutput} is considered as the most upstream, so the {@link xfade_time} is not scaled depending on the downstream delta. See also {@link AnimationNodeOneShot.fadeout_time}.
+   */
+  xfade_time: float;
+  set_allow_transition_to_self(value: boolean): void;
+  is_allow_transition_to_self(): boolean;
+  set_input_count(value: int): void;
+  set_xfade_curve(value: Curve | null): void;
+  get_xfade_curve(): Curve | null;
+  set_xfade_time(value: float): void;
+  get_xfade_time(): float;
+
+  /** Returns whether the animation breaks the loop at the end of the loop cycle for transition. */
+  is_input_loop_broken_at_end(input: int): boolean;
+  /** Returns whether the animation restarts when the animation transitions from the other animation. */
+  is_input_reset(input: int): boolean;
+  /** Returns `true` if auto-advance is enabled for the given `input` index. */
+  is_input_set_as_auto_advance(input: int): boolean;
+  /**
+   * Enables or disables auto-advance for the given `input` index. If enabled, state changes to the next input after playing the animation once. If enabled for the last input state, it loops to the first.
+   */
+  set_input_as_auto_advance(input: int, enable: boolean): void;
+  /**
+   * If `true`, breaks the loop at the end of the loop cycle for transition, even if the animation is looping.
+   */
+  set_input_break_loop_at_end(input: int, enable: boolean): void;
+  /** If `true`, the destination animation is restarted when the animation transitions. */
+  set_input_reset(input: int, enable: boolean): void;
+}