@ringozz/godot 0.1.0

package/gen/classes/GraphFrame.ts

@@ -0,0 +1,66 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { GraphElement } from './GraphElement.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+import type { HBoxContainer } from './HBoxContainer.ts';
+
+/**
+ * GraphFrame is a special {@link GraphElement} to which other {@link GraphElement}s can be attached. It can be configured to automatically resize to enclose all attached {@link GraphElement}s. If the frame is moved, all the attached {@link GraphElement}s inside it will be moved as well.
+ * A GraphFrame is always kept behind the connection layer and other {@link GraphElement}s inside a {@link GraphEdit}.
+ */
+export class GraphFrame extends GraphElement {
+    constructor(name = 319) { super(name); }
+
+    /**
+     * Returns the {@link HBoxContainer} used for the title bar, only containing a {@link Label} for displaying the title by default.
+     * This can be used to add custom controls to the title bar such as option or close buttons.
+     */
+    getTitlebarHbox(): HBoxContainer { return _C(this, 6834) as HBoxContainer; }
+
+    /**
+     * Title of the frame.
+     */
+    get title(): string { return _C(this, 6829) as string; }
+    set title(v: string) { _C(this, 13099, v); }
+
+    /**
+     * If `true`, the frame's rect will be adjusted automatically to enclose all attached {@link GraphElement}s.
+     */
+    get autoshrinkEnabled(): boolean { return _C(this, 7778) as boolean; }
+    set autoshrinkEnabled(v: boolean) { _C(this, 10591, v); }
+
+    /**
+     * The margin around the attached nodes that is used to calculate the size of the frame when {@link autoshrinkEnabled} is `true`.
+     */
+    get autoshrinkMargin(): number { return _C(this, 3846) as number; }
+    set autoshrinkMargin(v: number) { _C(this, 10592, v); }
+
+    /**
+     * The margin inside the frame that can be used to drag the frame.
+     */
+    get dragMargin(): number { return _C(this, 4559) as number; }
+    set dragMargin(v: number) { _C(this, 11171, v); }
+
+    /**
+     * If `true`, the tint color will be used to tint the frame.
+     */
+    get tintColorEnabled(): boolean { return _C(this, 8365) as boolean; }
+    set tintColorEnabled(v: boolean) { _C(this, 13092, v); }
+
+    /**
+     * The color of the frame when {@link tintColorEnabled} is `true`.
+     */
+    get tintColor(): Color { return _C(this, 6822) as Color; }
+    set tintColor(v: Color) { _C(this, 13091, v); }
+
+    /**
+     * Emitted when {@link autoshrinkEnabled} or {@link autoshrinkMargin} changes.
+     */
+    get autoshrinkChanged(): Signal<() => void> { return _G(this, 1664) as Signal<() => void>; }
+    set autoshrinkChanged(v: (() => void) | null) { _G(this, 1664, v); }
+
+    static readonly name = _R(319, GraphFrame);
+}

package/gen/classes/GraphNode.ts

