@ringozz/godot 0.1.0

package/gen/classes/SpinBox.ts

@@ -0,0 +1,97 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Range } from './Range.ts';
+import type { HorizontalAlignment } from '../global-enums.ts';
+import type { LineEdit } from './LineEdit.ts';
+
+/**
+ * {@link SpinBox} is a numerical input text field. It allows entering integers and floating-point numbers. The {@link SpinBox} also has up and down buttons that can be clicked to increase or decrease the value. The value can also be changed by dragging the mouse up or down over the {@link SpinBox}'s arrows.
+ * Additionally, mathematical expressions can be entered. These are evaluated when the user presses `Enter` while editing the {@link SpinBox}'s text field. This uses the {@link Expression} class to parse and evaluate the expression. The result of the expression is then set as the value of the {@link SpinBox}. Some examples of valid expressions are `5 + 2 * 3`, `pow(2, 4)`, and `PI + sin(0.5)`. Expressions are case-sensitive.
+ * **Example:** Create a {@link SpinBox}, disable its context menu and set its text alignment to right.
+ *
+ *
+ * ```gdscript
+ *
+ * var spin_box = SpinBox.new()
+ * add_child(spin_box)
+ * var line_edit = spin_box.get_line_edit()
+ * line_edit.context_menu_enabled = false
+ * spin_box.horizontal_alignment = LineEdit.HORIZONTAL_ALIGNMENT_RIGHT
+ *
+ * ```
+ *
+ *
+ *
+ * See {@link Range} class for more options over the {@link SpinBox}.
+ * **Note:** With the {@link SpinBox}'s context menu disabled, you can right-click the bottom half of the spinbox to set the value to its minimum, while right-clicking the top half sets the value to its maximum.
+ * **Note:** {@link SpinBox} relies on an underlying {@link LineEdit} node. To theme a {@link SpinBox}'s background, add theme items for {@link LineEdit} and customize them. The {@link LineEdit} has the `SpinBoxInnerLineEdit` theme variation, so that you can give it a distinct appearance from regular {@link LineEdit}s.
+ * **Note:** If you want to implement drag and drop for the underlying {@link LineEdit}, you can use {@link Control.setDragForwarding} on the node returned by {@link getLineEdit}.
+ */
+export class SpinBox extends Range {
+    constructor(name = 726) { super(name); }
+
+    /**
+     * Applies the current value of this {@link SpinBox}. This is equivalent to pressing `Enter` while editing the {@link LineEdit} used by the {@link SpinBox}. This will cause {@link LineEdit.text_submitted} to be emitted and its currently contained expression to be evaluated.
+     */
+    apply(): void { _C(this, 1527); }
+
+    /**
+     * Returns the {@link LineEdit} instance from this {@link SpinBox}. You can use it to access properties and methods of {@link LineEdit}.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link CanvasItem.visible} property.
+     */
+    getLineEdit(): LineEdit { return _C(this, 5357) as LineEdit; }
+
+    /**
+     * Changes the alignment of the underlying {@link LineEdit}.
+     */
+    get alignment(): HorizontalAlignment { return _C(this, 5044) as HorizontalAlignment; }
+    set alignment(v: HorizontalAlignment) { _C(this, 11638, v); }
+
+    /**
+     * If `true`, the {@link SpinBox} will be editable. Otherwise, it will be read only.
+     */
+    get editable(): boolean { return _C(this, 7916) as boolean; }
+    set editable(v: boolean) { _C(this, 11216, v); }
+
+    /**
+     * Sets the value of the {@link Range} for this {@link SpinBox} when the {@link LineEdit} text is *changed* instead of *submitted*. See {@link LineEdit.text_changed} and {@link LineEdit.text_submitted}.
+     * **Note:** If set to `true`, this will interfere with entering mathematical expressions in the {@link SpinBox}. The {@link SpinBox} will try to evaluate the expression as you type, which means symbols like a trailing `+` are removed immediately by the expression being evaluated.
+     */
+    get updateOnTextChanged(): boolean { return _C(this, 6961) as boolean; }
+    set updateOnTextChanged(v: boolean) { _C(this, 13181, v); }
+
+    /**
+     * Adds the specified prefix string before the numerical value of the {@link SpinBox}.
+     */
+    get prefix(): string { return _C(this, 5989) as string; }
+    set prefix(v: string) { _C(this, 12398, v); }
+
+    /**
+     * Adds the specified suffix string after the numerical value of the {@link SpinBox}.
+     */
+    get suffix(): string { return _C(this, 6607) as string; }
+    set suffix(v: string) { _C(this, 12931, v); }
+
+    /**
+     * If not `0`, sets the step when interacting with the arrow buttons of the {@link SpinBox}.
+     * **Note:** {@link Range.value} will still be rounded to a multiple of {@link Range.step}.
+     */
+    get customArrowStep(): number { return _C(this, 4376) as number; }
+    set customArrowStep(v: number) { _C(this, 11001, v); }
+
+    /**
+     * If `true`, the value will be rounded to a multiple of {@link customArrowStep} when interacting with the arrow buttons. Otherwise, increments the value by {@link customArrowStep} and then rounds it according to {@link Range.step}.
+     */
+    get customArrowRound(): boolean { return _C(this, 7864) as boolean; }
+    set customArrowRound(v: boolean) { _C(this, 11000, v); }
+
+    /**
+     * If `true`, the {@link SpinBox} will select the whole text when the {@link LineEdit} gains focus. Clicking the up and down arrows won't trigger this behavior.
+     */
+    get selectAllOnFocus(): boolean { return _C(this, 8285) as boolean; }
+    set selectAllOnFocus(v: boolean) { _C(this, 12684, v); }
+
+    static readonly name = _R(726, SpinBox);
+}

