@ringozz/godot 0.1.0

package/gen/classes/Tween.ts

@@ -0,0 +1,604 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Callable, NodePath, Signal, Variant } from '../heap-types/index.ts';
+import type { AwaitTweener } from './AwaitTweener.ts';
+import type { CallbackTweener } from './CallbackTweener.ts';
+import type { IntervalTweener } from './IntervalTweener.ts';
+import type { MethodTweener } from './MethodTweener.ts';
+import type { Node } from './Node.ts';
+import type { Object } from './Object.ts';
+import type { PropertyTweener } from './PropertyTweener.ts';
+import type { SubtweenTweener } from './SubtweenTweener.ts';
+
+/**
+ * Tweens are mostly useful for animations requiring a numerical property to be interpolated over a range of values. The name *tween* comes from *in-betweening*, an animation technique where you specify *keyframes* and the computer interpolates the frames that appear between them. Animating something with a {@link Tween} is called tweening.
+ * {@link Tween} is more suited than {@link AnimationPlayer} for animations where you don't know the final values in advance. For example, interpolating a dynamically-chosen camera zoom value is best done with a {@link Tween}; it would be difficult to do the same thing with an {@link AnimationPlayer} node. Tweens are also more light-weight than {@link AnimationPlayer}, so they are very much suited for simple animations or general tasks that don't require visual tweaking provided by the editor. They can be used in a "fire-and-forget" manner for some logic that normally would be done by code. You can e.g. make something shoot periodically by using a looped {@link CallbackTweener} with a delay.
+ * A {@link Tween} can be created by using either {@link SceneTree.createTween} or {@link Node.createTween}. {@link Tween}s created manually (i.e. by using `Tween.new()`) are invalid and can't be used for tweening values.
+ * A tween animation is created by adding {@link Tweener}s to the {@link Tween} object, using {@link tweenProperty}, {@link tweenInterval}, {@link tweenCallback}, {@link tweenMethod}, {@link tweenSubtween}, or {@link tweenAwait}:
+ *
+ *
+ * ```gdscript
+ *
+ * var tween = get_tree().create_tween()
+ * tween.tween_property($Sprite, "modulate", Color.RED, 1.0)
+ * tween.tween_property($Sprite, "scale", Vector2(), 1.0)
+ * tween.tween_callback($Sprite.queue_free)
+ *
+ * ```
+ *
+ *
+ *
+ * This sequence will make the `$Sprite` node turn red, then shrink, before finally calling {@link Node.queueFree} to free the sprite. {@link Tweener}s are executed one after another by default. This behavior can be changed using {@link parallel} and {@link setParallel}.
+ * When a {@link Tweener} is created with one of the `tween_*` methods, a chained method call can be used to tweak the properties of this {@link Tweener}. For example, if you want to set a different transition type in the above example, you can use {@link setTrans}:
+ *
+ *
+ * ```gdscript
+ *
+ * var tween = get_tree().create_tween()
+ * tween.tween_property($Sprite, "modulate", Color.RED, 1.0).set_trans(Tween.TRANS_SINE)
+ * tween.tween_property($Sprite, "scale", Vector2(), 1.0).set_trans(Tween.TRANS_BOUNCE)
+ * tween.tween_callback($Sprite.queue_free)
+ *
+ * ```
+ *
+ *
+ *
+ * Most of the {@link Tween} methods can be chained this way too. In the following example the {@link Tween} is bound to the running script's node and a default transition is set for its {@link Tweener}s:
+ *
+ *
+ * ```gdscript
+ *
+ * var tween = get_tree().create_tween().bind_node(self).set_trans(Tween.TRANS_ELASTIC)
+ * tween.tween_property($Sprite, "modulate", Color.RED, 1.0)
+ * tween.tween_property($Sprite, "scale", Vector2(), 1.0)
+ * tween.tween_callback($Sprite.queue_free)
+ *
+ * ```
+ *
+ *
+ *
+ * Another interesting use for {@link Tween}s is animating arbitrary sets of objects:
+ *
+ *
+ * ```gdscript
+ *
+ * var tween = create_tween()
+ * for sprite in get_children():
+ * 	tween.tween_property(sprite, "position", Vector2(0, 0), 1.0)
+ *
+ * ```
+ *
+ *
+ *
+ * In the example above, all children of a node are moved one after another to position `(0, 0)`.
+ * You should avoid using more than one {@link Tween} per object's property. If two or more tweens animate one property at the same time, the last one created will take priority and assign the final value. If you want to interrupt and restart an animation, consider assigning the {@link Tween} to a variable:
+ *
+ *
+ * ```gdscript
+ *
+ * var tween
+ * func animate():
+ * 	if tween:
+ * 		tween.kill() # Abort the previous animation.
+ * 	tween = create_tween()
+ *
+ * ```
+ *
+ *
+ *
+ * Some {@link Tweener}s use transitions and eases. The first accepts a {@link TransitionType} constant, and refers to the way the timing of the animation is handled (see [easings.net](https://easings.net/) for some examples). The second accepts an {@link EaseType} constant, and controls where the `trans_type` is applied to the interpolation (in the beginning, the end, or both). If you don't know which transition and easing to pick, you can try different {@link TransitionType} constants with {@link EASE_IN_OUT}, and use the one that looks best.
+ * [Tween easing and transition types cheatsheet](https://raw.githubusercontent.com/godotengine/godot-docs/master/img/tween_cheatsheet.webp)
+ * **Note:** Tweens are not designed to be reused and trying to do so results in an undefined behavior. Create a new Tween for each animation and every time you replay an animation from start. Keep in mind that Tweens start immediately, so only create a Tween when you want to start animating.
+ * **Note:** The tween is processed after all of the nodes in the current frame, i.e. node's {@link Node.Process} method would be called before the tween (or {@link Node.PhysicsProcess} depending on the value passed to {@link setProcessMode}).
+ */
+export class Tween extends RefCounted {
+    constructor(name = 812) { super(name); }
+
+    /**
+     * Creates and appends a {@link PropertyTweener}. This method tweens a `property` of an `object` between an initial value and `finalVal` in a span of time equal to `duration`, in seconds. The initial value by default is the property's value at the time the tweening of the {@link PropertyTweener} starts.
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = create_tween()
+     * tween.tween_property($Sprite, "position", Vector2(100, 200), 1.0)
+     * tween.tween_property($Sprite, "position", Vector2(200, 300), 1.0)
+     *
+     * ```
+     *
+     *
+     *
+     * will move the sprite to position (100, 200) and then to (200, 300). If you use {@link PropertyTweener.from} or {@link PropertyTweener.fromCurrent}, the starting position will be overwritten by the given value instead. See other methods in {@link PropertyTweener} to see how the tweening can be tweaked further.
+     * **Note:** You can find the correct property name by hovering over the property in the Inspector. You can also provide the components of a property directly by using `"property:component"` (eg. `position:x`), where it would only apply to that particular component.
+     * **Example:** Moving an object twice from the same position, with different transition types:
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = create_tween()
+     * tween.tween_property($Sprite, "position", Vector2.RIGHT * 300, 1.0).as_relative().set_trans(Tween.TRANS_SINE)
+     * tween.tween_property($Sprite, "position", Vector2.RIGHT * 300, 1.0).as_relative().from_current().set_trans(Tween.TRANS_EXPO)
+     *
+     * ```
+     */
+    tweenProperty(object: Object, property: NodePath, finalVal: Variant, duration: number /* double */): PropertyTweener { return _C(this, 14450, object, property, finalVal, duration) as PropertyTweener; }
+
+    /**
+     * Creates and appends an {@link IntervalTweener}. This method can be used to create delays in the tween animation, as an alternative to using the delay in other {@link Tweener}s, or when there's no animation (in which case the {@link Tween} acts as a timer). `time` is the length of the interval, in seconds.
+     * **Example:** Creating an interval in code execution:
+     *
+     *
+     * ```gdscript
+     *
+     * # ... some code
+     * await create_tween().tween_interval(2).finished
+     * # ... more code
+     *
+     * ```
+     *
+     *
+     *
+     * **Example:** Creating an object that moves back and forth and jumps every few seconds:
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = create_tween().set_loops()
+     * tween.tween_property($Sprite, "position:x", 200.0, 1.0).as_relative()
+     * tween.tween_callback(jump)
+     * tween.tween_interval(2)
+     * tween.tween_property($Sprite, "position:x", -200.0, 1.0).as_relative()
+     * tween.tween_callback(jump)
+     * tween.tween_interval(2)
+     *
+     * ```
+     */
+    tweenInterval(time: number /* double */): IntervalTweener { return _C(this, 14448, time) as IntervalTweener; }
+
+    /**
+     * Creates and appends a {@link CallbackTweener}. This method can be used to call an arbitrary method in any object. Use {@link Callable.bind} to bind additional arguments for the call.
+     * **Example:** Object that keeps shooting every 1 second:
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = get_tree().create_tween().set_loops()
+     * tween.tween_callback(shoot).set_delay(1.0)
+     *
+     * ```
+     *
+     *
+     *
+     * **Example:** Turning a sprite red and then blue, with 2 second delay:
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = get_tree().create_tween()
+     * tween.tween_callback($Sprite.set_modulate.bind(Color.RED)).set_delay(2)
+     * tween.tween_callback($Sprite.set_modulate.bind(Color.BLUE)).set_delay(2)
+     *
+     * ```
+     */
+    tweenCallback(callback: Callable): CallbackTweener { return _C(this, 14447, callback) as CallbackTweener; }
+
+    /**
+     * Creates and appends a {@link MethodTweener}. This method is similar to a combination of {@link tweenCallback} and {@link tweenProperty}. It calls a method over time with a tweened value provided as an argument. The value is tweened between `from` and `to` over the time specified by `duration`, in seconds. Use {@link Callable.bind} to bind additional arguments for the call. You can use {@link MethodTweener.setEase} and {@link MethodTweener.setTrans} to tweak the easing and transition of the value or {@link MethodTweener.setDelay} to delay the tweening.
+     * **Example:** Making a 3D object look from one point to another point:
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = create_tween()
+     * tween.tween_method(look_at.bind(Vector3.UP), Vector3(-1, 0, -1), Vector3(1, 0, -1), 1.0) # The look_at() method takes up vector as second argument.
+     *
+     * ```
+     *
+     *
+     *
+     * **Example:** Setting the text of a {@link Label}, using an intermediate method and after a delay:
+     *
+     *
+     * ```gdscript
+     *
+     * func _ready():
+     * 	var tween = create_tween()
+     * 	tween.tween_method(set_label_text, 0, 10, 1.0).set_delay(1.0)
+     *
+     * func set_label_text(value: int):
+     * 	$Label.text = "Counting " + str(value)
+     *
+     * ```
+     */
+    tweenMethod(method: Callable, from: Variant, to: Variant, duration: number /* double */): MethodTweener { return _C(this, 14449, method, from, to, duration) as MethodTweener; }
+
+    /**
+     * Creates and appends a {@link SubtweenTweener}. This method can be used to nest `subtween` within this {@link Tween}, allowing for the creation of more complex and composable sequences.
+     *
+     * ```text
+     *
+     * # Subtween will rotate the object.
+     * var subtween = create_tween()
+     * subtween.tween_property(self, "rotation_degrees", 45.0, 1.0)
+     * subtween.tween_property(self, "rotation_degrees", 0.0, 1.0)
+     *
+     * # Parent tween will execute the subtween as one of its steps.
+     * var tween = create_tween()
+     * tween.tween_property(self, "position:x", 500, 3.0)
+     * tween.tween_subtween(subtween)
+     * tween.tween_property(self, "position:x", 300, 2.0)
+     *
+     * ```
+     *
+     * **Note:** The methods {@link pause}, {@link stop}, and {@link setLoops} can cause the parent {@link Tween} to get stuck on the subtween step; see the documentation for those methods for more information.
+     * **Note:** The pause and process modes set by {@link setPauseMode} and {@link setProcessMode} on `subtween` will be overridden by the parent {@link Tween}'s settings.
+     */
+    tweenSubtween(subtween: Tween): SubtweenTweener { return _C(this, 14451, subtween) as SubtweenTweener; }
+
+    /**
+     * Creates and appends an {@link AwaitTweener}. This method can be used to await a signal to be emitted and create asynchronous animations or cutscenes.
+     * The animation will not progress to the next step until the awaited signal is emitted or the connection becomes invalid (e.g. as a result of freeing the target object). If you know that the emission may not happen, use {@link AwaitTweener.setTimeout}.
+     * **Note:** The awaited signal should be emitted during the step when {@link AwaitTweener} is active.
+     * **Example:** An object launches itself and explodes upon collision or after 4 seconds.
+     *
+     * ```text
+     *
+     * var tween = create_tween()
+     * tween.tween_callback(launch)
+     * tween.tween_await(collided).set_timeout(4.0)
+     * tween.tween_callback(explode)
+     *
+     * ```
+     *
+     * **Example:** A character walks to a specific point, says some lines and walks back when the player closes the message box.
+     *
+     * ```text
+     *
+     * var tween = create_tween()
+     * tween.tween_callback(walk_to.bind(600.0))
+     * tween.tween_await(destination_reached)
+     * tween.tween_callback(say_dialogue.bind("Good day, sir!"))
+     * tween.tween_await(dialogue_closed)
+     * tween.tween_callback(walk_to.bind(0.0))
+     *
+     * ```
+     *
+     * **Note:** If you are awaiting a signal from a callback called in the same {@link Tween}, make sure the signal is emitted *after* the await starts. If it can't be reasonably guaranteed, you can await and emit in the same step:
+     *
+     * ```text
+     *
+     * var tween = create_tween()
+     * tween.tween_await(signal)
+     * tween.parallel().tween_callback(method_that_emits_signal)
+     *
+     * ```
+     */
+    tweenAwait(signal: Signal): AwaitTweener { return _C(this, 14446, signal) as AwaitTweener; }
+
+    /**
+     * Processes the {@link Tween} by the given `delta` value, in seconds. This is mostly useful for manual control when the {@link Tween} is paused. It can also be used to end the {@link Tween} animation immediately, by setting `delta` longer than the whole duration of the {@link Tween} animation.
+     * Returns `true` if the {@link Tween} still has {@link Tweener}s that haven't finished.
+     */
+    customStep(delta: number /* double */): boolean { return _C(this, 2633, delta) as boolean; }
+
+    /**
+     * Stops the tweening and resets the {@link Tween} to its initial state. This will not remove any appended {@link Tweener}s.
+     * **Note:** This does *not* reset targets of {@link PropertyTweener}s to their values when the {@link Tween} first started.
+     *
+     * ```text
+     *
+     * var tween = create_tween()
+     *
+     * # Will move from 0 to 500 over 1 second.
+     * position.x = 0.0
+     * tween.tween_property(self, "position:x", 500, 1.0)
+     *
+     * # Will be at (about) 250 when the timer finishes.
+     * await get_tree().create_timer(0.5).timeout
+     *
+     * # Will now move from (about) 250 to 500 over 1 second,
+     * # thus at half the speed as before.
+     * tween.stop()
+     * tween.play()
+     *
+     * ```
+     *
+     * **Note:** If a Tween is stopped and not bound to any node, it will exist indefinitely until manually started or invalidated. If you lose a reference to such Tween, you can retrieve it using {@link SceneTree.getProcessedTweens}.
+     */
+    stop(): void { _C(this, 13866); }
+
+    /**
+     * Pauses the tweening. The animation can be resumed by using {@link play}.
+     * **Note:** If a Tween is paused and not bound to any node, it will exist indefinitely until manually started or invalidated. If you lose a reference to such Tween, you can retrieve it using {@link SceneTree.getProcessedTweens}.
+     */
+    pause(): void { _C(this, 9383); }
+
+    /**
+     * Resumes a paused or stopped {@link Tween}.
+     */
+    play(): void { _C(this, 9447); }
+
+    /**
+     * Aborts all tweening operations and invalidates the {@link Tween}.
+     */
+    kill(): void { _C(this, 8532); }
+
+    /**
+     * Returns the total time in seconds the {@link Tween} has been animating (i.e. the time since it started, not counting pauses etc.). The time is affected by {@link setSpeedScale}, and {@link stop} will reset it to `0`.
+     * **Note:** As it results from accumulating frame deltas, the time returned after the {@link Tween} has finished animating will be slightly greater than the actual {@link Tween} duration.
+     */
+    getTotalElapsedTime(): number { return _C(this, 6851) as number; }
+
+    /**
+     * Returns `true` if any {@link Tweener} has been added to the {@link Tween} and the {@link Tween} is valid. Useful when tweeners are added dynamically and the tween can end up empty. Killing an empty tween before it starts will prevent errors.
+     */
+    hasTweeners(): boolean { return _C(this, 7478) as boolean; }
+
+    /**
+     * Returns whether the {@link Tween} is currently running, i.e. it wasn't paused and it's not finished.
+     */
+    isRunning(): boolean { return _C(this, 8258) as boolean; }
+
+    /**
+     * Returns whether the {@link Tween} is valid. A valid {@link Tween} is a {@link Tween} contained by the scene tree (i.e. the array from {@link SceneTree.getProcessedTweens} will contain this {@link Tween}). A {@link Tween} might become invalid when it has finished tweening, is killed, or when created with `Tween.new()`. Invalid {@link Tween}s can't have {@link Tweener}s appended.
+     */
+    isValid(): boolean { return _C(this, 8432) as boolean; }
+
+    /**
+     * Binds this {@link Tween} with the given `node`. {@link Tween}s are processed directly by the {@link SceneTree}, so they run independently of the animated nodes. When you bind a {@link Node} with the {@link Tween}, the {@link Tween} will halt the animation when the object is not inside tree and the {@link Tween} will be automatically killed when the bound object is freed. Also {@link TWEEN_PAUSE_BOUND} will make the pausing behavior dependent on the bound node.
+     * For a shorter way to create and bind a {@link Tween}, you can use {@link Node.createTween}.
+     */
+    bindNode(node: Node): Tween { return _C(this, 1777, node) as Tween; }
+
+    /**
+     * Determines whether the {@link Tween} should run after process frames (see {@link Node.Process}) or physics frames (see {@link Node.PhysicsProcess}).
+     * Default value is {@link TWEEN_PROCESS_IDLE}.
+     */
+    setProcessMode(mode: TweenProcessMode): Tween { return _C(this, 12427, mode) as Tween; }
+
+    /**
+     * Determines the behavior of the {@link Tween} when the {@link SceneTree} is paused.
+     * Default value is {@link TWEEN_PAUSE_BOUND}.
+     */
+    setPauseMode(mode: TweenPauseMode): Tween { return _C(this, 12301, mode) as Tween; }
+
+    /**
+     * If `ignore` is `true`, the tween will ignore {@link Engine.timeScale} and update with the real, elapsed time. This affects all {@link Tweener}s and their delays. Default value is `false`.
+     */
+    setIgnoreTimeScale(ignore?: boolean /* = true */): Tween { return _C(this, 11668, ignore) as Tween; }
+
+    /**
+     * If `parallel` is `true`, the {@link Tweener}s appended after this method will by default run simultaneously, as opposed to sequentially.
+     * **Note:** Just like with {@link parallel}, the tweener added right before this method will also be part of the parallel step.
+     *
+     * ```text
+     *
+     * tween.tween_property(self, "position", Vector2(300, 0), 0.5)
+     * tween.set_parallel()
+     * tween.tween_property(self, "modulate", Color.GREEN, 0.5) # Runs together with the position tweener.
+     *
+     * ```
+     */
+    setParallel(parallel?: boolean /* = true */): Tween { return _C(this, 12247, parallel) as Tween; }
+
+    /**
+     * Sets the number of times the tweening sequence will be repeated, i.e. `set_loops(2)` will run the animation twice.
+     * Calling this method without arguments will make the {@link Tween} run infinitely, until either it is killed with {@link kill}, the {@link Tween}'s bound node is freed, or all the animated objects have been freed (which makes further animation impossible).
+     * **Warning:** Make sure to always add some duration/delay when using infinite loops. To prevent the game freezing, 0-duration looped animations (e.g. a single {@link CallbackTweener} with no delay) are stopped after a small number of loops, which may produce unexpected results. If a {@link Tween}'s lifetime depends on some node, always use {@link bindNode}.
+     */
+    setLoops(loops?: number /* = 0 */): Tween { return _C(this, 11954, loops) as Tween; }
+
+    /**
+     * Returns the number of remaining loops for this {@link Tween} (see {@link setLoops}). A return value of `-1` indicates an infinitely looping {@link Tween}, and a return value of `0` indicates that the {@link Tween} has already finished.
+     */
+    getLoopsLeft(): number { return _C(this, 5422) as number; }
+
+    /**
+     * Scales the speed of tweening. This affects all {@link Tweener}s and their delays.
+     */
+    setSpeedScale(speed: number): Tween { return _C(this, 12839, speed) as Tween; }
+
+    /**
+     * Sets the default transition type for {@link PropertyTweener}s and {@link MethodTweener}s appended after this method.
+     * Before this method is called, the default transition type is {@link TRANS_LINEAR}.
+     *
+     * ```text
+     *
+     * var tween = create_tween()
+     * tween.tween_property(self, "position", Vector2(300, 0), 0.5) # Uses TRANS_LINEAR.
+     * tween.set_trans(Tween.TRANS_SINE)
+     * tween.tween_property(self, "rotation_degrees", 45.0, 0.5) # Uses TRANS_SINE.
+     *
+     * ```
+     */
+    setTrans(trans: TransitionType): Tween { return _C(this, 13131, trans) as Tween; }
+
+    /**
+     * Sets the default ease type for {@link PropertyTweener}s and {@link MethodTweener}s appended after this method.
+     * Before this method is called, the default ease type is {@link EASE_IN_OUT}.
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = create_tween()
+     * tween.tween_property(self, "position", Vector2(300, 0), 0.5) # Uses EASE_IN_OUT.
+     * tween.set_ease(Tween.EASE_IN)
+     * tween.tween_property(self, "rotation_degrees", 45.0, 0.5) # Uses EASE_IN.
+     *
+     * ```
+     */
+    setEase(ease: EaseType): Tween { return _C(this, 11206, ease) as Tween; }
+
+    /**
+     * Makes the next {@link Tweener} run parallelly to the previous one.
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = create_tween()
+     * tween.tween_property(...)
+     * tween.parallel().tween_property(...)
+     * tween.parallel().tween_property(...)
+     *
+     * ```
+     *
+     *
+     *
+     * All {@link Tweener}s in the example will run at the same time.
+     * You can make the {@link Tween} parallel by default by using {@link setParallel}.
+     */
+    parallel(): Tween { return _C(this, 9271) as Tween; }
+
+    /**
+     * Used to chain two {@link Tweener}s after {@link setParallel} is called with `true`.
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = create_tween().set_parallel(true)
+     * tween.tween_property(...)
+     * tween.tween_property(...) # Will run parallelly with above.
+     * tween.chain().tween_property(...) # Will run after two above are finished.
+     *
+     * ```
+     */
+    chain(): Tween { return _C(this, 2184) as Tween; }
+
+    /**
+     * This method can be used for manual interpolation of a value, when you don't want {@link Tween} to do animating for you. It's similar to {@link lerp}, but with support for custom transition and easing.
+     * `initialValue` is the starting value of the interpolation.
+     * `deltaValue` is the change of the value in the interpolation, i.e. it's equal to `final_value - initial_value`.
+     * `elapsedTime` is the time in seconds that passed after the interpolation started and it's used to control the position of the interpolation. E.g. when it's equal to half of the `duration`, the interpolated value will be halfway between initial and final values. This value can also be greater than `duration` or lower than 0, which will extrapolate the value.
+     * `duration` is the total time of the interpolation.
+     * **Note:** If `duration` is equal to `0`, the method will always return the final value, regardless of `elapsedTime` provided.
+     */
+    static interpolateValue(initialValue: Variant, deltaValue: Variant, elapsedTime: number /* double */, duration: number /* double */, transType: TransitionType, easeType: EaseType): Variant { return _C(812, 7693, initialValue, deltaValue, elapsedTime, duration, transType, easeType) as Variant; }
+
+    /**
+     * Emitted when one step of the {@link Tween} is complete, providing the step index. One step is either a single {@link Tweener} or a group of {@link Tweener}s running in parallel.
+     */
+    get stepFinished(): Signal<(idx: number) => void> { return _G(this, 13863) as Signal<(idx: number) => void>; }
+    set stepFinished(v: ((idx: number) => void) | null) { _G(this, 13863, v); }
+
+    /**
+     * Emitted when a full loop is complete (see {@link setLoops}), providing the loop index. This signal is not emitted after the final loop, use {@link finished} instead for this case.
+     */
+    get loopFinished(): Signal<(loopCount: number) => void> { return _G(this, 8712) as Signal<(loopCount: number) => void>; }
+    set loopFinished(v: ((loopCount: number) => void) | null) { _G(this, 8712, v); }
+
+    /**
+     * Emitted when the {@link Tween} has finished all tweening. Never emitted when the {@link Tween} is set to infinite looping (see {@link setLoops}).
+     */
+    get finished(): Signal<() => void> { return _G(this, 3310) as Signal<() => void>; }
+    set finished(v: (() => void) | null) { _G(this, 3310, v); }
+
+    static readonly name = _R(812, Tween);
+}
+
+export const TweenProcessMode = {
+    /**
+     * The {@link Tween} updates after each physics frame (see {@link Node.PhysicsProcess}).
+     */
+    TWEEN_PROCESS_PHYSICS: 0,
+    /**
+     * The {@link Tween} updates after each process frame (see {@link Node.Process}).
+     */
+    TWEEN_PROCESS_IDLE: 1,
+} as const;
+
+export type TweenProcessMode = (typeof TweenProcessMode)[keyof typeof TweenProcessMode];
+
+export const TweenPauseMode = {
+    /**
+     * If the {@link Tween} has a bound node, it will process when that node can process (see {@link Node.processMode}). Otherwise it's the same as {@link TWEEN_PAUSE_STOP}.
+     */
+    TWEEN_PAUSE_BOUND: 0,
+    /**
+     * If {@link SceneTree} is paused, the {@link Tween} will also pause.
+     */
+    TWEEN_PAUSE_STOP: 1,
+    /**
+     * The {@link Tween} will process regardless of whether {@link SceneTree} is paused.
+     */
+    TWEEN_PAUSE_PROCESS: 2,
+} as const;
+
+export type TweenPauseMode = (typeof TweenPauseMode)[keyof typeof TweenPauseMode];
+
+export const TransitionType = {
+    /**
+     * The animation is interpolated linearly.
+     */
+    TRANS_LINEAR: 0,
+    /**
+     * The animation is interpolated using a sine function.
+     */
+    TRANS_SINE: 1,
+    /**
+     * The animation is interpolated with a quintic (to the power of 5) function.
+     */
+    TRANS_QUINT: 2,
+    /**
+     * The animation is interpolated with a quartic (to the power of 4) function.
+     */
+    TRANS_QUART: 3,
+    /**
+     * The animation is interpolated with a quadratic (to the power of 2) function.
+     */
+    TRANS_QUAD: 4,
+    /**
+     * The animation is interpolated with an exponential (to the power of x) function.
+     */
+    TRANS_EXPO: 5,
+    /**
+     * The animation is interpolated with elasticity, wiggling around the edges.
+     */
+    TRANS_ELASTIC: 6,
+    /**
+     * The animation is interpolated with a cubic (to the power of 3) function.
+     */
+    TRANS_CUBIC: 7,
+    /**
+     * The animation is interpolated with a function using square roots.
+     */
+    TRANS_CIRC: 8,
+    /**
+     * The animation is interpolated by bouncing at the end.
+     */
+    TRANS_BOUNCE: 9,
+    /**
+     * The animation is interpolated backing out at ends.
+     */
+    TRANS_BACK: 10,
+    /**
+     * The animation is interpolated like a spring towards the end.
+     */
+    TRANS_SPRING: 11,
+} as const;
+
+export type TransitionType = (typeof TransitionType)[keyof typeof TransitionType];
+
+export const EaseType = {
+    /**
+     * The interpolation starts slowly and speeds up towards the end.
+     */
+    EASE_IN: 0,
+    /**
+     * The interpolation starts quickly and slows down towards the end.
+     */
+    EASE_OUT: 1,
+    /**
+     * A combination of {@link EASE_IN} and {@link EASE_OUT}. The interpolation is slowest at both ends.
+     */
+    EASE_IN_OUT: 2,
+    /**
+     * A combination of {@link EASE_IN} and {@link EASE_OUT}. The interpolation is fastest at both ends.
+     */
+    EASE_OUT_IN: 3,
+} as const;
+
+export type EaseType = (typeof EaseType)[keyof typeof EaseType];
+

package/gen/classes/Tweener.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Signal } from '../heap-types/index.ts';
+
+/**
+ * Tweeners are objects that perform a specific animating task, e.g. interpolating a property or calling a method at a given time. A {@link Tweener} can't be created manually, you need to use a dedicated method from {@link Tween}.
+ */
+export class Tweener extends RefCounted {
+
+    /**
+     * Emitted when the {@link Tweener} has just finished its job or became invalid (e.g. due to a freed object).
+     */
+    get finished(): Signal<() => void> { return _G(this, 3310) as Signal<() => void>; }
+    set finished(v: (() => void) | null) { _G(this, 3310, v); }
+
+    static readonly name = _R(813, Tweener);
+}