@@ -0,0 +1,241 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { GraphElement } from './GraphElement.ts';
+import type { Signal, Variant } from '../heap-types/index.ts';
+import type { Color, Vector2, Vector2i } from '../value-types/index.ts';
+import type { FocusMode } from './Control.ts';
+import type { HBoxContainer } from './HBoxContainer.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * {@link GraphNode} allows to create nodes for a {@link GraphEdit} graph with customizable content based on its child controls. {@link GraphNode} is derived from {@link Container} and it is responsible for placing its children on screen. This works similar to {@link VBoxContainer}. Children, in turn, provide {@link GraphNode} with so-called slots, each of which can have a connection port on either side.
+ * Each {@link GraphNode} slot is defined by its index and can provide the node with up to two ports: one on the left, and one on the right. By convention the left port is also referred to as the **input port** and the right port is referred to as the **output port**. Each port can be enabled and configured individually, using different type and color. The type is an arbitrary value that you can define using your own considerations. The parent {@link GraphEdit} will receive this information on each connect and disconnect request.
+ * Slots can be configured in the Inspector dock once you add at least one child {@link Control}. The properties are grouped by each slot's index in the "Slot" section.
+ * **Note:** While GraphNode is set up using slots and slot indices, connections are made between the ports which are enabled. Because of that {@link GraphEdit} uses the port's index and not the slot's index. You can use {@link getInputPortSlot} and {@link getOutputPortSlot} to get the slot index from the port index.
+ */
+export class GraphNode extends GraphElement {
+    constructor(name = 320) { super(name); }
+
+    /**
+     * Returns the {@link HBoxContainer} used for the title bar, only containing a {@link Label} for displaying the title by default. This can be used to add custom controls to the title bar such as option or close buttons.
+     */
+    getTitlebarHbox(): HBoxContainer { return _C(this, 6834) as HBoxContainer; }
+
+    /**
+     * Sets properties of the slot with the given `slotIndex`.
+     * If `enableLeftPort`/`enableRightPort` is `true`, a port will appear and the slot will be able to be connected from this side.
+     * With `typeLeft`/`typeRight` an arbitrary type can be assigned to each port. Two ports can be connected if they share the same type, or if the connection between their types is allowed in the parent {@link GraphEdit} (see {@link GraphEdit.addValidConnectionType}). Keep in mind that the {@link GraphEdit} has the final say in accepting the connection. Type compatibility simply allows the {@link GraphEdit.connection_request} signal to be emitted.
+     * Ports can be further customized using `colorLeft`/`colorRight` and `customIconLeft`/`customIconRight`. The color parameter adds a tint to the icon. The custom icon can be used to override the default port dot.
+     * Additionally, `drawStylebox` can be used to enable or disable drawing of the background stylebox for each slot. See {@link slot}.
+     * Individual properties can also be set using one of the `set_slot_*` methods.
+     * **Note:** This method only sets properties of the slot. To create the slot itself, add a {@link Control}-derived child to the GraphNode.
+     */
+    setSlot(slotIndex: number, enableLeftPort: boolean, typeLeft: number, colorLeft: Color, enableRightPort: boolean, typeRight: number, colorRight: Color, customIconLeft?: Texture2D /* = null */, customIconRight?: Texture2D /* = null */, drawStylebox?: boolean /* = true */): void { _C(this, 12782, slotIndex, enableLeftPort, typeLeft, colorLeft, enableRightPort, typeRight, colorRight, customIconLeft, customIconRight, drawStylebox); }
+
+    /**
+     * Disables the slot with the given `slotIndex`. This will remove the corresponding input and output port from the GraphNode.
+     */
+    clearSlot(slotIndex: number): void { _C(this, 2295, slotIndex); }
+
+    /**
+     * Disables all slots of the GraphNode. This will remove all input/output ports from the GraphNode.
+     */
+    clearAllSlots(): void { _C(this, 2234); }
+
+    /**
+     * Returns `true` if left (input) side of the slot with the given `slotIndex` is enabled.
+     */
+    isSlotEnabledLeft(slotIndex: number): boolean { return _C(this, 8322, slotIndex) as boolean; }
+
+    /**
+     * Toggles the left (input) side of the slot with the given `slotIndex`. If `enable` is `true`, a port will appear on the left side and the slot will be able to be connected from this side.
+     */
+    setSlotEnabledLeft(slotIndex: number, enable: boolean): void { _C(this, 12788, slotIndex, enable); }
+
+    /**
+     * Sets the left (input) type of the slot with the given `slotIndex` to `type`. If the value is negative, all connections will be disallowed to be created via user inputs.
+     */
+    setSlotTypeLeft(slotIndex: number, type: number): void { _C(this, 12792, slotIndex, type); }
+
+    /**
+     * Returns the left (input) type of the slot with the given `slotIndex`.
+     */
+    getSlotTypeLeft(slotIndex: number): number { return _C(this, 6441, slotIndex) as number; }
+
+    /**
+     * Sets the {@link Color} of the left (input) side of the slot with the given `slotIndex` to `color`.
+     */
+    setSlotColorLeft(slotIndex: number, color: Color): void { _C(this, 12783, slotIndex, color); }
+
+    /**
+     * Returns the left (input) {@link Color} of the slot with the given `slotIndex`.
+     */
+    getSlotColorLeft(slotIndex: number): Color { return _C(this, 6435, slotIndex) as Color; }
+
+    /**
+     * Sets the custom {@link Texture2D} of the left (input) side of the slot with the given `slotIndex` to `customIcon`.
+     */
+    setSlotCustomIconLeft(slotIndex: number, customIcon: Texture2D): void { _C(this, 12785, slotIndex, customIcon); }
+
+    /**
+     * Returns the left (input) custom {@link Texture2D} of the slot with the given `slotIndex`.
+     */
+    getSlotCustomIconLeft(slotIndex: number): Texture2D { return _C(this, 6437, slotIndex) as Texture2D; }
+
+    /**
+     * Sets the custom metadata for the left (input) side of the slot with the given `slotIndex` to `value`.
+     */
+    setSlotMetadataLeft(slotIndex: number, value: Variant): void { _C(this, 12790, slotIndex, value); }
+
+    /**
+     * Returns the left (input) metadata of the slot with the given `slotIndex`.
+     */
+    getSlotMetadataLeft(slotIndex: number): Variant { return _C(this, 6439, slotIndex) as Variant; }
+
+    /**
+     * Returns `true` if right (output) side of the slot with the given `slotIndex` is enabled.
+     */
+    isSlotEnabledRight(slotIndex: number): boolean { return _C(this, 8323, slotIndex) as boolean; }
+
+    /**
+     * Toggles the right (output) side of the slot with the given `slotIndex`. If `enable` is `true`, a port will appear on the right side and the slot will be able to be connected from this side.
+     */
+    setSlotEnabledRight(slotIndex: number, enable: boolean): void { _C(this, 12789, slotIndex, enable); }
+
+    /**
+     * Sets the right (output) type of the slot with the given `slotIndex` to `type`. If the value is negative, all connections will be disallowed to be created via user inputs.
+     */
+    setSlotTypeRight(slotIndex: number, type: number): void { _C(this, 12793, slotIndex, type); }
+
+    /**
+     * Returns the right (output) type of the slot with the given `slotIndex`.
+     */
+    getSlotTypeRight(slotIndex: number): number { return _C(this, 6442, slotIndex) as number; }
+
+    /**
+     * Sets the {@link Color} of the right (output) side of the slot with the given `slotIndex` to `color`.
+     */
+    setSlotColorRight(slotIndex: number, color: Color): void { _C(this, 12784, slotIndex, color); }
+
+    /**
+     * Returns the right (output) {@link Color} of the slot with the given `slotIndex`.
+     */
+    getSlotColorRight(slotIndex: number): Color { return _C(this, 6436, slotIndex) as Color; }
+
+    /**
+     * Sets the custom {@link Texture2D} of the right (output) side of the slot with the given `slotIndex` to `customIcon`.
+     */
+    setSlotCustomIconRight(slotIndex: number, customIcon: Texture2D): void { _C(this, 12786, slotIndex, customIcon); }
+
+    /**
+     * Returns the right (output) custom {@link Texture2D} of the slot with the given `slotIndex`.
+     */
+    getSlotCustomIconRight(slotIndex: number): Texture2D { return _C(this, 6438, slotIndex) as Texture2D; }
+
+    /**
+     * Sets the custom metadata for the right (output) side of the slot with the given `slotIndex` to `value`.
+     */
+    setSlotMetadataRight(slotIndex: number, value: Variant): void { _C(this, 12791, slotIndex, value); }
+
+    /**
+     * Returns the right (output) metadata of the slot with the given `slotIndex`.
+     */
+    getSlotMetadataRight(slotIndex: number): Variant { return _C(this, 6440, slotIndex) as Variant; }
+
+    /**
+     * Returns `true` if the background {@link StyleBox} of the slot with the given `slotIndex` is drawn.
+     */
+    isSlotDrawStylebox(slotIndex: number): boolean { return _C(this, 8321, slotIndex) as boolean; }
+
+    /**
+     * Toggles the background {@link StyleBox} of the slot with the given `slotIndex`.
+     */
+    setSlotDrawStylebox(slotIndex: number, enable: boolean): void { _C(this, 12787, slotIndex, enable); }
+
+    /**
+     * Returns the number of slots with an enabled input port.
+     */
+    getInputPortCount(): number { return _C(this, 5119) as number; }
+
+    /**
+     * Returns the position of the input port with the given `portIdx`.
+     */
+    getInputPortPosition(portIdx: number): Vector2 { return _C(this, 5121, portIdx) as Vector2; }
+
+    /**
+     * Returns the type of the input port with the given `portIdx`.
+     */
+    getInputPortType(portIdx: number): number { return _C(this, 5123, portIdx) as number; }
+
+    /**
+     * Returns the {@link Color} of the input port with the given `portIdx`.
+     */
+    getInputPortColor(portIdx: number): Color { return _C(this, 5118, portIdx) as Color; }
+
+    /**
+     * Returns the corresponding slot index of the input port with the given `portIdx`.
+     */
+    getInputPortSlot(portIdx: number): number { return _C(this, 5122, portIdx) as number; }
+
+    /**
+     * Returns the number of slots with an enabled output port.
+     */
+    getOutputPortCount(): number { return _C(this, 5767) as number; }
+
+    /**
+     * Returns the position of the output port with the given `portIdx`.
+     */
+    getOutputPortPosition(portIdx: number): Vector2 { return _C(this, 5769, portIdx) as Vector2; }
+
+    /**
+     * Returns the type of the output port with the given `portIdx`.
+     */
+    getOutputPortType(portIdx: number): number { return _C(this, 5771, portIdx) as number; }
+
+    /**
+     * Returns the {@link Color} of the output port with the given `portIdx`.
+     */
+    getOutputPortColor(portIdx: number): Color { return _C(this, 5766, portIdx) as Color; }
+
+    /**
+     * Returns the corresponding slot index of the output port with the given `portIdx`.
+     */
+    getOutputPortSlot(portIdx: number): number { return _C(this, 5770, portIdx) as number; }
+
+    /**
+     * The text displayed in the GraphNode's title bar.
+     */
+    get title(): string { return _C(this, 6829) as string; }
+    set title(v: string) { _C(this, 13099, v); }
+
+    /**
+     * If `true`, you can connect ports with different types, even if the connection was not explicitly allowed in the parent {@link GraphEdit}.
+     */
+    get ignoreInvalidConnectionType(): boolean { return _C(this, 8008) as boolean; }
+    set ignoreInvalidConnectionType(v: boolean) { _C(this, 11663, v); }
+
+    /**
+     * Determines how connection slots can be focused.
+     * - If set to {@link Control.FOCUS_CLICK}, connections can only be made with the mouse.
+     * - If set to {@link Control.FOCUS_ALL}, slots can also be focused using the {@link ProjectSettings.input/uiUp} and {@link ProjectSettings.input/uiDown} and connected using {@link ProjectSettings.input/uiLeft} and {@link ProjectSettings.input/uiRight} input actions.
+     * - If set to {@link Control.FOCUS_ACCESSIBILITY}, slot input actions are only enabled when the screen reader is active.
+     */
+    get slotsFocusMode(): FocusMode { return _C(this, 6443) as FocusMode; }
+    set slotsFocusMode(v: FocusMode) { _C(this, 12794, v); }
+
+    /**
+     * Emitted when any GraphNode's slot is updated.
+     */
+    get slotUpdated(): Signal<(slotIndex: number) => void> { return _G(this, 13666) as Signal<(slotIndex: number) => void>; }
+    set slotUpdated(v: ((slotIndex: number) => void) | null) { _G(this, 13666, v); }
+
+    /**
+     * Emitted when any slot's size might have changed.
+     */
+    get slotSizesChanged(): Signal<() => void> { return _G(this, 13665) as Signal<() => void>; }
+    set slotSizesChanged(v: (() => void) | null) { _G(this, 13665, v); }
+
+    static readonly name = _R(320, GraphNode);
+}