package/gen/classes/SplineIK3D.ts

@@ -0,0 +1,70 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { ChainIK3D } from './ChainIK3D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+
+/**
+ * A {@link SkeletonModifier3D} for aligning bones along a {@link Path3D}. The smoothness of the fitting depends on the {@link Curve3D.bakeInterval}.
+ * If you want the {@link Path3D} to attach to a specific bone, it is recommended to place a {@link ModifierBoneTarget3D} before the {@link SplineIK3D} in the {@link SkeletonModifier3D} list (children of the {@link Skeleton3D}), and then place a {@link Path3D} as the {@link ModifierBoneTarget3D}'s child.
+ * Bone twist is determined based on the {@link Curve3D.getPointTilt}.
+ * If the root bone joint and the start point of the {@link Curve3D} are separated, it assumes that there is a linear line segment between them. This means that the vector pointing toward the start point of the {@link Curve3D} takes precedence over the shortest intersection point along the {@link Curve3D}.
+ * If the end bone joint exceeds the path length, it is bent as close as possible to the end point of the {@link Curve3D}.
+ * **Note:** All the methods in this class take an `index` parameter. This parameter specifies which setting list entry to return if the IK has multiple entries (e.g. `settings/<index>/root_bone_name`).
+ */
+export class SplineIK3D extends ChainIK3D {
+    constructor(name = 727) { super(name); }
+
+    /**
+     * Sets the node path of the {@link Path3D} which is describing the path.
+     */
+    setPath3d(index: number, path3d: NodePath): void { _C(this, 12272, index, path3d); }
+
+    /**
+     * Returns the node path of the {@link Path3D} which is describing the path.
+     */
+    getPath3d(index: number): NodePath { return _C(this, 5841, index) as NodePath; }
+
+    /**
+     * Sets if the tilt property of the {@link Curve3D} should affect the bone twist.
+     */
+    setTiltEnabled(index: number, enabled: boolean): void { _C(this, 13080, index, enabled); }
+
+    /**
+     * Returns if the tilt property of the {@link Curve3D} affects the bone twist.
+     */
+    isTiltEnabled(index: number): boolean { return _C(this, 8364, index) as boolean; }
+
+    /**
+     * If `size` is greater than `0`, the tilt is interpolated between `size` start bones from the start point of the {@link Curve3D} when they are apart.
+     * If `size` is equal `0`, the tilts between the root bone head and the start point of the {@link Curve3D} are unified with a tilt of the start point of the {@link Curve3D}.
+     * If `size` is less than `0`, the tilts between the root bone and the start point of the {@link Curve3D} are `0.0`.
+     */
+    setTiltFadeIn(index: number, size: number): void { _C(this, 13081, index, size); }
+
+    /**
+     * Returns the tilt interpolation method used between the root bone and the start point of the {@link Curve3D} when they are apart. See also {@link setTiltFadeIn}.
+     */
+    getTiltFadeIn(index: number): number { return _C(this, 6805, index) as number; }
+
+    /**
+     * If `size` is greater than `0`, the tilt is interpolated between `size` end bones from the end point of the {@link Curve3D} when they are apart.
+     * If `size` is equal `0`, the tilts between the end bone tail and the end point of the {@link Curve3D} are unified with a tilt of the end point of the {@link Curve3D}.
+     * If `size` is less than `0`, the tilts between the end bone and the end point of the {@link Curve3D} are `0.0`.
+     */
+    setTiltFadeOut(index: number, size: number): void { _C(this, 13082, index, size); }
+
+    /**
+     * Returns the tilt interpolation method used between the end bone and the end point of the {@link Curve3D} when they are apart. See also {@link setTiltFadeOut}.
+     */
+    getTiltFadeOut(index: number): number { return _C(this, 6806, index) as number; }
+
+    /**
+     * The number of settings.
+     */
+    get settingCount(): number { return _C(this, 6350) as number; }
+    set settingCount(v: number) { _C(this, 12700, v); }
+
+    static readonly name = _R(727, SplineIK3D);
+}

