@ringozz/godot 0.1.0

package/gen/classes/AnimationNodeAnimation.ts

@@ -0,0 +1,84 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationRootNode } from './AnimationRootNode.ts';
+import type { StringName } from '../heap-types/index.ts';
+import type { LoopMode } from './AudioStreamWAV.ts';
+
+/**
+ * A resource to add to an {@link AnimationNodeBlendTree}. Only has one output port using the {@link animation} property. Used as an input for {@link AnimationNode}s that blend animations together.
+ */
+export class AnimationNodeAnimation extends AnimationRootNode {
+    constructor(name = 59) { super(name); }
+
+    /**
+     * Animation to use as an output. It is one of the animations provided by {@link AnimationTree.animPlayer}.
+     */
+    get animation(): StringName { return _C(this, 3759) as StringName; }
+    set animation(v: StringName) { _C(this, 10502, v); }
+
+    /**
+     * Determines the playback direction of the animation.
+     */
+    get playMode(): PlayMode { return _C(this, 5930) as PlayMode; }
+    set playMode(v: PlayMode) { _C(this, 12345, v); }
+
+    /**
+     * 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}.
+     */
+    get advanceOnStart(): boolean { return _C(this, 7749) as boolean; }
+    set advanceOnStart(v: boolean) { _C(this, 10440, v); }
+
+    /**
+     * If `true`, {@link AnimationNode} provides an animation based on the {@link Animation} resource with some parameters adjusted.
+     */
+    get useCustomTimeline(): boolean { return _C(this, 8400) as boolean; }
+    set useCustomTimeline(v: boolean) { _C(this, 13206, v); }
+
+    /**
+     * The length of the custom timeline.
+     * If {@link stretchTimeScale} is `true`, scales the animation to this length.
+     */
+    get timelineLength(): number { return _C(this, 6819) as number; }
+    set timelineLength(v: number) { _C(this, 13088, v); }
+
+    /**
+     * If `true`, scales the time so that the length specified in {@link timelineLength} 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 loopMode}, the animation will loop in {@link timelineLength}.
+     */
+    get stretchTimeScale(): boolean { return _C(this, 8345) as boolean; }
+    set stretchTimeScale(v: boolean) { _C(this, 12910, v); }
+
+    /**
+     * If {@link useCustomTimeline} is `true`, offset the start position of the animation.
+     * This is useful for adjusting which foot steps first in 3D walking animations.
+     */
+    get startOffset(): number { return _C(this, 6535) as number; }
+    set startOffset(v: number) { _C(this, 12880, v); }
+
+    /**
+     * If {@link useCustomTimeline} is `true`, override the loop settings of the original {@link Animation} resource with the value.
+     * **Note:** If the {@link Animation.loopMode} isn't set to looping, the {@link Animation.trackSetInterpolationLoopWrap} option will not be respected. If you cannot get the expected behavior, consider duplicating the {@link Animation} resource and changing the loop settings.
+     */
+    get loopMode(): LoopMode { return _C(this, 5420) as LoopMode; }
+    set loopMode(v: LoopMode) { _C(this, 11952, v); }
+
+    static readonly name = _R(59, AnimationNodeAnimation);
+}
+
+export const PlayMode = {
+    /**
+     * Plays animation in forward direction.
+     */
+    PLAY_MODE_FORWARD: 0,
+    /**
+     * Plays animation in backward direction.
+     */
+    PLAY_MODE_BACKWARD: 1,
+} as const;
+
+export type PlayMode = (typeof PlayMode)[keyof typeof PlayMode];
+

package/gen/classes/AnimationNodeBlend2.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationNodeSync } from './AnimationNodeSync.ts';
+
+/**
+ * A resource to add to an {@link AnimationNodeBlendTree}. Blends two animations linearly based on the amount value.
+ * In general, the blend value should be in the `[0.0, 1.0]` range. Values outside of this range can blend amplified or inverted animations, however, {@link AnimationNodeAdd2} works better for this purpose.
+ */
+export class AnimationNodeBlend2 extends AnimationNodeSync {
+    constructor(name = 60) { super(name); }
+
+    static readonly name = _R(60, AnimationNodeBlend2);
+}

