@ringozz/godot 0.1.0

package/gen/classes/OpenXRSpatialEntityTracker.ts

@@ -0,0 +1,82 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { XRPositionalTracker } from './XRPositionalTracker.ts';
+import type { RID, Signal } from '../heap-types/index.ts';
+import type { OpenXRStructureBase } from './OpenXRStructureBase.ts';
+
+/**
+ * These are trackers created and managed by OpenXR's spatial entity extensions that give access to specific data related to OpenXR's spatial entities. They will always be of type `TRACKER_ANCHOR`.
+ */
+export class OpenXRSpatialEntityTracker extends XRPositionalTracker {
+    constructor(name = 526) { super(name); }
+
+    /**
+     * Sets the spatial context used to create this tracker.
+     */
+    setSpatialContext(spatialContext: RID): void { _C(this, 12826, spatialContext); }
+
+    /**
+     * Gets the spatial context used to create this {@link OpenXRSpatialEntityTracker}.
+     */
+    getSpatialContext(): RID { return _C(this, 6473) as RID; }
+
+    /**
+     * Gets the head {@link OpenXRStructureBase} in the next-chain.
+     * See also {@link addNext} and {@link removeNext}.
+     */
+    getNext(): OpenXRStructureBase { return _C(this, 5622) as OpenXRStructureBase; }
+
+    /**
+     * Adds a new {@link OpenXRStructureBase} to the next-chain.
+     * {@link getNext} will return this `next` until either {@link addNext} is called again or it's removed in {@link removeNext}.
+     */
+    addNext(next: OpenXRStructureBase): void { _C(this, 1256, next); }
+
+    /**
+     * Removes a `next` object previously added in {@link addNext} from the next-chain.
+     */
+    removeNext(next: OpenXRStructureBase): void { _C(this, 9936, next); }
+
+    /**
+     * The spatial entity associated with this tracker.
+     */
+    get entity(): RID { return _C(this, 4672) as RID; }
+    set entity(v: RID) { _C(this, 11299, v); }
+
+    /**
+     * The spatial tracking state for this tracker.
+     */
+    get spatialTrackingState(): EntityTrackingState { return _C(this, 6480) as EntityTrackingState; }
+    set spatialTrackingState(v: EntityTrackingState) { _C(this, 12827, v); }
+
+    /**
+     * Emitted when the next-chain changes, from either {@link addNext} or {@link removeNext}.
+     */
+    get nextChanged(): Signal<() => void> { return _G(this, 9071) as Signal<() => void>; }
+    set nextChanged(v: (() => void) | null) { _G(this, 9071, v); }
+
+    get spatialTrackingStateChanged(): Signal<(spatialTrackingState: number) => void> { return _G(this, 13765) as Signal<(spatialTrackingState: number) => void>; }
+    set spatialTrackingStateChanged(v: ((spatialTrackingState: number) => void) | null) { _G(this, 13765, v); }
+
+    static readonly name = _R(526, OpenXRSpatialEntityTracker);
+}
+
+export const EntityTrackingState = {
+    /**
+     * This anchor has stopped tracking.
+     */
+    ENTITY_TRACKING_STATE_STOPPED: 1,
+    /**
+     * Tracking is currently paused.
+     */
+    ENTITY_TRACKING_STATE_PAUSED: 2,
+    /**
+     * This anchor is currently being tracked.
+     */
+    ENTITY_TRACKING_STATE_TRACKING: 3,
+} as const;
+
+export type EntityTrackingState = (typeof EntityTrackingState)[keyof typeof EntityTrackingState];
+

package/gen/classes/OpenXRSpatialMarkerTrackingCapability.ts