package/gen/classes/SplitContainer.ts

@@ -0,0 +1,163 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Container } from './Container.ts';
+import type { GodotArray, PackedInt32Array, Signal } from '../heap-types/index.ts';
+import type { Control } from './Control.ts';
+
+/**
+ * A container that arranges child controls horizontally or vertically and creates grabbers between them. The grabbers can be dragged around to change the size relations between the child controls.
+ */
+export class SplitContainer extends Container {
+    constructor(name = 728) { super(name); }
+
+    /**
+     * Clamps the {@link splitOffsets} values to ensure they are within valid ranges and do not overlap with each other. When overlaps occur, this method prioritizes one split offset (at index `priorityIndex`) by clamping any overlapping split offsets to it.
+     */
+    clampSplitOffset(priorityIndex?: number /* = 0 */): void { _C(this, 2204, priorityIndex); }
+
+    /**
+     * Returns an {@link Array} of the drag area {@link Control}s. These are the interactable {@link Control} nodes between each child. For example, this can be used to add a pre-configured button to a drag area {@link Control} so that it rides along with the split bar. Try setting the {@link Button} anchors to `center` prior to the {@link Node.reparent} call.
+     *
+     * ```text
+     *
+     * $BarnacleButton.reparent($SplitContainer.get_drag_area_controls()[0])
+     *
+     * ```
+     *
+     * **Note:** The drag area {@link Control}s are drawn over the {@link SplitContainer}'s children, so {@link CanvasItem} draw objects called from a drag area and children added to it will also appear over the {@link SplitContainer}'s children. Try setting {@link Control.mouseFilter} of custom children to {@link Control.MOUSE_FILTER_IGNORE} to prevent blocking the mouse from dragging if desired.
+     * **Warning:** These are required internal nodes, removing or freeing them may cause a crash.
+     */
+    getDragAreaControls(): GodotArray<Control> { return _C(this, 4552) as GodotArray<Control>; }
+
+    /**
+     * Returns the drag area {@link Control}. For example, you can move a pre-configured button into the drag area {@link Control} so that it rides along with the split bar. Try setting the {@link Button} anchors to `center` prior to the `reparent()` call.
+     *
+     * ```text
+     *
+     * $BarnacleButton.reparent($SplitContainer.get_drag_area_control())
+     *
+     * ```
+     *
+     * **Note:** The drag area {@link Control} is drawn over the {@link SplitContainer}'s children, so {@link CanvasItem} draw objects called from the {@link Control} and children added to the {@link Control} will also appear over the {@link SplitContainer}'s children. Try setting {@link Control.mouseFilter} of custom children to {@link Control.MOUSE_FILTER_IGNORE} to prevent blocking the mouse from dragging if desired.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash.
+     */
+    getDragAreaControl(): Control { return _C(this, 4551) as Control; }
+
+    /**
+     * Offsets for each dragger in pixels. Each one is the offset of the split between the {@link Control} nodes before and after the dragger, with `0` being the default position. The default position is based on the {@link Control} nodes expand flags and minimum sizes. See {@link Control.sizeFlagsHorizontal}, {@link Control.sizeFlagsVertical}, and {@link Control.sizeFlagsStretchRatio}.
+     * If none of the {@link Control} nodes before the dragger are expanded, the default position will be at the start of the {@link SplitContainer}. If none of the {@link Control} nodes after the dragger are expanded, the default position will be at the end of the {@link SplitContainer}. If the dragger is in between expanded {@link Control} nodes, the default position will be in the middle, based on the {@link Control.sizeFlagsStretchRatio}s and minimum sizes.
+     * **Note:** If the split offsets cause {@link Control} nodes to overlap, the first split will take priority when resolving the positions.
+     */
+    get splitOffsets(): PackedInt32Array { return _C(this, 6500) as PackedInt32Array; }
+    set splitOffsets(v: PackedInt32Array) { _C(this, 12843, v); }
+
+    /**
+     * If `true`, the draggers will be disabled and the children will be sized as if all {@link splitOffsets} were `0`.
+     */
+    get collapsed(): boolean { return _C(this, 7837) as boolean; }
+    set collapsed(v: boolean) { _C(this, 10881, v); }
+
+    /**
+     * Enables or disables split dragging.
+     */
+    get draggingEnabled(): boolean { return _C(this, 7901) as boolean; }
+    set draggingEnabled(v: boolean) { _C(this, 11180, v); }
+
+    /**
+     * Determines the dragger's visibility. This property does not determine whether dragging is enabled or not. Use {@link draggingEnabled} for that.
+     */
+    get draggerVisibility(): DraggerVisibility { return _C(this, 4563) as DraggerVisibility; }
+    set draggerVisibility(v: DraggerVisibility) { _C(this, 11179, v); }
+
+    /**
+     * If `true`, the {@link SplitContainer} will arrange its children vertically, rather than horizontally.
+     * Can't be changed when using {@link HSplitContainer} and {@link VSplitContainer}.
+     */
+    get vertical(): boolean { return _C(this, 8447) as boolean; }
+    set vertical(v: boolean) { _C(this, 13302, v); }
+
+    /**
+     * If `true`, a touch-friendly drag handle will be enabled for better usability on smaller screens. Unlike the standard grabber, this drag handle overlaps the {@link SplitContainer}'s children and does not affect their minimum separation. The standard grabber will no longer be drawn when this option is enabled.
+     */
+    get touchDraggerEnabled(): boolean { return _C(this, 8368) as boolean; }
+    set touchDraggerEnabled(v: boolean) { _C(this, 13119, v); }
+
+    /**
+     * Adds extra draggers at the intersection of the draggers of two SplitContainers to allow dragging both at once. This must be set to `true` for both SplitContainers, and one needs to be a descendant of the other. They also must be orthogonal (their {@link vertical} are different) and the descendant must be next to at least one of the ancestor's draggers (within {@link minimum_grab_thickness}).
+     */
+    get dragNestedIntersections(): boolean { return _C(this, 7902) as boolean; }
+    set dragNestedIntersections(v: boolean) { _C(this, 11172, v); }
+
+    /**
+     * Reduces the size of the drag area and split bar {@link split_bar_background} at the beginning of the container.
+     */
+    get dragAreaMarginBegin(): number { return _C(this, 4553) as number; }
+    set dragAreaMarginBegin(v: number) { _C(this, 11163, v); }
+
+    /**
+     * Reduces the size of the drag area and split bar {@link split_bar_background} at the end of the container.
+     */
+    get dragAreaMarginEnd(): number { return _C(this, 4554) as number; }
+    set dragAreaMarginEnd(v: number) { _C(this, 11164, v); }
+
+    /**
+     * Shifts the drag area in the axis of the container to prevent the drag area from overlapping the {@link ScrollBar} or other selectable {@link Control} of a child node.
+     */
+    get dragAreaOffset(): number { return _C(this, 4555) as number; }
+    set dragAreaOffset(v: number) { _C(this, 11165, v); }
+
+    /**
+     * Highlights the drag area {@link Rect2} so you can see where it is during development. The drag area is gold if {@link draggingEnabled} is `true`, and red if `false`.
+     */
+    get dragAreaHighlightInEditor(): boolean { return _C(this, 7894) as boolean; }
+    set dragAreaHighlightInEditor(v: boolean) { _C(this, 11162, v); }
+
+    /**
+     * The first element of {@link splitOffsets}.
+     */
+    get splitOffset(): number { return _C(this, 6499) as number; }
+    set splitOffset(v: number) { _C(this, 12842, v); }
+
+    /**
+     * Emitted when any dragger is dragged by user.
+     */
+    get dragged(): Signal<(offset: number) => void> { return _G(this, 2899) as Signal<(offset: number) => void>; }
+    set dragged(v: ((offset: number) => void) | null) { _G(this, 2899, v); }
+
+    /**
+     * Emitted when the user starts dragging.
+     */
+    get dragStarted(): Signal<() => void> { return _G(this, 2893) as Signal<() => void>; }
+    set dragStarted(v: (() => void) | null) { _G(this, 2893, v); }
+
+    /**
+     * Emitted when the user ends dragging.
+     */
+    get dragEnded(): Signal<() => void> { return _G(this, 2886) as Signal<() => void>; }
+    set dragEnded(v: (() => void) | null) { _G(this, 2886, v); }
+
+    static readonly name = _R(728, SplitContainer);
+}
+
+export const DraggerVisibility = {
+    /**
+     * The split dragger icon is always visible when {@link autohide} is `false`, otherwise visible only when the cursor hovers it.
+     * The size of the grabber icon determines the minimum {@link separation}.
+     * The dragger icon is automatically hidden if the length of the grabber icon is longer than the split bar.
+     */
+    DRAGGER_VISIBLE: 0,
+    /**
+     * The split dragger icon is never visible regardless of the value of {@link autohide}.
+     * The size of the grabber icon determines the minimum {@link separation}.
+     */
+    DRAGGER_HIDDEN: 1,
+    /**
+     * The split dragger icon is not visible, and the split bar is collapsed to zero thickness.
+     */
+    DRAGGER_HIDDEN_COLLAPSED: 2,
+} as const;
+
+export type DraggerVisibility = (typeof DraggerVisibility)[keyof typeof DraggerVisibility];
+