package/gen/classes/AnimationNodeBlend3.ts

@@ -0,0 +1,19 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationNodeSync } from './AnimationNodeSync.ts';
+
+/**
+ * A resource to add to an {@link AnimationNodeBlendTree}. Blends two animations out of three linearly out of three based on the amount value.
+ * This animation node has three inputs:
+ * - The base animation to blend with
+ * - A "-blend" animation to blend with when the blend amount is negative value
+ * - A "+blend" animation to blend with when the blend amount is positive value
+ * In general, the blend value should be in the `[-1.0, 1.0]` range. Values outside of this range can blend amplified animations, however, {@link AnimationNodeAdd3} works better for this purpose.
+ */
+export class AnimationNodeBlend3 extends AnimationNodeSync {
+    constructor(name = 61) { super(name); }
+
+    static readonly name = _R(61, AnimationNodeBlend3);
+}

package/gen/classes/AnimationNodeBlendSpace1D.ts

@@ -0,0 +1,162 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationRootNode } from './AnimationRootNode.ts';
+import type { StringName } from '../heap-types/index.ts';
+
+/**
+ * A resource used by {@link AnimationNodeBlendTree}.
+ * {@link AnimationNodeBlendSpace1D} represents a virtual axis on which any type of {@link AnimationRootNode}s can be added using {@link addBlendPoint}. Outputs the linear blend of the two {@link AnimationRootNode}s adjacent to the current value.
+ * You can set the extents of the axis with {@link minSpace} and {@link maxSpace}.
+ */
+export class AnimationNodeBlendSpace1D extends AnimationRootNode {
+    constructor(name = 62) { super(name); }
+
+    /**
+     * 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 `atIndex` argument. If you use the default value for `atIndex`, 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.
+     */
+    addBlendPoint(node: AnimationRootNode, pos: number, atIndex?: number /* = -1 */, name?: StringName /* = &"" */): void { _C(this, 1184, node, pos, atIndex, name); }
+
+    /**
+     * Updates the position of the point at index `point` on the blend axis.
+     */
+    setBlendPointPosition(point: number, pos: number): void { _C(this, 10680, point, pos); }
+
+    /**
+     * Returns the position of the point at index `point`.
+     */
+    getBlendPointPosition(point: number): number { return _C(this, 3936, point) as number; }
+
+    /**
+     * Changes the {@link AnimationNode} referenced by the point at index `point`.
+     */
+    setBlendPointNode(point: number, node: AnimationRootNode): void { _C(this, 10679, point, node); }
+
+    /**
+     * Returns the {@link AnimationNode} referenced by the point at index `point`.
+     */
+    getBlendPointNode(point: number): AnimationRootNode { return _C(this, 3935, point) as AnimationRootNode; }
+
+    /**
+     * 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.
+     */
+    setBlendPointName(point: number, name: StringName): void { _C(this, 10678, point, name); }
+
+    /**
+     * Returns the name of the blend point at index `point`.
+     */
+    getBlendPointName(point: number): StringName { return _C(this, 3934, point) as StringName; }
+
+    /**
+     * Returns the index of the blend point with the given `name`. Returns `-1` if no blend point with that name is found.
+     */
+    findBlendPointByName(name: StringName): number { return _C(this, 3281, name) as number; }
+
+    /**
+     * Removes the point at index `point` from the blend axis.
+     */
+    removeBlendPoint(point: number): void { _C(this, 9888, point); }
+
+    /**
+     * Returns the number of points on the blend axis.
+     */
+    getBlendPointCount(): number { return _C(this, 3933) as number; }
+
+    /**
+     * Swaps the blend points at indices `fromIndex` and `toIndex`, exchanging their positions and properties.
+     */
+    reorderBlendPoint(fromIndex: number, toIndex: number): void { _C(this, 10033, fromIndex, toIndex); }
+
+    /**
+     * The blend space's axis's lower limit for the points' position. See {@link addBlendPoint}.
+     */
+    get minSpace(): number { return _C(this, 5545) as number; }
+    set minSpace(v: number) { _C(this, 12055, v); }
+
+    /**
+     * The blend space's axis's upper limit for the points' position. See {@link addBlendPoint}.
+     */
+    get maxSpace(): number { return _C(this, 5487) as number; }
+    set maxSpace(v: number) { _C(this, 12009, v); }
+
+    /**
+     * Position increment to snap to when moving a point on the axis.
+     */
+    get snap(): number { return _C(this, 6446) as number; }
+    set snap(v: number) { _C(this, 12799, v); }
+
+    /**
+     * Label of the virtual axis of the blend space.
+     */
+    get valueLabel(): string { return _C(this, 7019) as string; }
+    set valueLabel(v: string) { _C(this, 13269, v); }
+
+    /**
+     * Controls the interpolation between animations.
+     */
+    get blendMode(): BlendMode { return _C(this, 3932) as BlendMode; }
+    set blendMode(v: BlendMode) { _C(this, 10677, v); }
+
+    /**
+     * If `true`, sync mode is enabled (equivalent to {@link SYNC_MODE_INDEPENDENT}). This property is kept for backward compatibility.
+     */
+    get sync(): boolean { return _C(this, 8422) as boolean; }
+    set sync(v: boolean) { _C(this, 13239, v); }
+
+    /**
+     * Controls how animations are synced when blended. See {@link SyncMode} for available options.
+     */
+    get syncMode(): SyncMode { return _C(this, 6652) as SyncMode; }
+    set syncMode(v: SyncMode) { _C(this, 12960, v); }
+
+    /**
+     * The cycle length in seconds used by {@link SYNC_MODE_CYCLIC_CONSTANT}. All animations are time-scaled so they complete one full cycle in this duration. Must be greater than `0` for cyclic sync to take effect.
+     */
+    get cyclicLength(): number { return _C(this, 4404) as number; }
+    set cyclicLength(v: number) { _C(this, 11028, v); }
+
+    static readonly name = _R(62, AnimationNodeBlendSpace1D);
+}
+
+export const BlendMode = {
+    /**
+     * The interpolation between animations is linear.
+     */
+    BLEND_MODE_INTERPOLATED: 0,
+    /**
+     * The blend space plays the animation of the animation node which blending position is closest to. Useful for frame-by-frame 2D animations.
+     */
+    BLEND_MODE_DISCRETE: 1,
+    /**
+     * Similar to {@link BLEND_MODE_DISCRETE}, but starts the new animation at the last animation's playback position.
+     */
+    BLEND_MODE_DISCRETE_CARRY: 2,
+} as const;
+
+export type BlendMode = (typeof BlendMode)[keyof typeof BlendMode];
+
+export const SyncMode = {
+    /**
+     * Inactive animations are frozen and do not advance.
+     */
+    SYNC_MODE_NONE: 0,
+    /**
+     * Inactive animations advance with a weight of `0`. This is equivalent to the previous `sync = true` behavior.
+     */
+    SYNC_MODE_INDEPENDENT: 1,
+    /**
+     * All animations are time-scaled so they stay in sync, with the cycle length dynamically computed from active blend weights. This is self-normalizing: a solo animation plays at normal speed.
+     * **Note:** If you apply {@link AnimationNodeTimeSeek} to the result when handling animations of different lengths, synchronization will be broken. In such cases, it is recommended to use {@link AnimationNodeAnimation.useCustomTimeline} to align the animation lengths.
+     */
+    SYNC_MODE_CYCLIC_MUTABLE: 2,
+    /**
+     * All animations are time-scaled so they complete one cycle in {@link cyclicLength} seconds, keeping them in sync regardless of their individual lengths.
+     * **Note:** If you apply {@link AnimationNodeTimeSeek} to the result when handling animations of different lengths, synchronization will be broken. In such cases, it is recommended to use {@link AnimationNodeAnimation.useCustomTimeline} to align the animation lengths.
+     */
+    SYNC_MODE_CYCLIC_CONSTANT: 3,
+} as const;
+
+export type SyncMode = (typeof SyncMode)[keyof typeof SyncMode];
+