package/gen/classes/GridContainer.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Container } from './Container.ts';
+
+/**
+ * {@link GridContainer} arranges its child controls in a grid layout. The number of columns is specified by the {@link columns} property, whereas the number of rows depends on how many are needed for the child controls. The number of rows and columns is preserved for every size of the container.
+ * **Note:** {@link GridContainer} only works with child nodes inheriting from {@link Control}. It won't rearrange child nodes inheriting from {@link Node2D}.
+ */
+export class GridContainer extends Container {
+    constructor(name = 321) { super(name); }
+
+    /**
+     * The number of columns in the {@link GridContainer}. If modified, {@link GridContainer} reorders its Control-derived children to accommodate the new layout.
+     */
+    get columns(): number { return _C(this, 4241) as number; }
+    set columns(v: number) { _C(this, 10925, v); }
+
+    static readonly name = _R(321, GridContainer);
+}

package/gen/classes/GridMap.ts

@@ -0,0 +1,294 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { GodotArray, RID, Signal } from '../heap-types/index.ts';
+import type { AABB, Basis, Vector3, Vector3i } from '../value-types/index.ts';
+import type { MeshLibrary } from './MeshLibrary.ts';
+import type { PhysicsMaterial } from './PhysicsMaterial.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * GridMap lets you place meshes on a grid interactively. It works both from the editor and from scripts, which can help you create in-game level editors.
+ * GridMaps use a {@link MeshLibrary} which contains a list of tiles. Each tile is a mesh with materials plus optional collision and navigation shapes.
+ * A GridMap contains a collection of cells. Each grid cell refers to a tile in the {@link MeshLibrary}. All cells in the map have the same dimensions.
+ * Internally, a GridMap is split into a sparse collection of octants for efficient rendering and physics processing. Every octant has the same dimensions and can contain several cells.
+ * **Note:** GridMap doesn't extend {@link VisualInstance3D} and therefore can't be hidden or cull masked based on {@link VisualInstance3D.layers}. If you make a light not affect the first layer, the whole GridMap won't be lit by the light in question.
+ */
+export class GridMap extends Node3D {
+    constructor(name = 322) { super(name); }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link collisionMask}, given a `layerNumber` between 1 and 32.
+     */
+    setCollisionMaskValue(layerNumber: number, value: boolean): void { _C(this, 10895, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link collisionMask} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getCollisionMaskValue(layerNumber: number): boolean { return _C(this, 4206, layerNumber) as boolean; }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link collisionLayer}, given a `layerNumber` between 1 and 32.
+     */
+    setCollisionLayerValue(layerNumber: number, value: boolean): void { _C(this, 10893, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link collisionLayer} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getCollisionLayerValue(layerNumber: number): boolean { return _C(this, 4203, layerNumber) as boolean; }
+
+    /**
+     * Sets the {@link RID} of the navigation map this GridMap node should use for its cell baked navigation meshes.
+     */
+    setNavigationMap(navigationMap: RID): void { _C(this, 12120, navigationMap); }
+
+    /**
+     * Returns the {@link RID} of the navigation map this GridMap node uses for its cell baked navigation meshes.
+     * This function returns always the map set on the GridMap node and not the map on the NavigationServer. If the map is changed directly with the NavigationServer API the GridMap node will not be aware of the map change.
+     */
+    getNavigationMap(): RID { return _C(this, 5612) as RID; }
+
+    /**
+     * Sets the mesh index for the cell referenced by its grid coordinates.
+     * A negative item index such as {@link INVALID_CELL_ITEM} will clear the cell.
+     * Optionally, the item's orientation can be passed. For valid orientation values, see {@link getOrthogonalIndexFromBasis}.
+     */
+    setCellItem(position: Vector3i, item: number, orientation?: number /* = 0 */): void { _C(this, 10823, position, item, orientation); }
+
+    /**
+     * The {@link MeshLibrary} item index located at the given grid coordinates. If the cell is empty, {@link INVALID_CELL_ITEM} will be returned.
+     */
+    getCellItem(position: Vector3i): number { return _C(this, 4109, position) as number; }
+
+    /**
+     * The orientation of the cell at the given grid coordinates. `-1` is returned if the cell is empty.
+     */
+    getCellItemOrientation(position: Vector3i): number { return _C(this, 4111, position) as number; }
+
+    /**
+     * Returns the basis that gives the specified cell its orientation.
+     */
+    getCellItemBasis(position: Vector3i): Basis { return _C(this, 4110, position) as Basis; }
+
+    /**
+     * Returns one of 24 possible rotations that lie along the vectors (x,y,z) with each component being either -1, 0, or 1. For further details, refer to the Godot source code.
+     */
+    getBasisWithOrthogonalIndex(index: number): Basis { return _C(this, 3905, index) as Basis; }
+
+    /**
+     * This function considers a discretization of rotations into 24 points on unit sphere, lying along the vectors (x,y,z) with each component being either -1, 0, or 1, and returns the index (in the range from 0 to 23) of the point best representing the orientation of the object. For further details, refer to the Godot source code.
+     */
+    getOrthogonalIndexFromBasis(basis: Basis): number { return _C(this, 5750, basis) as number; }
+
+    /**
+     * Returns the map coordinates of the cell containing the given `localPosition`. If `localPosition` is in global coordinates, consider using {@link Node3D.toLocal} before passing it to this method. See also {@link mapToLocal}.
+     */
+    localToMap(localPosition: Vector3): Vector3i { return _C(this, 8694, localPosition) as Vector3i; }
+
+    /**
+     * Returns the position of a grid cell in the GridMap's local coordinate space. To convert the returned value into global coordinates, use {@link Node3D.toGlobal}. See also {@link localToMap}.
+     */
+    mapToLocal(mapPosition: Vector3i): Vector3 { return _C(this, 8782, mapPosition) as Vector3; }
+
+    /**
+     * This method does nothing.
+     */
+    resourceChanged(resource: Resource): void { _C(this, 10089, resource); }
+
+    /**
+     * Clear all cells.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns an array of {@link Vector3} with the non-empty cell coordinates in the grid map.
+     */
+    getUsedCells(): GodotArray<Vector3i> { return _C(this, 6988) as GodotArray<Vector3i>; }
+
+    /**
+     * Returns an array of all cells with the given item index specified in `item`.
+     */
+    getUsedCellsByItem(item: number): GodotArray<Vector3i> { return _C(this, 6990, item) as GodotArray<Vector3i>; }
+
+    /**
+     * Returns an array of {@link Vector3i}s with the octant coordinates of the non-empty octants in the grid map.
+     */
+    getUsedOctants(): GodotArray<Vector3i> { return _C(this, 6993) as GodotArray<Vector3i>; }
+
+    /**
+     * Returns an array of {@link Vector3i}s with the octant coordinates of the octants that use the specified `item` in the grid map.
+     */
+    getUsedOctantsByItem(item: number): GodotArray<Vector3i> { return _C(this, 6994, item) as GodotArray<Vector3i>; }
+
+    /**
+     * Returns an array of {@link Vector3i}s with the cell coordinates of non-empty cells inside the octant at `octantCoords`.
+     */
+    getUsedCellsInOctant(octantCoords: Vector3i): GodotArray<Vector3i> { return _C(this, 6991, octantCoords) as GodotArray<Vector3i>; }
+
+    /**
+     * Returns an array of {@link Vector3i}s with the cell coordinates of cells inside the octant at `octantCoords` that use the specified cell `item`.
+     */
+    getUsedCellsInOctantByItem(octantCoords: Vector3i, item: number): GodotArray<Vector3i> { return _C(this, 6992, octantCoords, item) as GodotArray<Vector3i>; }
+
+    /**
+     * Returns an array of {@link Vector3i} octant coordinates that are inside the given `bounds`, including octants that have no cells in use.
+     */
+    getOctantsInBounds(bounds: AABB): GodotArray<Vector3i> { return _C(this, 5698, bounds) as GodotArray<Vector3i>; }
+
+    /**
+     * Returns an array of {@link Vector3i}s with the octant coordinates of non-empty octants that are inside the local `bounds`.
+     */
+    getUsedOctantsInBounds(bounds: AABB): GodotArray<Vector3i> { return _C(this, 6995, bounds) as GodotArray<Vector3i>; }
+
+    /**
+     * Returns the {@link Vector3i} octant coordinates of the octant that the cell at `cellCoords` belongs to.
+     */
+    getOctantCoordsFromCellCoords(cellCoords: Vector3i): Vector3i { return _C(this, 5696, cellCoords) as Vector3i; }
+
+    /**
+     * Returns an array of {@link Transform3D} and {@link Mesh} references corresponding to the non-empty cells in the grid. The transforms are specified in local space. Even indices contain {@link Transform3D}s, while odd indices contain {@link Mesh}es related to the {@link Transform3D} in the index preceding it.
+     */
+    getMeshes(): GodotArray { return _C(this, 5517) as GodotArray; }
+
+    /**
+     * Returns an array of {@link ArrayMesh}es and {@link Transform3D} references of all bake meshes that exist within the current GridMap. Even indices contain {@link ArrayMesh}es, while odd indices contain {@link Transform3D}s that are always equal to {@link Transform3D.IDENTITY}.
+     * This method relies on the output of {@link makeBakedMeshes}, which will be called with `gen_lightmap_uv` set to `true` and `lightmap_uv_texel_size` set to `0.1` if it hasn't been called yet.
+     */
+    getBakeMeshes(): GodotArray { return _C(this, 3878) as GodotArray; }
+
+    /**
+     * Returns {@link RID} of a baked mesh with the given `idx`.
+     */
+    getBakeMeshInstance(idx: number): RID { return _C(this, 3877, idx) as RID; }
+
+    /**
+     * Clears all baked meshes. See {@link makeBakedMeshes}.
+     */
+    clearBakedMeshes(): void { _C(this, 2235); }
+
+    /**
+     * Generates a baked mesh that represents all meshes in the assigned {@link MeshLibrary} for use with {@link LightmapGI}. If `genLightmapUv` is `true`, UV2 data will be generated for each mesh currently used in the {@link GridMap}. Otherwise, only meshes that already have UV2 data present will be able to use baked lightmaps. When generating UV2, `lightmapUvTexelSize` controls the texel density for lightmaps, with lower values resulting in more detailed lightmaps. `lightmapUvTexelSize` is ignored if `genLightmapUv` is `false`. See also {@link getBakeMeshes}, which relies on the output of this method.
+     * **Note:** Calling this method will not actually bake lightmaps, as lightmap baking is performed using the {@link LightmapGI} node.
+     */
+    makeBakedMeshes(genLightmapUv?: boolean /* = false */, lightmapUvTexelSize?: number /* = 0.1 */): void { _C(this, 8726, genLightmapUv, lightmapUvTexelSize); }
+
+    /**
+     * The assigned {@link MeshLibrary}.
+     */
+    get meshLibrary(): MeshLibrary { return _C(this, 5514) as MeshLibrary; }
+    set meshLibrary(v: MeshLibrary) { _C(this, 12027, v); }
+
+    /**
+     * Overrides the default friction and bounce physics properties for the whole {@link GridMap}.
+     */
+    get physicsMaterial(): PhysicsMaterial { return _C(this, 5896) as PhysicsMaterial; }
+    set physicsMaterial(v: PhysicsMaterial) { _C(this, 12316, v); }
+
+    /**
+     * The dimensions of the grid's cells.
+     * This does not affect the size of the meshes. See {@link cellScale}.
+     */
+    get cellSize(): Vector3 { return _C(this, 4115) as Vector3; }
+    set cellSize(v: Vector3) { _C(this, 10829, v); }
+
+    /**
+     * The size of each octant measured in number of cells. This applies to all three axis.
+     */
+    get cellOctantSize(): number { return _C(this, 5697) as number; }
+    set cellOctantSize(v: number) { _C(this, 12167, v); }
+
+    /**
+     * If `true`, grid items are centered on the X axis.
+     */
+    get cellCenterX(): boolean { return _C(this, 4132) as boolean; }
+    set cellCenterX(v: boolean) { _C(this, 10844, v); }
+
+    /**
+     * If `true`, grid items are centered on the Y axis.
+     */
+    get cellCenterY(): boolean { return _C(this, 4133) as boolean; }
+    set cellCenterY(v: boolean) { _C(this, 10845, v); }
+
+    /**
+     * If `true`, grid items are centered on the Z axis.
+     */
+    get cellCenterZ(): boolean { return _C(this, 4134) as boolean; }
+    set cellCenterZ(v: boolean) { _C(this, 10846, v); }
+
+    /**
+     * The scale of the cell items.
+     * This does not affect the size of the grid cells themselves, only the items in them. This can be used to make cell items overlap their neighbors.
+     */
+    get cellScale(): number { return _C(this, 4113) as number; }
+    set cellScale(v: number) { _C(this, 10827, v); }
+
+    /**
+     * The physics layers this GridMap is in.
+     * GridMaps act as static bodies, meaning they aren't affected by gravity or other forces. They only affect other physics bodies that collide with them.
+     */
+    get collisionLayer(): number { return _C(this, 4202) as number; }
+    set collisionLayer(v: number) { _C(this, 10892, v); }
+
+    /**
+     * The physics layers this GridMap detects collisions in. 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 priority used to solve colliding when occurring penetration. The higher the priority is, the lower the penetration into the object will be. This can for example be used to prevent the player from breaking through the boundaries of a level.
+     */
+    get collisionPriority(): number { return _C(this, 4214) as number; }
+    set collisionPriority(v: number) { _C(this, 10902, v); }
+
+    /**
+     * Show or hide the {@link GridMap}'s collision shapes. If set to {@link DEBUG_VISIBILITY_MODE_DEFAULT}, this depends on the show collision debug settings.
+     */
+    get collisionVisibilityMode(): DebugVisibilityMode { return _C(this, 4218) as DebugVisibilityMode; }
+    set collisionVisibilityMode(v: DebugVisibilityMode) { _C(this, 10904, v); }
+
+    /**
+     * If `true`, this GridMap creates a navigation region for each cell that uses a {@link meshLibrary} item with a navigation mesh. The created navigation region will use the navigation layers bitmask assigned to the {@link MeshLibrary}'s item.
+     */
+    get bakeNavigation(): boolean { return _C(this, 7790) as boolean; }
+    set bakeNavigation(v: boolean) { _C(this, 10632, v); }
+
+    /**
+     * Invalid cell item that can be used in {@link setCellItem} to clear cells (or represent an empty cell in {@link getCellItem}).
+     */
+    static readonly INVALID_CELL_ITEM = -1;
+
+    /**
+     * Emitted when {@link cellSize} changes.
+     */
+    get cellSizeChanged(): Signal<(cellSize: Vector3) => void> { return _G(this, 2169) as Signal<(cellSize: Vector3) => void>; }
+    set cellSizeChanged(v: ((cellSize: Vector3) => void) | null) { _G(this, 2169, v); }
+
+    /**
+     * Emitted when the {@link MeshLibrary} of this GridMap changes.
+     */
+    get changed(): Signal<() => void> { return _G(this, 2190) as Signal<() => void>; }
+    set changed(v: (() => void) | null) { _G(this, 2190, v); }
+
+    static readonly name = _R(322, GridMap);
+}
+
+export const DebugVisibilityMode = {
+    /**
+     * Hide the collisions debug shapes in the editor, and use the debug settings to determine their visibility in game (i.e. {@link SceneTree.debugCollisionsHint} or {@link SceneTree.debugNavigationHint}).
+     */
+    DEBUG_VISIBILITY_MODE_DEFAULT: 0,
+    /**
+     * Always show the collisions debug shapes.
+     */
+    DEBUG_VISIBILITY_MODE_FORCE_SHOW: 1,
+    /**
+     * Always hide the collisions debug shapes.
+     */
+    DEBUG_VISIBILITY_MODE_FORCE_HIDE: 2,
+} as const;
+
+export type DebugVisibilityMode = (typeof DebugVisibilityMode)[keyof typeof DebugVisibilityMode];
+