package/gen/classes/SpotLight3D.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Light3D } from './Light3D.ts';
+
+/**
+ * A Spotlight is a type of {@link Light3D} node that emits lights in a specific direction, in the shape of a cone. The light is attenuated through the distance. This attenuation can be configured by changing the energy, radius and attenuation parameters of {@link Light3D}.
+ * Light is emitted in the -Z direction of the node's global basis. For an unrotated light, this means that the light is emitted forwards, illuminating the front side of a 3D model (see {@link Vector3.FORWARD} and {@link Vector3.MODEL_FRONT}).
+ * **Note:** When using the Mobile rendering method, only 8 spot lights can be displayed on each mesh resource. Attempting to display more than 8 spot lights on a single mesh resource will result in spot lights flickering in and out as the camera moves. When using the Compatibility rendering method, only 8 spot lights can be displayed on each mesh resource by default, but this can be increased by adjusting {@link ProjectSettings.rendering/limits/opengl/maxLightsPerObject}.
+ * **Note:** When using the Mobile or Compatibility rendering methods, spot lights will only correctly affect meshes whose visibility AABB intersects with the light's AABB. If using a shader to deform the mesh in a way that makes it go outside its AABB, {@link GeometryInstance3D.extraCullMargin} must be increased on the mesh. Otherwise, the light may not be visible on the mesh.
+ */
+export class SpotLight3D extends Light3D {
+    constructor(name = 729) { super(name); }
+
+    /**
+     * The maximal range that can be reached by the spotlight. Note that the effectively lit area may appear to be smaller depending on the {@link spotAttenuation} in use. No matter the {@link spotAttenuation} in use, the light will never reach anything outside this range.
+     * **Note:** {@link spotRange} is not affected by {@link Node3D.scale} (the light's scale or its parent's scale).
+     */
+    get spotRange(): number { return _C(this, 5809, 4) as number; }
+    set spotRange(v: number) { _C(this, 12248, 4, v); }
+
+    /**
+     * Controls the distance attenuation function for spotlights.
+     * A value of `0.0` will maintain a constant brightness through most of the range, but smoothly attenuate the light at the edge of the range. Use a value of `2.0` for physically accurate lights as it results in the proper inverse square attenutation.
+     * **Note:** Setting attenuation to `2.0` or higher may result in distant objects receiving minimal light, even within range. For example, with a range of `4096`, an object at `100` units is attenuated by a factor of `0.0001`. With a default brightness of `1`, the light would not be visible at that distance.
+     * **Note:** Using negative or values higher than `10.0` may lead to unexpected results.
+     */
+    get spotAttenuation(): number { return _C(this, 5809, 6) as number; }
+    set spotAttenuation(v: number) { _C(this, 12248, 6, v); }
+
+    /**
+     * The spotlight's angle in degrees. This is the angular radius, meaning the angle from the -Z axis, the cone's center, to the edge of the cone. The default angular radius of 45 degrees corresponds to a cone with an angular diameter of 90 degrees.
+     * **Note:** {@link spotAngle} is not affected by {@link Node3D.scale} (the light's scale or its parent's scale).
+     */
+    get spotAngle(): number { return _C(this, 5809, 7) as number; }
+    set spotAngle(v: number) { _C(this, 12248, 7, v); }
+
+    /**
+     * The spotlight's *angular* attenuation curve. See also {@link spotAttenuation}.
+     */
+    get spotAngleAttenuation(): number { return _C(this, 5809, 8) as number; }
+    set spotAngleAttenuation(v: number) { _C(this, 12248, 8, v); }
+
+    static readonly name = _R(729, SpotLight3D);
+}