@@ -0,0 +1,56 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRExtensionWrapper } from './OpenXRExtensionWrapper.ts';
+import type { Callable, GodotArray, RID } from '../heap-types/index.ts';
+import type { OpenXRFutureResult } from './OpenXRFutureResult.ts';
+import type { OpenXRSpatialComponentData } from './OpenXRSpatialComponentData.ts';
+import type { OpenXRStructureBase } from './OpenXRStructureBase.ts';
+
+/**
+ * This class handles the OpenXR marker tracking spatial entity extension.
+ */
+export class OpenXRSpatialMarkerTrackingCapability extends OpenXRExtensionWrapper {
+    constructor(name = 527) { super(name); }
+
+    /**
+     * Returns `true` if QR code marker tracking is supported by the current device.
+     */
+    isQrcodeSupported(): boolean { return _C(this, 8222) as boolean; }
+
+    /**
+     * Returns `true` if micro QR code marker tracking is supported by the current device.
+     */
+    isMicroQrcodeSupported(): boolean { return _C(this, 8105) as boolean; }
+
+    /**
+     * Returns `true` if Aruco marker tracking is supported by the current device.
+     */
+    isArucoSupported(): boolean { return _C(this, 7766) as boolean; }
+
+    /**
+     * Returns `true` if April tag marker tracking is supported by the current device.
+     */
+    isAprilTagSupported(): boolean { return _C(this, 7764) as boolean; }
+
+    /**
+     * Calls {@link OpenXRSpatialEntityExtension.discoverSpatialEntities} and {@link OpenXRSpatialEntityExtension.querySnapshot} with the marker entities associated with `spatialContext`.
+     * `componentData` are the {@link OpenXRSpatialComponentData}s to discover for this marker capability.
+     * If `nextSnapshotCreate` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.discoverSpatialEntities}.
+     * If `nextSnapshotQuery` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.querySnapshot}.
+     * `userCallback`, when non-null, is called with two parameters usually twice. The first parameter is the {@link RID} of the discovery snapshot and the second parameter is a boolean where `false` indicates the discovery snapshot is about to be processed, and `true` indicates the discovery snapshot has been processed and `componentData` has valid data. The second call is skipped if an error was encountered.
+     * The returned {@link OpenXRFutureResult} is identical to the return from {@link OpenXRSpatialEntityExtension.discoverSpatialEntities}.
+     */
+    startEntityDiscovery(spatialContext: RID, componentData: GodotArray<OpenXRSpatialComponentData>, nextSnapshotCreate?: OpenXRStructureBase /* = null */, nextSnapshotQuery?: OpenXRStructureBase /* = null */, userCallback?: Callable /* = Callable() */): OpenXRFutureResult { return _C(this, 13834, spatialContext, componentData, nextSnapshotCreate, nextSnapshotQuery, userCallback) as OpenXRFutureResult; }
+
+    /**
+     * Calls {@link OpenXRSpatialEntityExtension.updateSpatialEntities} and {@link OpenXRSpatialEntityExtension.querySnapshot} with the marker entities associated with `spatialContext`.
+     * `componentData` are the {@link OpenXRSpatialComponentData}s to update for this marker capability.
+     * If `nextSnapshotCreate` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.updateSpatialEntities}.
+     * If `nextSnapshotQuery` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.querySnapshot}.
+     */
+    doEntityUpdate(spatialContext: RID, componentData: GodotArray<OpenXRSpatialComponentData>, nextSnapshotCreate?: OpenXRStructureBase /* = null */, nextSnapshotQuery?: OpenXRStructureBase /* = null */): void { _C(this, 2852, spatialContext, componentData, nextSnapshotCreate, nextSnapshotQuery); }
+
+    static readonly name = _R(527, OpenXRSpatialMarkerTrackingCapability);
+}

package/gen/classes/OpenXRSpatialPlaneTrackingCapability.ts

@@ -0,0 +1,33 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRExtensionWrapper } from './OpenXRExtensionWrapper.ts';
+import type { Callable, GodotArray, RID } from '../heap-types/index.ts';
+import type { OpenXRFutureResult } from './OpenXRFutureResult.ts';
+import type { OpenXRSpatialComponentData } from './OpenXRSpatialComponentData.ts';
+import type { OpenXRStructureBase } from './OpenXRStructureBase.ts';
+
+/**
+ * This class handles the OpenXR plane tracking spatial entity extension.
+ */
+export class OpenXRSpatialPlaneTrackingCapability extends OpenXRExtensionWrapper {
+    constructor(name = 528) { super(name); }
+
+    /**
+     * Returns `true` if plane tracking is supported by the current device.
+     */
+    isSupported(): boolean { return _C(this, 8349) as boolean; }
+
+    /**
+     * Calls {@link OpenXRSpatialEntityExtension.discoverSpatialEntities} and {@link OpenXRSpatialEntityExtension.querySnapshot} with the plane entities associated with `spatialContext`.
+     * `componentData` are the {@link OpenXRSpatialComponentData}s to discover for this plane capability.
+     * If `nextSnapshotCreate` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.discoverSpatialEntities}.
+     * If `nextSnapshotQuery` is non-null, then pass this to the `next` parameter in {@link OpenXRSpatialEntityExtension.querySnapshot}.
+     * `userCallback`, when non-null, is called with two parameters usually twice. The first parameter is the {@link RID} of the discovery snapshot and the second parameter is a boolean where `false` indicates the discovery snapshot is about to be processed, and `true` indicates the discovery snapshot has been processed and `componentData` has valid data. The second call is skipped if an error was encountered.
+     * The returned {@link OpenXRFutureResult} is identical to the return from {@link OpenXRSpatialEntityExtension.discoverSpatialEntities}.
+     */
+    startEntityDiscovery(spatialContext: RID, componentData: GodotArray<OpenXRSpatialComponentData>, nextSnapshotCreate?: OpenXRStructureBase /* = null */, nextSnapshotQuery?: OpenXRStructureBase /* = null */, userCallback?: Callable /* = Callable() */): OpenXRFutureResult { return _C(this, 13834, spatialContext, componentData, nextSnapshotCreate, nextSnapshotQuery, userCallback) as OpenXRFutureResult; }
+
+    static readonly name = _R(528, OpenXRSpatialPlaneTrackingCapability);
+}