package/gen/classes/GrooveJoint2D.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 { Joint2D } from './Joint2D.ts';
+
+/**
+ * A physics joint that restricts the movement of two 2D physics bodies to a fixed axis. For example, a {@link StaticBody2D} representing a piston base can be attached to a {@link RigidBody2D} representing the piston head, moving up and down.
+ */
+export class GrooveJoint2D extends Joint2D {
+    constructor(name = 323) { super(name); }
+
+    /**
+     * The groove's length. The groove is from the joint's origin towards {@link length} along the joint's local Y axis.
+     */
+    get length(): number { return _C(this, 5331) as number; }
+    set length(v: number) { _C(this, 11891, v); }
+
+    /**
+     * The body B's initial anchor position defined by the joint's origin and a local offset {@link initialOffset} along the joint's Y axis (along the groove).
+     */
+    get initialOffset(): number { return _C(this, 5101) as number; }
+    set initialOffset(v: number) { _C(this, 11701, v); }
+
+    static readonly name = _R(323, GrooveJoint2D);
+}

package/gen/classes/HBoxContainer.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 { BoxContainer } from './BoxContainer.ts';
+
+/**
+ * A variant of {@link BoxContainer} that can only arrange its child controls horizontally. Child controls are rearranged automatically when their minimum size changes.
+ */
+export class HBoxContainer extends BoxContainer {
+    constructor(name = 324) { super(name); }
+
+    static readonly name = _R(324, HBoxContainer);
+}