@ringozz/godot 0.1.0

package/gen/classes/Animation.ts

@@ -0,0 +1,596 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, NodePath, PackedStringArray, StringName, Variant } from '../heap-types/index.ts';
+import type { Color, Quaternion, Vector2, Vector3 } from '../value-types/index.ts';
+
+/**
+ * This resource holds data that can be used to animate anything in the engine. Animations are divided into tracks and each track must be linked to a node. The state of that node can be changed through time, by adding timed keys (events) to the track.
+ *
+ *
+ * ```gdscript
+ *
+ * # This creates an animation that makes the node "Enemy" move to the right by
+ * # 100 pixels in 2.0 seconds.
+ * var animation = Animation.new()
+ * var track_index = animation.add_track(Animation.TYPE_VALUE)
+ * animation.track_set_path(track_index, "Enemy:position:x")
+ * animation.track_insert_key(track_index, 0.0, 0)
+ * animation.track_insert_key(track_index, 2.0, 100)
+ * animation.length = 2.0
+ *
+ * ```
+ *
+ *
+ *
+ * Animations are just data containers, and must be added to nodes such as an {@link AnimationPlayer} to be played back. Animation tracks have different types, each with its own set of dedicated methods. Check {@link TrackType} to see available types.
+ * **Note:** For 3D position/rotation/scale, using the dedicated {@link TYPE_POSITION_3D}, {@link TYPE_ROTATION_3D} and {@link TYPE_SCALE_3D} track types instead of {@link TYPE_VALUE} is recommended for performance reasons.
+ */
+export class Animation extends Resource {
+    constructor(name = 53) { super(name); }
+
+    /**
+     * Adds a track to the Animation.
+     */
+    addTrack(type: TrackType, atPosition?: number /* = -1 */): number { return _C(this, 1316, type, atPosition) as number; }
+
+    /**
+     * Removes a track by specifying the track index.
+     */
+    removeTrack(trackIdx: number): void { _C(this, 9978, trackIdx); }
+
+    /**
+     * Returns the amount of tracks in the animation.
+     */
+    getTrackCount(): number { return _C(this, 6857) as number; }
+
+    /**
+     * Gets the type of a track.
+     */
+    trackGetType(trackIdx: number): TrackType { return _C(this, 14353, trackIdx) as TrackType; }
+
+    /**
+     * Gets the path of a track. For more information on the path format, see {@link trackSetPath}.
+     */
+    trackGetPath(trackIdx: number): NodePath { return _C(this, 14352, trackIdx) as NodePath; }
+
+    /**
+     * Sets the path of a track. Paths must be valid scene-tree paths to a node and must be specified starting from the {@link AnimationMixer.rootNode} that will reproduce the animation. Tracks that control properties or bones must append their name after the path, separated by `":"`.
+     * For example, `"character/skeleton:ankle"` or `"character/mesh:transform/local"`.
+     */
+    trackSetPath(trackIdx: number, path: NodePath): void { _C(this, 14370, trackIdx, path); }
+
+    /**
+     * Returns the index of the specified track. If the track is not found, return -1.
+     */
+    findTrack(path: NodePath, type: TrackType): number { return _C(this, 3302, path, type) as number; }
+
+    /**
+     * Moves a track up.
+     */
+    trackMoveUp(trackIdx: number): void { _C(this, 14360, trackIdx); }
+
+    /**
+     * Moves a track down.
+     */
+    trackMoveDown(trackIdx: number): void { _C(this, 14358, trackIdx); }
+
+    /**
+     * Changes the index position of track `trackIdx` to the one defined in `toIdx`.
+     */
+    trackMoveTo(trackIdx: number, toIdx: number): void { _C(this, 14359, trackIdx, toIdx); }
+
+    /**
+     * Swaps the track `trackIdx`'s index position with the track `withIdx`.
+     */
+    trackSwap(trackIdx: number, withIdx: number): void { _C(this, 14371, trackIdx, withIdx); }
+
+    /**
+     * Sets the given track as imported or not.
+     */
+    trackSetImported(trackIdx: number, imported: boolean): void { _C(this, 14364, trackIdx, imported); }
+
+    /**
+     * Returns `true` if the given track is imported. Else, return `false`.
+     */
+    trackIsImported(trackIdx: number): boolean { return _C(this, 14357, trackIdx) as boolean; }
+
+    /**
+     * Enables/disables the given track. Tracks are enabled by default.
+     */
+    trackSetEnabled(trackIdx: number, enabled: boolean): void { _C(this, 14363, trackIdx, enabled); }
+
+    /**
+     * Returns `true` if the track at index `trackIdx` is enabled.
+     */
+    trackIsEnabled(trackIdx: number): boolean { return _C(this, 14356, trackIdx) as boolean; }
+
+    /**
+     * Inserts a key in a given 3D position track. Returns the key index.
+     */
+    positionTrackInsertKey(trackIdx: number, time: number /* double */, position: Vector3): number { return _C(this, 9509, trackIdx, time, position) as number; }
+
+    /**
+     * Inserts a key in a given 3D rotation track. Returns the key index.
+     */
+    rotationTrackInsertKey(trackIdx: number, time: number /* double */, rotation: Quaternion): number { return _C(this, 10157, trackIdx, time, rotation) as number; }
+
+    /**
+     * Inserts a key in a given 3D scale track. Returns the key index.
+     */
+    scaleTrackInsertKey(trackIdx: number, time: number /* double */, scale: Vector3): number { return _C(this, 10230, trackIdx, time, scale) as number; }
+
+    /**
+     * Inserts a key in a given blend shape track. Returns the key index.
+     */
+    blendShapeTrackInsertKey(trackIdx: number, time: number /* double */, amount: number): number { return _C(this, 1797, trackIdx, time, amount) as number; }
+
+    /**
+     * Returns the interpolated position value at the given time (in seconds). The `trackIdx` must be the index of a 3D position track.
+     */
+    positionTrackInterpolate(trackIdx: number, timeSec: number /* double */, backward?: boolean /* = false */): Vector3 { return _C(this, 9510, trackIdx, timeSec, backward) as Vector3; }
+
+    /**
+     * Returns the interpolated rotation value at the given time (in seconds). The `trackIdx` must be the index of a 3D rotation track.
+     */
+    rotationTrackInterpolate(trackIdx: number, timeSec: number /* double */, backward?: boolean /* = false */): Quaternion { return _C(this, 10158, trackIdx, timeSec, backward) as Quaternion; }
+
+    /**
+     * Returns the interpolated scale value at the given time (in seconds). The `trackIdx` must be the index of a 3D scale track.
+     */
+    scaleTrackInterpolate(trackIdx: number, timeSec: number /* double */, backward?: boolean /* = false */): Vector3 { return _C(this, 10231, trackIdx, timeSec, backward) as Vector3; }
+
+    /**
+     * Returns the interpolated blend shape value at the given time (in seconds). The `trackIdx` must be the index of a blend shape track.
+     */
+    blendShapeTrackInterpolate(trackIdx: number, timeSec: number /* double */, backward?: boolean /* = false */): number { return _C(this, 1798, trackIdx, timeSec, backward) as number; }
+
+    /**
+     * Inserts a generic key in a given track. Returns the key index.
+     */
+    trackInsertKey(trackIdx: number, time: number /* double */, key: Variant, transition?: number /* = 1 */): number { return _C(this, 14354, trackIdx, time, key, transition) as number; }
+
+    /**
+     * Removes a key by index in a given track.
+     */
+    trackRemoveKey(trackIdx: number, keyIdx: number): void { _C(this, 14361, trackIdx, keyIdx); }
+
+    /**
+     * Removes a key at `time` in a given track.
+     */
+    trackRemoveKeyAtTime(trackIdx: number, time: number /* double */): void { _C(this, 14362, trackIdx, time); }
+
+    /**
+     * Sets the value of an existing key.
+     */
+    trackSetKeyValue(trackIdx: number, key: number, value: Variant): void { _C(this, 14369, trackIdx, key, value); }
+
+    /**
+     * Sets the transition curve (easing) for a specific key (see the built-in math function {@link ease}).
+     */
+    trackSetKeyTransition(trackIdx: number, keyIdx: number, transition: number): void { _C(this, 14368, trackIdx, keyIdx, transition); }
+
+    /**
+     * Sets the time of an existing key.
+     */
+    trackSetKeyTime(trackIdx: number, keyIdx: number, time: number /* double */): void { _C(this, 14367, trackIdx, keyIdx, time); }
+
+    /**
+     * Returns the transition curve (easing) for a specific key (see the built-in math function {@link ease}).
+     */
+    trackGetKeyTransition(trackIdx: number, keyIdx: number): number { return _C(this, 14350, trackIdx, keyIdx) as number; }
+
+    /**
+     * Returns the number of keys in a given track.
+     */
+    trackGetKeyCount(trackIdx: number): number { return _C(this, 14348, trackIdx) as number; }
+
+    /**
+     * Returns the value of a given key in a given track.
+     */
+    trackGetKeyValue(trackIdx: number, keyIdx: number): Variant { return _C(this, 14351, trackIdx, keyIdx) as Variant; }
+
+    /**
+     * Returns the time at which the key is located.
+     */
+    trackGetKeyTime(trackIdx: number, keyIdx: number): number { return _C(this, 14349, trackIdx, keyIdx) as number; }
+
+    /**
+     * Finds the key index by time in a given track. Optionally, only find it if the approx/exact time is given.
+     * If `limit` is `true`, it does not return keys outside the animation range.
+     * If `backward` is `true`, the direction is reversed in methods that rely on one directional processing.
+     * For example, in case `findMode` is {@link FIND_MODE_NEAREST}, if there is no key in the current position just after seeked, the first key found is retrieved by searching before the position, but if `backward` is `true`, the first key found is retrieved after the position.
+     */
+    trackFindKey(trackIdx: number, time: number /* double */, findMode?: FindMode /* = 0 */, limit?: boolean /* = false */, backward?: boolean /* = false */): number { return _C(this, 14345, trackIdx, time, findMode, limit, backward) as number; }
+
+    /**
+     * Sets the interpolation type of a given track.
+     */
+    trackSetInterpolationType(trackIdx: number, interpolation: InterpolationType): void { _C(this, 14366, trackIdx, interpolation); }
+
+    /**
+     * Returns the interpolation type of a given track.
+     */
+    trackGetInterpolationType(trackIdx: number): InterpolationType { return _C(this, 14347, trackIdx) as InterpolationType; }
+
+    /**
+     * If `true`, the track at `trackIdx` wraps the interpolation loop.
+     */
+    trackSetInterpolationLoopWrap(trackIdx: number, interpolation: boolean): void { _C(this, 14365, trackIdx, interpolation); }
+
+    /**
+     * Returns `true` if the track at `trackIdx` wraps the interpolation loop. New tracks wrap the interpolation loop by default.
+     */
+    trackGetInterpolationLoopWrap(trackIdx: number): boolean { return _C(this, 14346, trackIdx) as boolean; }
+
+    /**
+     * Returns `true` if the track is compressed, `false` otherwise. See also {@link compress}.
+     */
+    trackIsCompressed(trackIdx: number): boolean { return _C(this, 14355, trackIdx) as boolean; }
+
+    /**
+     * Sets the update mode of a value track.
+     */
+    valueTrackSetUpdateMode(trackIdx: number, mode: UpdateMode): void { _C(this, 14671, trackIdx, mode); }
+
+    /**
+     * Returns the update mode of a value track.
+     */
+    valueTrackGetUpdateMode(trackIdx: number): UpdateMode { return _C(this, 14669, trackIdx) as UpdateMode; }
+
+    /**
+     * Returns the interpolated value at the given time (in seconds). The `trackIdx` must be the index of a value track.
+     * A `backward` mainly affects the direction of key retrieval of the track with {@link UPDATE_DISCRETE} converted by {@link AnimationMixer.ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS} to match the result with {@link trackFindKey}.
+     */
+    valueTrackInterpolate(trackIdx: number, timeSec: number /* double */, backward?: boolean /* = false */): Variant { return _C(this, 14670, trackIdx, timeSec, backward) as Variant; }
+
+    /**
+     * Returns the method name of a method track.
+     */
+    methodTrackGetName(trackIdx: number, keyIdx: number): StringName { return _C(this, 8903, trackIdx, keyIdx) as StringName; }
+
+    /**
+     * Returns the arguments values to be called on a method track for a given key in a given track.
+     */
+    methodTrackGetParams(trackIdx: number, keyIdx: number): GodotArray { return _C(this, 8904, trackIdx, keyIdx) as GodotArray; }
+
+    /**
+     * Inserts a Bezier Track key at the given `time` in seconds. The `trackIdx` must be the index of a Bezier Track.
+     * `inHandle` is the left-side weight of the added Bezier curve point, `outHandle` is the right-side one, while `value` is the actual value at this point.
+     */
+    bezierTrackInsertKey(trackIdx: number, time: number /* double */, value: number, inHandle?: Vector2 /* = Vector2(0, 0) */, outHandle?: Vector2 /* = Vector2(0, 0) */): number { return _C(this, 1761, trackIdx, time, value, inHandle, outHandle) as number; }
+
+    /**
+     * Sets the value of the key identified by `keyIdx` to the given value. The `trackIdx` must be the index of a Bezier Track.
+     */
+    bezierTrackSetKeyValue(trackIdx: number, keyIdx: number, value: number): void { _C(this, 1765, trackIdx, keyIdx, value); }
+
+    /**
+     * Sets the in handle of the key identified by `keyIdx` to value `inHandle`. The `trackIdx` must be the index of a Bezier Track.
+     */
+    bezierTrackSetKeyInHandle(trackIdx: number, keyIdx: number, inHandle: Vector2, balancedValueTimeRatio?: number /* = 1.0 */): void { _C(this, 1763, trackIdx, keyIdx, inHandle, balancedValueTimeRatio); }
+
+    /**
+     * Sets the out handle of the key identified by `keyIdx` to value `outHandle`. The `trackIdx` must be the index of a Bezier Track.
+     */
+    bezierTrackSetKeyOutHandle(trackIdx: number, keyIdx: number, outHandle: Vector2, balancedValueTimeRatio?: number /* = 1.0 */): void { _C(this, 1764, trackIdx, keyIdx, outHandle, balancedValueTimeRatio); }
+
+    /**
+     * Returns the value of the key identified by `keyIdx`. The `trackIdx` must be the index of a Bezier Track.
+     */
+    bezierTrackGetKeyValue(trackIdx: number, keyIdx: number): number { return _C(this, 1760, trackIdx, keyIdx) as number; }
+
+    /**
+     * Returns the in handle of the key identified by `keyIdx`. The `trackIdx` must be the index of a Bezier Track.
+     */
+    bezierTrackGetKeyInHandle(trackIdx: number, keyIdx: number): Vector2 { return _C(this, 1758, trackIdx, keyIdx) as Vector2; }
+
+    /**
+     * Returns the out handle of the key identified by `keyIdx`. The `trackIdx` must be the index of a Bezier Track.
+     */
+    bezierTrackGetKeyOutHandle(trackIdx: number, keyIdx: number): Vector2 { return _C(this, 1759, trackIdx, keyIdx) as Vector2; }
+
+    /**
+     * Returns the interpolated value at the given `time` (in seconds). The `trackIdx` must be the index of a Bezier Track.
+     */
+    bezierTrackInterpolate(trackIdx: number, time: number /* double */): number { return _C(this, 1762, trackIdx, time) as number; }
+
+    /**
+     * Inserts an Audio Track key at the given `time` in seconds. The `trackIdx` must be the index of an Audio Track.
+     * `stream` is the {@link AudioStream} resource to play. `startOffset` is the number of seconds cut off at the beginning of the audio stream, while `endOffset` is at the ending.
+     */
+    audioTrackInsertKey(trackIdx: number, time: number /* double */, stream: Resource, startOffset?: number /* = 0 */, endOffset?: number /* = 0 */): number { return _C(this, 1632, trackIdx, time, stream, startOffset, endOffset) as number; }
+
+    /**
+     * Sets the stream of the key identified by `keyIdx` to value `stream`. The `trackIdx` must be the index of an Audio Track.
+     */
+    audioTrackSetKeyStream(trackIdx: number, keyIdx: number, stream: Resource): void { _C(this, 1636, trackIdx, keyIdx, stream); }
+
+    /**
+     * Sets the start offset of the key identified by `keyIdx` to value `offset`. The `trackIdx` must be the index of an Audio Track.
+     */
+    audioTrackSetKeyStartOffset(trackIdx: number, keyIdx: number, offset: number): void { _C(this, 1635, trackIdx, keyIdx, offset); }
+
+    /**
+     * Sets the end offset of the key identified by `keyIdx` to value `offset`. The `trackIdx` must be the index of an Audio Track.
+     */
+    audioTrackSetKeyEndOffset(trackIdx: number, keyIdx: number, offset: number): void { _C(this, 1634, trackIdx, keyIdx, offset); }
+
+    /**
+     * Returns the audio stream of the key identified by `keyIdx`. The `trackIdx` must be the index of an Audio Track.
+     */
+    audioTrackGetKeyStream(trackIdx: number, keyIdx: number): Resource { return _C(this, 1631, trackIdx, keyIdx) as Resource; }
+
+    /**
+     * Returns the start offset of the key identified by `keyIdx`. The `trackIdx` must be the index of an Audio Track.
+     * Start offset is the number of seconds cut off at the beginning of the audio stream.
+     */
+    audioTrackGetKeyStartOffset(trackIdx: number, keyIdx: number): number { return _C(this, 1630, trackIdx, keyIdx) as number; }
+
+    /**
+     * Returns the end offset of the key identified by `keyIdx`. The `trackIdx` must be the index of an Audio Track.
+     * End offset is the number of seconds cut off at the ending of the audio stream.
+     */
+    audioTrackGetKeyEndOffset(trackIdx: number, keyIdx: number): number { return _C(this, 1629, trackIdx, keyIdx) as number; }
+
+    /**
+     * Sets whether the track will be blended with other animations. If `true`, the audio playback volume changes depending on the blend value.
+     */
+    audioTrackSetUseBlend(trackIdx: number, enable: boolean): void { _C(this, 1637, trackIdx, enable); }
+
+    /**
+     * Returns `true` if the track at `trackIdx` will be blended with other animations.
+     */
+    audioTrackIsUseBlend(trackIdx: number): boolean { return _C(this, 1633, trackIdx) as boolean; }
+
+    /**
+     * Inserts a key with value `animation` at the given `time` (in seconds). The `trackIdx` must be the index of an Animation Track.
+     */
+    animationTrackInsertKey(trackIdx: number, time: number /* double */, animation: StringName): number { return _C(this, 1493, trackIdx, time, animation) as number; }
+
+    /**
+     * Sets the key identified by `keyIdx` to value `animation`. The `trackIdx` must be the index of an Animation Track.
+     */
+    animationTrackSetKeyAnimation(trackIdx: number, keyIdx: number, animation: StringName): void { _C(this, 1494, trackIdx, keyIdx, animation); }
+
+    /**
+     * Returns the animation name at the key identified by `keyIdx`. The `trackIdx` must be the index of an Animation Track.
+     */
+    animationTrackGetKeyAnimation(trackIdx: number, keyIdx: number): StringName { return _C(this, 1492, trackIdx, keyIdx) as StringName; }
+
+    /**
+     * Adds a marker to this Animation.
+     */
+    addMarker(name: StringName, time: number /* double */): void { _C(this, 1246, name, time); }
+
+    /**
+     * Removes the marker with the given name from this Animation.
+     */
+    removeMarker(name: StringName): void { _C(this, 9932, name); }
+
+    /**
+     * Returns `true` if this Animation contains a marker with the given name.
+     */
+    hasMarker(name: StringName): boolean { return _C(this, 7413, name) as boolean; }
+
+    /**
+     * Returns the name of the marker located at the given time.
+     */
+    getMarkerAtTime(time: number /* double */): StringName { return _C(this, 5443, time) as StringName; }
+
+    /**
+     * Returns the closest marker that comes after the given time. If no such marker exists, an empty string is returned.
+     */
+    getNextMarker(time: number /* double */): StringName { return _C(this, 5627, time) as StringName; }
+
+    /**
+     * Returns the closest marker that comes before the given time. If no such marker exists, an empty string is returned.
+     */
+    getPrevMarker(time: number /* double */): StringName { return _C(this, 6000, time) as StringName; }
+
+    /**
+     * Returns the given marker's time.
+     */
+    getMarkerTime(name: StringName): number { return _C(this, 5448, name) as number; }
+
+    /**
+     * Returns every marker in this Animation, sorted ascending by time.
+     */
+    getMarkerNames(): PackedStringArray { return _C(this, 5447) as PackedStringArray; }
+
+    /**
+     * Returns the given marker's color.
+     */
+    getMarkerColor(name: StringName): Color { return _C(this, 5444, name) as Color; }
+
+    /**
+     * Sets the given marker's color.
+     */
+    setMarkerColor(name: StringName, color: Color): void { _C(this, 11972, name, color); }
+
+    /**
+     * Clear the animation (clear all tracks and reset all).
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Adds a new track to `toAnimation` that is a copy of the given track from this animation.
+     */
+    copyTrack(trackIdx: number, toAnimation: Animation): void { _C(this, 2492, trackIdx, toAnimation); }
+
+    /**
+     * Optimize the animation and all its tracks in-place. This will preserve only as many keys as are necessary to keep the animation within the specified bounds.
+     */
+    optimize(allowedVelocityErr?: number /* = 0.01 */, allowedAngularErr?: number /* = 0.01 */, precision?: number /* = 3 */): void { _C(this, 9207, allowedVelocityErr, allowedAngularErr, precision); }
+
+    /**
+     * Compress the animation and all its tracks in-place. This will make {@link trackIsCompressed} return `true` once called on this {@link Animation}. Compressed tracks require less memory to be played, and are designed to be used for complex 3D animations (such as cutscenes) imported from external 3D software. Compression is lossy, but the difference is usually not noticeable in real world conditions.
+     * **Note:** Compressed tracks have various limitations (such as not being editable from the editor), so only use compressed animations if you actually need them.
+     */
+    compress(pageSize?: number /* = 8192,  uint32 */, fps?: number /* = 120,  uint32 */, splitTolerance?: number /* = 4.0 */): void { _C(this, 2410, pageSize, fps, splitTolerance); }
+
+    /**
+     * The total length of the animation (in seconds).
+     * **Note:** Length is not delimited by the last key, as this one may be before or after the end to ensure correct interpolation and looping.
+     */
+    get length(): number { return _C(this, 5331) as number; }
+    set length(v: number) { _C(this, 11891, v); }
+
+    /**
+     * Determines the behavior of both ends of the animation timeline during animation playback. This indicates whether and how the animation should be restarted, and is also used to correctly interpolate animation cycles.
+     */
+    get loopMode(): LoopMode { return _C(this, 5420) as LoopMode; }
+    set loopMode(v: LoopMode) { _C(this, 11952, v); }
+
+    /**
+     * The animation step value.
+     */
+    get step(): number { return _C(this, 6553) as number; }
+    set step(v: number) { _C(this, 12891, v); }
+
+    /**
+     * Returns `true` if the capture track is included. This is a cached readonly value for performance.
+     */
+    get captureIncluded(): boolean { return _C(this, 7817) as boolean; }
+
+    static readonly name = _R(53, Animation);
+}
+
+export const TrackType = {
+    /**
+     * Value tracks set values in node properties, but only those which can be interpolated. For 3D position/rotation/scale, using the dedicated {@link TYPE_POSITION_3D}, {@link TYPE_ROTATION_3D} and {@link TYPE_SCALE_3D} track types instead of {@link TYPE_VALUE} is recommended for performance reasons.
+     */
+    TYPE_VALUE: 0,
+    /**
+     * 3D position track (values are stored in {@link Vector3}s).
+     */
+    TYPE_POSITION_3D: 1,
+    /**
+     * 3D rotation track (values are stored in {@link Quaternion}s).
+     */
+    TYPE_ROTATION_3D: 2,
+    /**
+     * 3D scale track (values are stored in {@link Vector3}s).
+     */
+    TYPE_SCALE_3D: 3,
+    /**
+     * Blend shape track.
+     */
+    TYPE_BLEND_SHAPE: 4,
+    /**
+     * Method tracks call functions with given arguments per key.
+     */
+    TYPE_METHOD: 5,
+    /**
+     * Bezier tracks are used to interpolate a value using custom curves. They can also be used to animate sub-properties of vectors and colors (e.g. alpha value of a {@link Color}).
+     */
+    TYPE_BEZIER: 6,
+    /**
+     * Audio tracks are used to play an audio stream with either type of {@link AudioStreamPlayer}. The stream can be trimmed and previewed in the animation.
+     */
+    TYPE_AUDIO: 7,
+    /**
+     * Animation tracks play animations in other {@link AnimationPlayer} nodes.
+     */
+    TYPE_ANIMATION: 8,
+} as const;
+
+export type TrackType = (typeof TrackType)[keyof typeof TrackType];
+
+export const InterpolationType = {
+    /**
+     * No interpolation (nearest value).
+     */
+    INTERPOLATION_NEAREST: 0,
+    /**
+     * Linear interpolation.
+     */
+    INTERPOLATION_LINEAR: 1,
+    /**
+     * Cubic interpolation. This looks smoother than linear interpolation, but is more expensive to interpolate. Stick to {@link INTERPOLATION_LINEAR} for complex 3D animations imported from external software, even if it requires using a higher animation framerate in return.
+     */
+    INTERPOLATION_CUBIC: 2,
+    /**
+     * Linear interpolation with shortest path rotation.
+     * **Note:** The result value is always normalized and may not match the key value.
+     */
+    INTERPOLATION_LINEAR_ANGLE: 3,
+    /**
+     * Cubic interpolation with shortest path rotation.
+     * **Note:** The result value is always normalized and may not match the key value.
+     */
+    INTERPOLATION_CUBIC_ANGLE: 4,
+} as const;
+
+export type InterpolationType = (typeof InterpolationType)[keyof typeof InterpolationType];
+
+export const UpdateMode = {
+    /**
+     * Update between keyframes and hold the value.
+     */
+    UPDATE_CONTINUOUS: 0,
+    /**
+     * Update at the keyframes.
+     */
+    UPDATE_DISCRETE: 1,
+    /**
+     * Same as {@link UPDATE_CONTINUOUS} but works as a flag to capture the value of the current object and perform interpolation in some methods. See also {@link AnimationMixer.capture}, {@link AnimationPlayer.playbackAutoCapture}, and {@link AnimationPlayer.playWithCapture}.
+     */
+    UPDATE_CAPTURE: 2,
+} as const;
+
+export type UpdateMode = (typeof UpdateMode)[keyof typeof UpdateMode];
+
+export const LoopMode = {
+    /**
+     * At both ends of the animation, the animation will stop playing.
+     */
+    LOOP_NONE: 0,
+    /**
+     * At both ends of the animation, the animation will be repeated without changing the playback direction.
+     */
+    LOOP_LINEAR: 1,
+    /**
+     * Repeats playback and reverse playback at both ends of the animation.
+     */
+    LOOP_PINGPONG: 2,
+} as const;
+
+export type LoopMode = (typeof LoopMode)[keyof typeof LoopMode];
+
+export const LoopedFlag = {
+    /**
+     * This flag indicates that the animation proceeds without any looping.
+     */
+    LOOPED_FLAG_NONE: 0,
+    /**
+     * This flag indicates that the animation has reached the end of the animation and just after loop processed.
+     */
+    LOOPED_FLAG_END: 1,
+    /**
+     * This flag indicates that the animation has reached the start of the animation and just after loop processed.
+     */
+    LOOPED_FLAG_START: 2,
+} as const;
+
+export type LoopedFlag = (typeof LoopedFlag)[keyof typeof LoopedFlag];
+
+export const FindMode = {
+    /**
+     * Finds the nearest time key.
+     */
+    FIND_MODE_NEAREST: 0,
+    /**
+     * Finds only the key with approximating the time.
+     */
+    FIND_MODE_APPROX: 1,
+    /**
+     * Finds only the key with matching the time.
+     */
+    FIND_MODE_EXACT: 2,
+} as const;
+
+export type FindMode = (typeof FindMode)[keyof typeof FindMode];
+