package/gen/classes/OpenXRSpatialQueryResultData.ts

@@ -0,0 +1,30 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRSpatialComponentData } from './OpenXRSpatialComponentData.ts';
+import type { EntityTrackingState } from './OpenXRSpatialEntityTracker.ts';
+
+/**
+ * Object for storing the main query result data when calling {@link OpenXRSpatialEntityExtension.querySnapshot}. This must always be the first component requested.
+ */
+export class OpenXRSpatialQueryResultData extends OpenXRSpatialComponentData {
+    constructor(name = 529) { super(name); }
+
+    /**
+     * Returns the number of entities that were retrieved.
+     */
+    getCapacity(): number { return _C(this, 4080) as number; }
+
+    /**
+     * Returns the entity id (`XrSpatialEntityIdEXT`) for the entity at this `index`.
+     */
+    getEntityId(index: number /* int64 */): number { return _C(this, 4673, index) as number; }
+
+    /**
+     * Returns the entity state for the entity at this `index`.
+     */
+    getEntityState(index: number /* int64 */): EntityTrackingState { return _C(this, 4675, index) as EntityTrackingState; }
+
+    static readonly name = _R(529, OpenXRSpatialQueryResultData);
+}

package/gen/classes/OpenXRStructureBase.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 { RefCounted } from './RefCounted.ts';
+
+/**
+ * Object for storing OpenXR structure data that is passed when calling into OpenXR APIs.
+ */
+export class OpenXRStructureBase extends RefCounted {
+    constructor(name = 530) { super(name); }
+
+    /**
+     * Returns the structure type (OpenXR `XrStructureType`) used for this structure.
+     */
+    getStructureType(): number { return _C(this, 6584) as number; }
+
+    /**
+     * Setting another structure object here chains these structures together to extend the API functionality. Consult the OpenXR documentation for which structures can be used with a given API call.
+     */
+    get next(): OpenXRStructureBase { return _C(this, 5622) as OpenXRStructureBase; }
+    set next(v: OpenXRStructureBase) { _C(this, 12131, v); }
+
+    static readonly name = _R(530, OpenXRStructureBase);
+}

package/gen/classes/OpenXRVisibilityMask.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 { VisualInstance3D } from './VisualInstance3D.ts';
+
+/**
+ * The visibility mask allows us to black out the part of the render result that is invisible due to lens distortion.
+ * As this is rendered first, it prevents fragments with expensive lighting calculations to be processed as they are discarded through z-checking.
+ */
+export class OpenXRVisibilityMask extends VisualInstance3D {
+    constructor(name = 531) { super(name); }
+
+    static readonly name = _R(531, OpenXRVisibilityMask);
+}

package/gen/classes/OptimizedTranslation.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Translation } from './Translation.ts';
+
+/**
+ * An optimized translation. Uses real-time compressed translations, which results in very small dictionaries.
+ * This class does not store the untranslated strings for optimization purposes. Therefore, {@link Translation.getMessageList} always returns an empty array, and {@link Translation.getMessageCount} always returns `0`.
+ */
+export class OptimizedTranslation extends Translation {
+    constructor(name = 532) { super(name); }
+
+    /**
+     * Generates and sets an optimized translation from the given {@link Translation} resource. Returns `true` if successful.
+     * **Note:** Messages in `from` should not use context or plural forms.
+     * **Note:** This method is intended to be used in the editor. It does nothing when called from an exported project.
+     */
+    generate(from: Translation): boolean { return _C(this, 3627, from) as boolean; }
+
+    static readonly name = _R(532, OptimizedTranslation);
+}