package/gen/classes/AnimationNodeBlendSpace2D.ts

@@ -0,0 +1,204 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { AnimationRootNode } from './AnimationRootNode.ts';
+import type { PackedInt32Array, Signal, StringName } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * A resource used by {@link AnimationNodeBlendTree}.
+ * {@link AnimationNodeBlendSpace2D} represents a virtual 2D space on which {@link AnimationRootNode}s are placed. Outputs the linear blend of the three adjacent animations using a {@link Vector2} weight. Adjacent in this context means the three {@link AnimationRootNode}s making up the triangle that contains the current value.
+ * You can add vertices to the blend space with {@link addBlendPoint} and automatically triangulate it by setting {@link autoTriangles} to `true`. Otherwise, use {@link addTriangle} and {@link removeTriangle} to triangulate the blend space by hand.
+ */
+export class AnimationNodeBlendSpace2D extends AnimationRootNode {
+    constructor(name = 63) { super(name); }
+
+    /**
+     * 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 `atIndex` argument. If you use the default value for `atIndex`, 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.
+     */
+    addBlendPoint(node: AnimationRootNode, pos: Vector2, atIndex?: number /* = -1 */, name?: StringName /* = &"" */): void { _C(this, 1184, node, pos, atIndex, name); }
+
+    /**
+     * Updates the position of the point at index `point` in the blend space.
+     */
+    setBlendPointPosition(point: number, pos: Vector2): void { _C(this, 10680, point, pos); }
+
+    /**
+     * Returns the position of the point at index `point`.
+     */
+    getBlendPointPosition(point: number): Vector2 { return _C(this, 3936, point) as Vector2; }
+
+    /**
+     * Changes the {@link AnimationNode} referenced by the point at index `point`.
+     */
+    setBlendPointNode(point: number, node: AnimationRootNode): void { _C(this, 10679, point, node); }
+
+    /**
+     * Returns the {@link AnimationRootNode} referenced by the point at index `point`.
+     */
+    getBlendPointNode(point: number): AnimationRootNode { return _C(this, 3935, point) as AnimationRootNode; }
+
+    /**
+     * 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.
+     */
+    setBlendPointName(point: number, name: StringName): void { _C(this, 10678, point, name); }
+
+    /**
+     * Returns the name of the blend point at index `point`.
+     */
+    getBlendPointName(point: number): StringName { return _C(this, 3934, point) as StringName; }
+
+    /**
+     * Returns the index of the blend point with the given `name`. Returns `-1` if no blend point with that name is found.
+     */
+    findBlendPointByName(name: StringName): number { return _C(this, 3281, name) as number; }
+
+    /**
+     * Removes the point at index `point` from the blend space.
+     */
+    removeBlendPoint(point: number): void { _C(this, 9888, point); }
+
+    /**
+     * Returns the number of points in the blend space.
+     */
+    getBlendPointCount(): number { return _C(this, 3933) as number; }
+
+    /**
+     * Swaps the blend points at indices `fromIndex` and `toIndex`, exchanging their positions and properties.
+     */
+    reorderBlendPoint(fromIndex: number, toIndex: number): void { _C(this, 10033, fromIndex, toIndex); }
+
+    /**
+     * 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 `atIndex` argument. If you use the default value for `atIndex`, the point is inserted at the end of the blend points array.
+     */
+    addTriangle(x: number, y: number, z: number, atIndex?: number /* = -1 */): void { _C(this, 1321, x, y, z, atIndex); }
+
+    /**
+     * Returns the position of the point at index `point` in the triangle of index `triangle`.
+     */
+    getTrianglePoint(triangle: number, point: number): number { return _C(this, 6911, triangle, point) as number; }
+
+    /**
+     * Removes the triangle at index `triangle` from the blend space.
+     */
+    removeTriangle(triangle: number): void { _C(this, 9983, triangle); }
+
+    /**
+     * Returns the number of triangles in the blend space.
+     */
+    getTriangleCount(): number { return _C(this, 6910) as number; }
+
+    /**
+     * If `true`, the blend space is triangulated automatically. The mesh updates every time you add or remove points with {@link addBlendPoint} and {@link removeBlendPoint}.
+     */
+    get autoTriangles(): boolean { return _C(this, 3840) as boolean; }
+    set autoTriangles(v: boolean) { _C(this, 10583, v); }
+
+    get triangles(): PackedInt32Array { return _C(this, 1015) as PackedInt32Array; }
+    set triangles(v: PackedInt32Array) { _C(this, 1046, v); }
+
+    /**
+     * The blend space's X and Y axes' lower limit for the points' position. See {@link addBlendPoint}.
+     */
+    get minSpace(): Vector2 { return _C(this, 5545) as Vector2; }
+    set minSpace(v: Vector2) { _C(this, 12055, v); }
+
+    /**
+     * The blend space's X and Y axes' upper limit for the points' position. See {@link addBlendPoint}.
+     */
+    get maxSpace(): Vector2 { return _C(this, 5487) as Vector2; }
+    set maxSpace(v: Vector2) { _C(this, 12009, v); }
+
+    /**
+     * Position increment to snap to when moving a point.
+     */
+    get snap(): Vector2 { return _C(this, 6446) as Vector2; }
+    set snap(v: Vector2) { _C(this, 12799, v); }
+
+    /**
+     * Name of the blend space's X axis.
+     */
+    get xLabel(): string { return _C(this, 7172) as string; }
+    set xLabel(v: string) { _C(this, 13394, v); }
+
+    /**
+     * Name of the blend space's Y axis.
+     */
+    get yLabel(): string { return _C(this, 7176) as string; }
+    set yLabel(v: string) { _C(this, 13398, v); }
+
+    /**
+     * Controls the interpolation between animations.
+     */
+    get blendMode(): BlendMode { return _C(this, 3932) as BlendMode; }
+    set blendMode(v: BlendMode) { _C(this, 10677, v); }
+
+    /**
+     * If `true`, sync mode is enabled (equivalent to {@link SYNC_MODE_INDEPENDENT}). This property is kept for backward compatibility.
+     */
+    get sync(): boolean { return _C(this, 8422) as boolean; }
+    set sync(v: boolean) { _C(this, 13239, v); }
+
+    /**
+     * Controls how animations are synced when blended. See {@link SyncMode} for available options.
+     */
+    get syncMode(): SyncMode { return _C(this, 6652) as SyncMode; }
+    set syncMode(v: SyncMode) { _C(this, 12960, v); }
+
+    /**
+     * The cycle length in seconds used by {@link SYNC_MODE_CYCLIC_CONSTANT}. All animations are time-scaled so they complete one full cycle in this duration. Must be greater than `0` for cyclic sync to take effect.
+     */
+    get cyclicLength(): number { return _C(this, 4404) as number; }
+    set cyclicLength(v: number) { _C(this, 11028, v); }
+
+    /**
+     * Emitted every time the blend space's triangles are created, removed, or when one of their vertices changes position.
+     */
+    get trianglesUpdated(): Signal<() => void> { return _G(this, 14416) as Signal<() => void>; }
+    set trianglesUpdated(v: (() => void) | null) { _G(this, 14416, v); }
+
+    static readonly name = _R(63, AnimationNodeBlendSpace2D);
+}
+
+export const BlendMode = {
+    /**
+     * The interpolation between animations is linear.
+     */
+    BLEND_MODE_INTERPOLATED: 0,
+    /**
+     * The blend space plays the animation of the animation node which blending position is closest to. Useful for frame-by-frame 2D animations.
+     */
+    BLEND_MODE_DISCRETE: 1,
+    /**
+     * Similar to {@link BLEND_MODE_DISCRETE}, but starts the new animation at the last animation's playback position.
+     */
+    BLEND_MODE_DISCRETE_CARRY: 2,
+} as const;
+
+export type BlendMode = (typeof BlendMode)[keyof typeof BlendMode];
+
+export const SyncMode = {
+    /**
+     * Inactive animations are frozen and do not advance.
+     */
+    SYNC_MODE_NONE: 0,
+    /**
+     * Inactive animations advance with a weight of `0`. This is equivalent to the previous `sync = true` behavior.
+     */
+    SYNC_MODE_INDEPENDENT: 1,
+    /**
+     * All animations are time-scaled so they stay in sync, with the cycle length dynamically computed from active blend weights. This is self-normalizing: a solo animation plays at normal speed.
+     * **Note:** If you apply {@link AnimationNodeTimeSeek} to the result when handling animations of different lengths, synchronization will be broken. In such cases, it is recommended to use {@link AnimationNodeAnimation.useCustomTimeline} to align the animation lengths.
+     */
+    SYNC_MODE_CYCLIC_MUTABLE: 2,
+    /**
+     * All animations are time-scaled so they complete one cycle in {@link cyclicLength} seconds, keeping them in sync regardless of their individual lengths.
+     * **Note:** If you apply {@link AnimationNodeTimeSeek} to the result when handling animations of different lengths, synchronization will be broken. In such cases, it is recommended to use {@link AnimationNodeAnimation.useCustomTimeline} to align the animation lengths.
+     */
+    SYNC_MODE_CYCLIC_CONSTANT: 3,
+} as const;
+
+export type SyncMode = (typeof SyncMode)[keyof typeof SyncMode];
+