package/gen/classes/SpringArm3D.ts

@@ -0,0 +1,64 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Shape3D } from './Shape3D.ts';
+
+/**
+ * {@link SpringArm3D} casts a ray or a shape along its Z axis and moves all its direct children to the collision point, with an optional margin. This is useful for 3rd person cameras that move closer to the player when inside a tight space (you may need to exclude the player's collider from the {@link SpringArm3D}'s collision check).
+ */
+export class SpringArm3D extends Node3D {
+    constructor(name = 730) { super(name); }
+
+    /**
+     * Returns the spring arm's current length.
+     */
+    getHitLength(): number { return _C(this, 5041) as number; }
+
+    /**
+     * Adds the {@link PhysicsBody3D} object with the given {@link RID} to the list of {@link PhysicsBody3D} objects excluded from the collision check.
+     */
+    addExcludedObject(RID: RID): void { _C(this, 1214, RID); }
+
+    /**
+     * Removes the given {@link RID} from the list of {@link PhysicsBody3D} objects excluded from the collision check.
+     */
+    removeExcludedObject(RID: RID): boolean { return _C(this, 9910, RID) as boolean; }
+
+    /**
+     * Clears the list of {@link PhysicsBody3D} objects excluded from the collision check.
+     */
+    clearExcludedObjects(): void { _C(this, 2264); }
+
+    /**
+     * The layers against which the collision check will be done. See [Collision layers and masks]($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+     */
+    get collisionMask(): number { return _C(this, 4205) as number; }
+    set collisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * The {@link Shape3D} to use for the SpringArm3D.
+     * When the shape is set, the SpringArm3D will cast the {@link Shape3D} on its z axis instead of performing a ray cast.
+     */
+    get shape(): Shape3D { return _C(this, 6370) as Shape3D; }
+    set shape(v: Shape3D) { _C(this, 12717, v); }
+
+    /**
+     * The maximum extent of the SpringArm3D. This is used as a length for both the ray and the shape cast used internally to calculate the desired position of the SpringArm3D's child nodes.
+     * To know more about how to perform a shape cast or a ray cast, please consult the {@link PhysicsDirectSpaceState3D} documentation.
+     */
+    get springLength(): number { return _C(this, 5331) as number; }
+    set springLength(v: number) { _C(this, 11891, v); }
+
+    /**
+     * When the collision check is made, a candidate length for the SpringArm3D is given.
+     * The margin is then subtracted to this length and the translation is applied to the child objects of the SpringArm3D.
+     * This margin is useful for when the SpringArm3D has a {@link Camera3D} as a child node: without the margin, the {@link Camera3D} would be placed on the exact point of collision, while with the margin the {@link Camera3D} would be placed close to the point of collision.
+     */
+    get margin(): number { return _C(this, 5441) as number; }
+    set margin(v: number) { _C(this, 11969, v); }
+
+    static readonly name = _R(730, SpringArm3D);
+}