package/gen/classes/OptionButton.ts

@@ -0,0 +1,236 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Button } from './Button.ts';
+import type { Signal, Variant } from '../heap-types/index.ts';
+import type { AutoTranslateMode } from './Node.ts';
+import type { PopupMenu } from './PopupMenu.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * {@link OptionButton} is a type of button that brings up a dropdown with selectable items when pressed. The item selected becomes the "current" item and is displayed as the button text.
+ * See also {@link BaseButton} which contains common properties and methods associated with this node.
+ * **Note:** The IDs used for items are limited to signed 32-bit integers, not the full 64 bits of {@link int}. These have a range of `-2^31` to `2^31 - 1`, that is, `-2147483648` to `2147483647`.
+ * **Note:** The {@link Button.text} and {@link Button.icon} properties are set automatically based on the selected item. They shouldn't be changed manually.
+ */
+export class OptionButton extends Button {
+    constructor(name = 533) { super(name); }
+
+    /**
+     * Adds an item, with text `label` and (optionally) `id`. If no `id` is passed, the item index will be used as the item's ID. New items are appended at the end.
+     * **Note:** The item will be selected if there are no other items.
+     */
+    addItem(label: string, id?: number /* = -1 */): void { _C(this, 1241, label, id); }
+
+    /**
+     * Adds an item, with a `texture` icon, text `label` and (optionally) `id`. If no `id` is passed, the item index will be used as the item's ID. New items are appended at the end.
+     * **Note:** The item will be selected if there are no other items.
+     */
+    addIconItem(texture: Texture2D, label: string, id?: number /* = -1 */): void { _C(this, 1230, texture, label, id); }
+
+    /**
+     * Sets the text of the item at index `idx`.
+     */
+    setItemText(idx: number, text: string): void { _C(this, 11806, idx, text); }
+
+    /**
+     * Sets the icon of the item at index `idx`.
+     */
+    setItemIcon(idx: number, texture: Texture2D): void { _C(this, 11773, idx, texture); }
+
+    /**
+     * Sets whether the item at index `idx` is disabled.
+     * Disabled items are drawn differently in the dropdown and are not selectable by the user. If the current selected item is set as disabled, it will remain selected.
+     */
+    setItemDisabled(idx: number, disabled: boolean): void { _C(this, 11770, idx, disabled); }
+
+    /**
+     * Sets the ID of the item at index `idx`.
+     */
+    setItemId(idx: number, id: number): void { _C(this, 11778, idx, id); }
+
+    /**
+     * Sets the metadata of an item. Metadata may be of any type and can be used to store extra information about an item, such as an external string ID.
+     */
+    setItemMetadata(idx: number, metadata: Variant): void { _C(this, 11788, idx, metadata); }
+
+    /**
+     * Sets the tooltip of the item at index `idx`.
+     */
+    setItemTooltip(idx: number, tooltip: string): void { _C(this, 11808, idx, tooltip); }
+
+    /**
+     * Sets the auto translate mode of the item at index `idx`.
+     * Items use {@link Node.AUTO_TRANSLATE_MODE_INHERIT} by default, which uses the same auto translate mode as the {@link OptionButton} itself.
+     */
+    setItemAutoTranslateMode(idx: number, mode: AutoTranslateMode): void { _C(this, 11762, idx, mode); }
+
+    /**
+     * Returns the text of the item at index `idx`.
+     */
+    getItemText(idx: number): string { return _C(this, 5216, idx) as string; }
+
+    /**
+     * Returns the icon of the item at index `idx`.
+     */
+    getItemIcon(idx: number): Texture2D { return _C(this, 5185, idx) as Texture2D; }
+
+    /**
+     * Returns the ID of the item at index `idx`.
+     */
+    getItemId(idx: number): number { return _C(this, 5189, idx) as number; }
+
+    /**
+     * Returns the index of the item with the given `id`.
+     */
+    getItemIndex(id: number): number { return _C(this, 5192, id) as number; }
+
+    /**
+     * Retrieves the metadata of an item. Metadata may be any type and can be used to store extra information about an item, such as an external string ID.
+     */
+    getItemMetadata(idx: number): Variant { return _C(this, 5200, idx) as Variant; }
+
+    /**
+     * Returns the tooltip of the item at index `idx`.
+     */
+    getItemTooltip(idx: number): string { return _C(this, 5218, idx) as string; }
+
+    /**
+     * Returns the auto translate mode of the item at index `idx`.
+     */
+    getItemAutoTranslateMode(idx: number): AutoTranslateMode { return _C(this, 5179, idx) as AutoTranslateMode; }
+
+    /**
+     * Returns `true` if the item at index `idx` is disabled.
+     */
+    isItemDisabled(idx: number): boolean { return _C(this, 8040, idx) as boolean; }
+
+    /**
+     * Returns `true` if the item at index `idx` is marked as a separator.
+     */
+    isItemSeparator(idx: number): boolean { return _C(this, 8045, idx) as boolean; }
+
+    /**
+     * Adds a separator to the list of items. Separators help to group items, and can optionally be given a `text` header. A separator also gets an index assigned, and is appended at the end of the item list.
+     */
+    addSeparator(text?: string /* = "" */): void { _C(this, 1286, text); }
+
+    /**
+     * Clears all the items in the {@link OptionButton}.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Selects an item by index and makes it the current item. This will work even if the item is disabled.
+     * Passing `-1` as the index deselects any currently selected item.
+     */
+    select(idx: number): void { _C(this, 10353, idx); }
+
+    /**
+     * Returns the ID of the selected item, or `-1` if no item is selected.
+     */
+    getSelectedId(): number { return _C(this, 6324) as number; }
+
+    /**
+     * Gets the metadata of the selected item. Metadata for items can be set using {@link setItemMetadata}.
+     */
+    getSelectedMetadata(): Variant { return _C(this, 6326) as Variant; }
+
+    /**
+     * Removes the item at index `idx`.
+     */
+    removeItem(idx: number): void { _C(this, 9924, idx); }
+
+    /**
+     * Returns the {@link PopupMenu} contained in this button.
+     * **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 Window.visible} property.
+     */
+    getPopup(): PopupMenu { return _C(this, 5966) as PopupMenu; }
+
+    /**
+     * Adjusts popup position and sizing for the {@link OptionButton}, then shows the {@link PopupMenu}. Prefer this over using `get_popup().popup()`.
+     */
+    showPopup(): void { _C(this, 13583); }
+
+    /**
+     * Returns `true` if this button contains at least one item which is not disabled, or marked as a separator.
+     */
+    hasSelectableItems(): boolean { return _C(this, 7443) as boolean; }
+
+    /**
+     * Returns the index of the first item which is not disabled, or marked as a separator. If `fromLast` is `true`, the items will be searched in reverse order.
+     * Returns `-1` if no item is found.
+     */
+    getSelectableItem(fromLast?: boolean /* = false */): number { return _C(this, 6321, fromLast) as number; }
+
+    /**
+     * If `true`, shortcuts are disabled and cannot be used to trigger the button.
+     */
+    setDisableShortcuts(disabled: boolean): void { _C(this, 11121, disabled); }
+
+    /**
+     * The index of the currently selected item, or `-1` if no item is selected.
+     */
+    get selected(): number { return _C(this, 6322) as number; }
+    set selected(v: number) { _C(this, 1018, v); }
+
+    /**
+     * If `true`, minimum size will be determined by the longest item's width, instead of the currently selected one's. It will also take the popup's margins into account, making the button match its total width.
+     * **Note:** For performance reasons, the minimum size doesn't update immediately when adding, removing or modifying items.
+     */
+    get fitToLongestItem(): boolean { return _C(this, 7955) as boolean; }
+    set fitToLongestItem(v: boolean) { _C(this, 11401, v); }
+
+    /**
+     * If `true`, the currently selected item can be selected again.
+     */
+    get allowReselect(): boolean { return _C(this, 3719) as boolean; }
+    set allowReselect(v: boolean) { _C(this, 10457, v); }
+
+    /**
+     * If `true`, shows a search bar at the top of the {@link PopupMenu} for filtering items. See {@link searchBarMinItemCount} for dynamically controlling its visibility based on the number of items.
+     */
+    get searchBarEnabled(): boolean { return _C(this, 8282) as boolean; }
+    set searchBarEnabled(v: boolean) { _C(this, 12662, v); }
+
+    /**
+     * Sets the minimum number of items required for the {@link PopupMenu} search bar to be visible. {@link searchBarEnabled} must be `true` for this to have any effect.
+     */
+    get searchBarMinItemCount(): number { return _C(this, 6302) as number; }
+    set searchBarMinItemCount(v: number) { _C(this, 12665, v); }
+
+    /**
+     * If `true`, enables fuzzy searching in the {@link PopupMenu} search bar. This allows the search results to include items that almost match the search query, as well items that match the individual characters of the search query, but not in sequence.
+     * Use {@link searchBarFuzzySearchMaxMisses} to set the maximum number of mismatches allowed in the search results.
+     */
+    get searchBarFuzzySearchEnabled(): boolean { return _C(this, 8283) as boolean; }
+    set searchBarFuzzySearchEnabled(v: boolean) { _C(this, 12663, v); }
+
+    /**
+     * Sets the maximum number of mismatches allowed in each search result when fuzzy searching is enabled for the {@link PopupMenu} search bar. Any item with more mismatches will be hidden from the search results.
+     */
+    get searchBarFuzzySearchMaxMisses(): number { return _C(this, 6301) as number; }
+    set searchBarFuzzySearchMaxMisses(v: number) { _C(this, 12664, v); }
+
+    /**
+     * The number of items to select from.
+     */
+    get itemCount(): number { return _C(this, 5181) as number; }
+    set itemCount(v: number) { _C(this, 11766, v); }
+
+    /**
+     * Emitted when the current item has been changed by the user. The index of the item selected is passed as argument.
+     * {@link allowReselect} must be enabled to reselect an item.
+     */
+    get itemSelected(): Signal<(index: number) => void> { return _G(this, 8469) as Signal<(index: number) => void>; }
+    set itemSelected(v: ((index: number) => void) | null) { _G(this, 8469, v); }
+
+    /**
+     * Emitted when the user navigates to an item using the {@link ProjectSettings.input/uiUp} or {@link ProjectSettings.input/uiDown} input actions. The index of the item focused is passed as argument.
+     */
+    get itemFocused(): Signal<(index: number) => void> { return _G(this, 8465) as Signal<(index: number) => void>; }
+    set itemFocused(v: ((index: number) => void) | null) { _G(this, 8465, v); }
+
+    static readonly name = _R(533, OptionButton);
+}