package/gen/classes/AnimationNodeBlendTree.ts

@@ -0,0 +1,110 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { AnimationRootNode } from './AnimationRootNode.ts';
+import type { GodotArray, Signal, StringName } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { AnimationNode } from './AnimationNode.ts';
+
+/**
+ * This animation node may contain a sub-tree of any other type animation nodes, such as {@link AnimationNodeTransition}, {@link AnimationNodeBlend2}, {@link AnimationNodeBlend3}, {@link AnimationNodeOneShot}, etc. This is one of the most commonly used animation node roots.
+ * An {@link AnimationNodeOutput} node named `output` is created by default.
+ */
+export class AnimationNodeBlendTree extends AnimationRootNode {
+    constructor(name = 64) { super(name); }
+
+    /**
+     * Adds an {@link AnimationNode} at the given `position`. The `name` is used to identify the created sub animation node later.
+     */
+    addNode(name: StringName, node: AnimationNode, position?: Vector2 /* = Vector2(0, 0) */): void { _C(this, 1257, name, node, position); }
+
+    /**
+     * Returns the sub animation node with the specified `name`.
+     */
+    getNode(name: StringName): AnimationNode { return _C(this, 5638, name) as AnimationNode; }
+
+    /**
+     * Removes a sub animation node.
+     */
+    removeNode(name: StringName): void { _C(this, 9937, name); }
+
+    /**
+     * Changes the name of a sub animation node.
+     */
+    renameNode(name: StringName, newName: StringName): void { _C(this, 10000, name, newName); }
+
+    /**
+     * Returns `true` if a sub animation node with specified `name` exists.
+     */
+    hasNode(name: StringName): boolean { return _C(this, 7420, name) as boolean; }
+
+    /**
+     * Connects the output of an {@link AnimationNode} as input for another {@link AnimationNode}, at the input port specified by `inputIndex`.
+     */
+    connectNode(inputNode: StringName, inputIndex: number, outputNode: StringName): void { _C(this, 2434, inputNode, inputIndex, outputNode); }
+
+    /**
+     * Disconnects the animation node connected to the specified input.
+     */
+    disconnectNode(inputNode: StringName, inputIndex: number): void { _C(this, 2825, inputNode, inputIndex); }
+
+    /**
+     * Returns a list containing the names of all sub animation nodes in this blend tree.
+     */
+    getNodeList(): GodotArray<StringName> { return _C(this, 5650) as GodotArray<StringName>; }
+
+    /**
+     * Modifies the position of a sub animation node.
+     */
+    setNodePosition(name: StringName, position: Vector2): void { _C(this, 12139, name, position); }
+
+    /**
+     * Returns the position of the sub animation node with the specified `name`.
+     */
+    getNodePosition(name: StringName): Vector2 { return _C(this, 5657, name) as Vector2; }
+
+    /**
+     * The global offset of all sub animation nodes.
+     */
+    get graphOffset(): Vector2 { return _C(this, 4970) as Vector2; }
+    set graphOffset(v: Vector2) { _C(this, 11552, v); }
+
+    /**
+     * The connection was successful.
+     */
+    static readonly CONNECTION_OK = 0;
+
+    /**
+     * The input node is `null`.
+     */
+    static readonly CONNECTION_ERROR_NO_INPUT = 1;
+
+    /**
+     * The specified input port is out of range.
+     */
+    static readonly CONNECTION_ERROR_NO_INPUT_INDEX = 2;
+
+    /**
+     * The output node is `null`.
+     */
+    static readonly CONNECTION_ERROR_NO_OUTPUT = 3;
+
+    /**
+     * Input and output nodes are the same.
+     */
+    static readonly CONNECTION_ERROR_SAME_NODE = 4;
+
+    /**
+     * The specified connection already exists.
+     */
+    static readonly CONNECTION_ERROR_CONNECTION_EXISTS = 5;
+
+    /**
+     * Emitted when the input port information is changed.
+     */
+    get nodeChanged(): Signal<(nodeName: StringName) => void> { return _G(this, 9080) as Signal<(nodeName: StringName) => void>; }
+    set nodeChanged(v: ((nodeName: StringName) => void) | null) { _G(this, 9080, v); }
+
+    static readonly name = _R(64, AnimationNodeBlendTree);
+}