package/gen/classes/SpringBoneCollision3D.ts

@@ -0,0 +1,48 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { Quaternion, Vector3 } from '../value-types/index.ts';
+import type { Skeleton3D } from './Skeleton3D.ts';
+
+/**
+ * A collision can be a child of {@link SpringBoneSimulator3D}. If it is not a child of {@link SpringBoneSimulator3D}, it has no effect.
+ * The colliding and sliding are done in the {@link SpringBoneSimulator3D}'s modification process in order of its collision list which is set by {@link SpringBoneSimulator3D.setCollisionPath}. If {@link SpringBoneSimulator3D.areAllChildCollisionsEnabled} is `true`, the order matches {@link SceneTree}.
+ * If {@link bone} is set, it synchronizes with the bone pose of the ancestor {@link Skeleton3D}, which is done in before the {@link SpringBoneSimulator3D}'s modification process as the pre-process.
+ * **Warning:** A scaled {@link SpringBoneCollision3D} will likely not behave as expected. Make sure that the parent {@link Skeleton3D} and its bones are not scaled.
+ */
+export class SpringBoneCollision3D extends Node3D {
+    constructor(name = 731) { super(name); }
+
+    /**
+     * Get parent {@link Skeleton3D} node of the parent {@link SpringBoneSimulator3D} if found.
+     */
+    getSkeleton(): Skeleton3D { return _C(this, 6405) as Skeleton3D; }
+
+    /**
+     * The name of the attached bone.
+     */
+    get boneName(): string { return _C(this, 3972) as string; }
+    set boneName(v: string) { _C(this, 10710, v); }
+
+    /**
+     * The index of the attached bone.
+     */
+    get bone(): number { return _C(this, 3953) as number; }
+    set bone(v: number) { _C(this, 10698, v); }
+
+    /**
+     * The offset of the position from {@link Skeleton3D}'s {@link bone} pose position.
+     */
+    get positionOffset(): Vector3 { return _C(this, 5975) as Vector3; }
+    set positionOffset(v: Vector3) { _C(this, 12383, v); }
+
+    /**
+     * The offset of the rotation from {@link Skeleton3D}'s {@link bone} pose rotation.
+     */
+    get rotationOffset(): Quaternion { return _C(this, 6212) as Quaternion; }
+    set rotationOffset(v: Quaternion) { _C(this, 12586, v); }
+
+    static readonly name = _R(731, SpringBoneCollision3D);
+}