package/gen/classes/PCKPacker.ts

@@ -0,0 +1,57 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedByteArray } from '../heap-types/index.ts';
+
+/**
+ * The {@link PCKPacker} is used to create packages that can be loaded into a running project using {@link ProjectSettings.loadResourcePack}.
+ *
+ *
+ * ```gdscript
+ *
+ * var packer = PCKPacker.new()
+ * packer.pck_start("test.pck")
+ * packer.add_file("res://text.txt", "text.txt")
+ * packer.flush()
+ *
+ * ```
+ *
+ *
+ *
+ * The above {@link PCKPacker} creates package `test.pck`, then adds a file named `text.txt` at the root of the package.
+ * **Note:** PCK is Godot's own pack file format. To create ZIP archives that can be read by any program, use {@link ZIPPacker} instead.
+ */
+export class PCKPacker extends RefCounted {
+    constructor(name = 534) { super(name); }
+
+    /**
+     * Creates a new PCK file at the file path `pckPath`. The `.pck` file extension isn't added automatically, so it should be part of `pckPath` (even though it's not required).
+     */
+    pckStart(pckPath: string, alignment?: number /* = 32 */, key?: string /* = "0000000000000000000000000000000000000000000000000000000000000000" */, encryptDirectory?: boolean /* = false */): Error { return _C(this, 9385, pckPath, alignment, key, encryptDirectory) as Error; }
+
+    /**
+     * Adds the `sourcePath` file to the current PCK package at the `targetPath` internal path. The `res://` prefix for `targetPath` is optional and stripped internally. File content is immediately written to the PCK.
+     */
+    addFile(targetPath: string, sourcePath: string, encrypt?: boolean /* = false */): Error { return _C(this, 1217, targetPath, sourcePath, encrypt) as Error; }
+
+    /**
+     * Adds the `data` to the current PCK package at the `targetPath` internal path. The `res://` prefix for `targetPath` is optional and stripped internally. File content is immediately written to the PCK.
+     */
+    addFileFromBuffer(targetPath: string, data: PackedByteArray, encrypt?: boolean /* = false */): Error { return _C(this, 1218, targetPath, data, encrypt) as Error; }
+
+    /**
+     * Registers a file removal of the `targetPath` internal path to the PCK. This is mainly used for patches. If the file at this path has been loaded from a previous PCK, it will be removed. The `res://` prefix for `targetPath` is optional and stripped internally.
+     */
+    addFileRemoval(targetPath: string): Error { return _C(this, 1219, targetPath) as Error; }
+
+    /**
+     * Writes the file directory and closes the PCK. If `verbose` is `true`, a list of files added will be printed to the console for easier debugging.
+     * **Note:** {@link PCKPacker} will automatically flush when it's freed, which happens when it goes out of scope or when it gets assigned with `null`. In C# the reference must be disposed after use, either with the `using` statement or by calling the `Dispose` method directly.
+     */
+    flush(verbose?: boolean /* = false */): Error { return _C(this, 3343, verbose) as Error; }
+
+    static readonly name = _R(534, PCKPacker);
+}