package/gen/classes/AnimationLibrary.ts

@@ -0,0 +1,77 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, Signal, StringName } from '../heap-types/index.ts';
+import type { Animation } from './Animation.ts';
+
+/**
+ * An animation library stores a set of animations accessible through {@link StringName} keys, for use with {@link AnimationPlayer} nodes.
+ */
+export class AnimationLibrary extends Resource {
+    constructor(name = 54) { super(name); }
+
+    /**
+     * Adds the `animation` to the library, accessible by the key `name`.
+     */
+    addAnimation(name: StringName, animation: Animation): Error { return _C(this, 1179, name, animation) as Error; }
+
+    /**
+     * Removes the {@link Animation} with the key `name`.
+     */
+    removeAnimation(name: StringName): void { _C(this, 9884, name); }
+
+    /**
+     * Changes the key of the {@link Animation} associated with the key `name` to `newname`.
+     */
+    renameAnimation(name: StringName, newname: StringName): void { _C(this, 9993, name, newname); }
+
+    /**
+     * Returns `true` if the library stores an {@link Animation} with `name` as the key.
+     */
+    hasAnimation(name: StringName): boolean { return _C(this, 7356, name) as boolean; }
+
+    /**
+     * Returns the {@link Animation} with the key `name`. If the animation does not exist, `null` is returned and an error is logged.
+     */
+    getAnimation(name: StringName): Animation { return _C(this, 3759, name) as Animation; }
+
+    /**
+     * Returns the keys for the {@link Animation}s stored in the library.
+     */
+    getAnimationList(): GodotArray<StringName> { return _C(this, 3762) as GodotArray<StringName>; }
+
+    /**
+     * Returns the key count for the {@link Animation}s stored in the library.
+     */
+    getAnimationListSize(): number { return _C(this, 3763) as number; }
+
+    /**
+     * Emitted when an {@link Animation} is added, under the key `animName`.
+     */
+    get animationAdded(): Signal<(animName: StringName) => void> { return _G(this, 1477) as Signal<(animName: StringName) => void>; }
+    set animationAdded(v: ((animName: StringName) => void) | null) { _G(this, 1477, v); }
+
+    /**
+     * Emitted when an {@link Animation} stored with the key `animName` is removed.
+     */
+    get animationRemoved(): Signal<(animName: StringName) => void> { return _G(this, 1488) as Signal<(animName: StringName) => void>; }
+    set animationRemoved(v: ((animName: StringName) => void) | null) { _G(this, 1488, v); }
+
+    /**
+     * Emitted when the key for an {@link Animation} is changed, from `oldName` to `newName`.
+     */
+    get animationRenamed(): Signal<(oldName: StringName, newName: StringName) => void> { return _G(this, 1489) as Signal<(oldName: StringName, newName: StringName) => void>; }
+    set animationRenamed(v: ((oldName: StringName, newName: StringName) => void) | null) { _G(this, 1489, v); }
+
+    /**
+     * Emitted when there's a change in one of the animations, e.g. tracks are added, moved or have changed paths. `animName` is the key of the animation that was changed.
+     * See also {@link Resource.changed}, which this acts as a relay for.
+     */
+    get animationChanged(): Signal<(animName: StringName) => void> { return _G(this, 1478) as Signal<(animName: StringName) => void>; }
+    set animationChanged(v: ((animName: StringName) => void) | null) { _G(this, 1478, v); }
+
+    static readonly name = _R(54, AnimationLibrary);
+}