package/gen/classes/SpringBoneCollisionCapsule3D.ts

@@ -0,0 +1,40 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SpringBoneCollision3D } from './SpringBoneCollision3D.ts';
+
+/**
+ * A capsule shape collision that interacts with {@link SpringBoneSimulator3D}.
+ */
+export class SpringBoneCollisionCapsule3D extends SpringBoneCollision3D {
+    constructor(name = 732) { super(name); }
+
+    /**
+     * The capsule's radius.
+     * **Note:** The {@link radius} of a capsule cannot be greater than half of its {@link height}. Otherwise, the capsule becomes a sphere. If the {@link radius} is greater than half of the {@link height}, the properties adjust to a valid value.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * The capsule's full height, including the hemispheres.
+     * **Note:** The {@link height} of a capsule must be at least twice its {@link radius}. Otherwise, the capsule becomes a sphere. If the {@link height} is less than twice the {@link radius}, the properties adjust to a valid value.
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    /**
+     * The capsule's height, excluding the hemispheres. This is the height of the central cylindrical part in the middle of the capsule, and is the distance between the centers of the two hemispheres. This is a wrapper for {@link height}.
+     */
+    get midHeight(): number { return _C(this, 5531) as number; }
+    set midHeight(v: number) { _C(this, 12041, v); }
+
+    /**
+     * If `true`, the collision acts to trap the joint within the collision.
+     */
+    get inside(): boolean { return _C(this, 8031) as boolean; }
+    set inside(v: boolean) { _C(this, 11723, v); }
+
+    static readonly name = _R(732, SpringBoneCollisionCapsule3D);
+}