package/gen/classes/PackedDataContainer.ts

@@ -0,0 +1,58 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { Error } from '../global-enums.ts';
+import type { Variant } from '../heap-types/index.ts';
+
+/**
+ * {@link PackedDataContainer} can be used to efficiently store data from untyped containers. The data is packed into raw bytes and can be saved to file. Only {@link Array} and {@link Dictionary} can be stored this way.
+ * You can retrieve the data by iterating on the container, which will work as if iterating on the packed data itself. If the packed container is a {@link Dictionary}, the data can be retrieved by key names ({@link String}/{@link StringName} only).
+ *
+ * ```text
+ *
+ * var data = { "key": "value", "another_key": 123, "lock": Vector2() }
+ * var packed = PackedDataContainer.new()
+ * packed.pack(data)
+ * ResourceSaver.save(packed, "packed_data.res")
+ *
+ * ```
+ *
+ *
+ * ```text
+ *
+ * var container = load("packed_data.res")
+ * for key in container:
+ * 	prints(key, container[key])
+ *
+ * ```
+ *
+ * Prints:
+ *
+ * ```text
+ *
+ * key value
+ * lock (0, 0)
+ * another_key 123
+ *
+ * ```
+ *
+ * Nested containers will be packed recursively. While iterating, they will be returned as {@link PackedDataContainerRef}.
+ */
+export class PackedDataContainer extends Resource {
+    constructor(name = 535) { super(name); }
+
+    /**
+     * Packs the given container into a binary representation. The `value` must be either {@link Array} or {@link Dictionary}, any other type will result in invalid data error.
+     * **Note:** Subsequent calls to this method will overwrite the existing data.
+     */
+    pack(value: Variant): Error { return _C(this, 9256, value) as Error; }
+
+    /**
+     * Returns the size of the packed container (see {@link Array.size} and {@link Dictionary.size}).
+     */
+    size(): number { return _C(this, 13608) as number; }
+
+    static readonly name = _R(535, PackedDataContainer);
+}