package/gen/classes/AnimationNodeExtension.ts

@@ -0,0 +1,25 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AnimationNode } from './AnimationNode.ts';
+import type { PackedFloat32Array, PackedFloat64Array } from '../heap-types/index.ts';
+
+/**
+ * {@link AnimationNodeExtension} exposes the APIs of {@link AnimationRootNode} to allow users to extend it from GDScript, C#, or C++. This class is not meant to be used directly, but to be extended by other classes. It is used to create custom nodes for the {@link AnimationTree} system.
+ */
+export class AnimationNodeExtension extends AnimationNode {
+    constructor(name = 65) { super(name); }
+
+    /**
+     * Returns `true` if the animation for the given `nodeInfo` is looping.
+     */
+    static isLooping(nodeInfo: PackedFloat32Array): boolean { return _C(65, 8094, nodeInfo) as boolean; }
+
+    /**
+     * Returns the animation's remaining time for the given node info. For looping animations, it will only return the remaining time if `breakLoop` is `true`, a large integer value will be returned otherwise.
+     */
+    static getRemainingTime(nodeInfo: PackedFloat32Array, breakLoop: boolean): number { return _C(65, 6124, nodeInfo, breakLoop) as number; }
+
+    static readonly name = _R(65, AnimationNodeExtension);
+}