package/gen/classes/SpringBoneCollisionPlane3D.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SpringBoneCollision3D } from './SpringBoneCollision3D.ts';
+
+/**
+ * An infinite plane collision that interacts with {@link SpringBoneSimulator3D}. It is an infinite size XZ plane, and the +Y direction is treated as normal.
+ */
+export class SpringBoneCollisionPlane3D extends SpringBoneCollision3D {
+    constructor(name = 733) { super(name); }
+
+    static readonly name = _R(733, SpringBoneCollisionPlane3D);
+}

package/gen/classes/SpringBoneCollisionSphere3D.ts

@@ -0,0 +1,26 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SpringBoneCollision3D } from './SpringBoneCollision3D.ts';
+
+/**
+ * A sphere shape collision that interacts with {@link SpringBoneSimulator3D}.
+ */
+export class SpringBoneCollisionSphere3D extends SpringBoneCollision3D {
+    constructor(name = 734) { super(name); }
+
+    /**
+     * The sphere's radius.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * If `true`, the collision acts to trap the joint within the collision.
+     */
+    get inside(): boolean { return _C(this, 8031) as boolean; }
+    set inside(v: boolean) { _C(this, 11723, v); }
+
+    static readonly name = _R(734, SpringBoneCollisionSphere3D);
+}