package/gen/classes/PackedDataContainerRef.ts

@@ -0,0 +1,47 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+
+/**
+ * When packing nested containers using {@link PackedDataContainer}, they are recursively packed into {@link PackedDataContainerRef} (only applies to {@link Array} and {@link Dictionary}). Their data can be retrieved the same way as from {@link PackedDataContainer}.
+ *
+ * ```text
+ *
+ * var packed = PackedDataContainer.new()
+ * packed.pack([1, 2, 3, ["nested1", "nested2"], 4, 5, 6])
+ *
+ * for element in packed:
+ * 	if element is PackedDataContainerRef:
+ * 		for subelement in element:
+ * 			print("::", subelement)
+ * 	else:
+ * 		print(element)
+ *
+ * ```
+ *
+ * Prints:
+ *
+ * ```text
+ *
+ * 1
+ * 2
+ * 3
+ * ::nested1
+ * ::nested2
+ * 4
+ * 5
+ * 6
+ *
+ * ```
+ */
+export class PackedDataContainerRef extends RefCounted {
+
+    /**
+     * Returns the size of the packed container (see {@link Array.size} and {@link Dictionary.size}).
+     */
+    size(): number { return _C(this, 13608) as number; }
+
+    static readonly name = _R(536, PackedDataContainerRef);
+}