@ringozz/godot 0.1.0

package/gen/classes/Script.ts

@@ -0,0 +1,122 @@
+// 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 { GodotArray, GodotDictionary, StringName, Variant } from '../heap-types/index.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * A class stored as a resource. A script extends the functionality of all objects that instantiate it.
+ * This is the base class for all scripts and should not be used directly. Trying to create a new script with this class will result in an error.
+ * The `new` method of a script subclass creates a new instance. {@link Object.setScript} extends an existing object, if that object's class matches one of the script's base classes.
+ */
+export class Script extends Resource {
+
+    /**
+     * Returns `true` if the script can be instantiated.
+     */
+    canInstantiate(): boolean { return _C(this, 2013) as boolean; }
+
+    /**
+     * Returns `true` if the script contains non-empty source code.
+     * **Note:** If a script does not have source code, this does not mean that it is invalid or unusable. For example, a {@link GDScript} that was exported with binary tokenization has no source code, but still behaves as expected and could be instantiated. This can be checked with {@link canInstantiate}.
+     */
+    hasSourceCode(): boolean { return _C(this, 7450) as boolean; }
+
+    /**
+     * Reloads the script's class implementation. Returns an error code.
+     */
+    reload(keepState?: boolean /* = false */): Error { return _C(this, 9870, keepState) as Error; }
+
+    /**
+     * Returns the script directly inherited by this script.
+     */
+    getBaseScript(): Script { return _C(this, 3900) as Script; }
+
+    /**
+     * Returns the script's base type.
+     */
+    getInstanceBaseType(): StringName { return _C(this, 5129) as StringName; }
+
+    /**
+     * Returns the class name associated with the script, if there is one. Returns an empty string otherwise.
+     * To give the script a global name, you can use the `class_name` keyword in GDScript and the `[GlobalClass]` attribute in C#.
+     *
+     *
+     * ```gdscript
+     *
+     * class_name MyNode
+     * extends Node
+     *
+     * ```
+     */
+    getGlobalName(): StringName { return _C(this, 4928) as StringName; }
+
+    /**
+     * Returns `true` if the script, or a base class, defines a method with the given name.
+     */
+    hasScriptMethod(methodName: StringName): boolean { return _C(this, 7439, methodName) as boolean; }
+
+    /**
+     * Returns `true` if the script, or a base class, defines a signal with the given name.
+     */
+    hasScriptSignal(signalName: StringName): boolean { return _C(this, 7440, signalName) as boolean; }
+
+    /**
+     * Returns the list of properties in this {@link Script}.
+     * **Note:** The dictionaries returned by this method are formatted identically to those returned by {@link Object.getPropertyList}.
+     */
+    getScriptPropertyList(): GodotArray<GodotDictionary> { return _C(this, 6273) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns the list of methods in this {@link Script}.
+     * **Note:** The dictionaries returned by this method are formatted identically to those returned by {@link Object.getMethodList}.
+     */
+    getScriptMethodList(): GodotArray<GodotDictionary> { return _C(this, 6271) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns the list of signals defined in this {@link Script}.
+     * **Note:** The dictionaries returned by this method are formatted identically to those returned by {@link Object.getSignalList}.
+     */
+    getScriptSignalList(): GodotArray<GodotDictionary> { return _C(this, 6274) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns a dictionary containing constant names and their values.
+     */
+    getScriptConstantMap(): GodotDictionary { return _C(this, 6268) as GodotDictionary; }
+
+    /**
+     * Returns the default value of the specified property.
+     */
+    getPropertyDefaultValue(property: StringName): Variant { return _C(this, 6050, property) as Variant; }
+
+    /**
+     * Returns `true` if the script is a tool script. A tool script can run in the editor.
+     */
+    isTool(): boolean { return _C(this, 8367) as boolean; }
+
+    /**
+     * Returns `true` if the script is an abstract script. An abstract script does not have a constructor and cannot be instantiated.
+     */
+    isAbstract(): boolean { return _C(this, 7731) as boolean; }
+
+    /**
+     * Returns a {@link Dictionary} mapping method names to their RPC configuration defined by this script.
+     */
+    getRpcConfig(): Variant { return _C(this, 6222) as Variant; }
+
+    /**
+     * Returns `true` if `baseObject` is an instance of this script.
+     */
+    instanceHas(baseObject: Object): boolean { return _C(this, 7659, baseObject) as boolean; }
+
+    /**
+     * The script source code or an empty string if source code is not available. When set, does not reload the class implementation automatically.
+     */
+    get sourceCode(): string { return _C(this, 6456) as string; }
+    set sourceCode(v: string) { _C(this, 12813, v); }
+
+    static readonly name = _R(679, Script);
+}

package/gen/classes/ScriptBacktrace.ts

@@ -0,0 +1,103 @@
+// 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 { Variant } from '../heap-types/index.ts';
+
+/**
+ * {@link ScriptBacktrace} holds an already captured backtrace of a specific script language, such as GDScript or C#, which are captured using {@link Engine.captureScriptBacktraces}.
+ * See {@link ProjectSettings.debug/settings/gdscript/alwaysTrackCallStacks} and {@link ProjectSettings.debug/settings/gdscript/alwaysTrackLocalVariables} for ways of controlling the contents of this class.
+ */
+export class ScriptBacktrace extends RefCounted {
+    constructor(name = 680) { super(name); }
+
+    /**
+     * Returns the name of the script language that this backtrace was captured from.
+     */
+    getLanguageName(): string { return _C(this, 5300) as string; }
+
+    /**
+     * Returns `true` if the backtrace has no stack frames.
+     */
+    isEmpty(): boolean { return _C(this, 7931) as boolean; }
+
+    /**
+     * Returns the number of stack frames in the backtrace.
+     */
+    getFrameCount(): number { return _C(this, 4880) as number; }
+
+    /**
+     * Returns the name of the function called at the stack frame at the specified index.
+     */
+    getFrameFunction(index: number): string { return _C(this, 4884, index) as string; }
+
+    /**
+     * Returns the file name of the call site represented by the stack frame at the specified index.
+     */
+    getFrameFile(index: number): string { return _C(this, 4883, index) as string; }
+
+    /**
+     * Returns the line number of the call site represented by the stack frame at the specified index.
+     */
+    getFrameLine(index: number): number { return _C(this, 4885, index) as number; }
+
+    /**
+     * Returns the number of global variables (e.g. autoload singletons) in the backtrace.
+     * **Note:** This will be non-zero only if the `include_variables` parameter was `true` when capturing the backtrace with {@link Engine.captureScriptBacktraces}.
+     */
+    getGlobalVariableCount(): number { return _C(this, 4939) as number; }
+
+    /**
+     * Returns the name of the global variable at the specified index.
+     */
+    getGlobalVariableName(variableIndex: number): string { return _C(this, 4940, variableIndex) as string; }
+
+    /**
+     * Returns the value of the global variable at the specified index.
+     * **Warning:** With GDScript backtraces, the returned {@link Variant} will be the variable's actual value, including any object references. This means that storing the returned {@link Variant} will prevent any such object from being deallocated, so it's generally recommended not to do so.
+     */
+    getGlobalVariableValue(variableIndex: number): Variant { return _C(this, 4941, variableIndex) as Variant; }
+
+    /**
+     * Returns the number of local variables in the stack frame at the specified index.
+     * **Note:** This will be non-zero only if the `include_variables` parameter was `true` when capturing the backtrace with {@link Engine.captureScriptBacktraces}.
+     */
+    getLocalVariableCount(frameIndex: number): number { return _C(this, 5401, frameIndex) as number; }
+
+    /**
+     * Returns the name of the local variable at the specified `variableIndex` in the stack frame at the specified `frameIndex`.
+     */
+    getLocalVariableName(frameIndex: number, variableIndex: number): string { return _C(this, 5402, frameIndex, variableIndex) as string; }
+
+    /**
+     * Returns the value of the local variable at the specified `variableIndex` in the stack frame at the specified `frameIndex`.
+     * **Warning:** With GDScript backtraces, the returned {@link Variant} will be the variable's actual value, including any object references. This means that storing the returned {@link Variant} will prevent any such object from being deallocated, so it's generally recommended not to do so.
+     */
+    getLocalVariableValue(frameIndex: number, variableIndex: number): Variant { return _C(this, 5403, frameIndex, variableIndex) as Variant; }
+
+    /**
+     * Returns the number of member variables in the stack frame at the specified index.
+     * **Note:** This will be non-zero only if the `include_variables` parameter was `true` when capturing the backtrace with {@link Engine.captureScriptBacktraces}.
+     */
+    getMemberVariableCount(frameIndex: number): number { return _C(this, 5500, frameIndex) as number; }
+
+    /**
+     * Returns the name of the member variable at the specified `variableIndex` in the stack frame at the specified `frameIndex`.
+     */
+    getMemberVariableName(frameIndex: number, variableIndex: number): string { return _C(this, 5501, frameIndex, variableIndex) as string; }
+
+    /**
+     * Returns the value of the member variable at the specified `variableIndex` in the stack frame at the specified `frameIndex`.
+     * **Warning:** With GDScript backtraces, the returned {@link Variant} will be the variable's actual value, including any object references. This means that storing the returned {@link Variant} will prevent any such object from being deallocated, so it's generally recommended not to do so.
+     */
+    getMemberVariableValue(frameIndex: number, variableIndex: number): Variant { return _C(this, 5502, frameIndex, variableIndex) as Variant; }
+
+    /**
+     * Converts the backtrace to a {@link String}, where the entire string will be indented by `indentAll` number of spaces, and the individual stack frames will be additionally indented by `indentFrames` number of spaces.
+     * **Note:** Calling {@link Object.toString} on a {@link ScriptBacktrace} will produce the same output as calling {@link format} with all parameters left at their default values.
+     */
+    format(indentAll?: number /* = 0 */, indentFrames?: number /* = 4 */): string { return _C(this, 3544, indentAll, indentFrames) as string; }
+
+    static readonly name = _R(680, ScriptBacktrace);
+}

package/gen/classes/ScriptExtension.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 { Script } from './Script.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, StringName, Variant } from '../heap-types/index.ts';
+import type { Object } from './Object.ts';
+import type { ScriptLanguage } from './ScriptLanguage.ts';
+
+export class ScriptExtension extends Script {
+    constructor(name = 681) { super(name); }
+
+    static readonly name = _R(681, ScriptExtension);
+}

package/gen/classes/ScriptLanguage.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 { Object } from './Object.ts';
+
+export class ScriptLanguage extends Object {
+
+    static readonly name = _R(682, ScriptLanguage);
+}
+
+export const ScriptNameCasing = {
+    SCRIPT_NAME_CASING_AUTO: 0,
+    SCRIPT_NAME_CASING_PASCAL_CASE: 1,
+    SCRIPT_NAME_CASING_SNAKE_CASE: 2,
+    SCRIPT_NAME_CASING_KEBAB_CASE: 3,
+    SCRIPT_NAME_CASING_CAMEL_CASE: 4,
+} as const;
+
+export type ScriptNameCasing = (typeof ScriptNameCasing)[keyof typeof ScriptNameCasing];
+

package/gen/classes/ScriptLanguageExtension.ts

@@ -0,0 +1,72 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { ScriptLanguage } from './ScriptLanguage.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, PackedStringArray, StringName, Variant } from '../heap-types/index.ts';
+import type { Object } from './Object.ts';
+import type { Script } from './Script.ts';
+import type { ScriptNameCasing } from './ScriptLanguage.ts';
+
+export class ScriptLanguageExtension extends ScriptLanguage {
+    constructor(name = 683) { super(name); }
+
+    static readonly name = _R(683, ScriptLanguageExtension);
+}
+
+export const LookupResultType = {
+    LOOKUP_RESULT_SCRIPT_LOCATION: 0,
+    LOOKUP_RESULT_CLASS: 1,
+    LOOKUP_RESULT_CLASS_CONSTANT: 2,
+    LOOKUP_RESULT_CLASS_PROPERTY: 3,
+    LOOKUP_RESULT_CLASS_METHOD: 4,
+    LOOKUP_RESULT_CLASS_SIGNAL: 5,
+    LOOKUP_RESULT_CLASS_ENUM: 6,
+    LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE: 7,
+    LOOKUP_RESULT_CLASS_ANNOTATION: 8,
+    LOOKUP_RESULT_LOCAL_CONSTANT: 9,
+    LOOKUP_RESULT_LOCAL_VARIABLE: 10,
+    LOOKUP_RESULT_MAX: 11,
+} as const;
+
+export type LookupResultType = (typeof LookupResultType)[keyof typeof LookupResultType];
+
+export const CodeCompletionLocation = {
+    /**
+     * The option is local to the location of the code completion query - e.g. a local variable. Subsequent value of location represent options from the outer class, the exact value represent how far they are (in terms of inner classes).
+     */
+    LOCATION_LOCAL: 0,
+    /**
+     * The option is from the containing class or a parent class, relative to the location of the code completion query. Perform a bitwise OR with the class depth (e.g. `0` for the local class, `1` for the parent, `2` for the grandparent, etc.) to store the depth of an option in the class or a parent class.
+     */
+    LOCATION_PARENT_MASK: 256,
+    /**
+     * The option is from user code which is not local and not in a derived class (e.g. Autoload Singletons).
+     */
+    LOCATION_OTHER_USER_CODE: 512,
+    /**
+     * The option is from other engine code, not covered by the other enum constants - e.g. built-in classes.
+     */
+    LOCATION_OTHER: 1024,
+} as const;
+
+export type CodeCompletionLocation = (typeof CodeCompletionLocation)[keyof typeof CodeCompletionLocation];
+
+export const CodeCompletionKind = {
+    CODE_COMPLETION_KIND_CLASS: 0,
+    CODE_COMPLETION_KIND_FUNCTION: 1,
+    CODE_COMPLETION_KIND_SIGNAL: 2,
+    CODE_COMPLETION_KIND_VARIABLE: 3,
+    CODE_COMPLETION_KIND_MEMBER: 4,
+    CODE_COMPLETION_KIND_ENUM: 5,
+    CODE_COMPLETION_KIND_CONSTANT: 6,
+    CODE_COMPLETION_KIND_NODE_PATH: 7,
+    CODE_COMPLETION_KIND_FILE_PATH: 8,
+    CODE_COMPLETION_KIND_PLAIN_TEXT: 9,
+    CODE_COMPLETION_KIND_KEYWORD: 10,
+    CODE_COMPLETION_KIND_MAX: 11,
+} as const;
+
+export type CodeCompletionKind = (typeof CodeCompletionKind)[keyof typeof CodeCompletionKind];
+

package/gen/classes/ScrollBar.ts

@@ -0,0 +1,26 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Range } from './Range.ts';
+import type { Signal } from '../heap-types/index.ts';
+
+/**
+ * Abstract base class for scrollbars, typically used to navigate through content that extends beyond the visible area of a control. Scrollbars are {@link Range}-based controls.
+ */
+export class ScrollBar extends Range {
+
+    /**
+     * Overrides the step used when clicking increment and decrement buttons or when using arrow keys when the {@link ScrollBar} is focused.
+     */
+    get customStep(): number { return _C(this, 4399) as number; }
+    set customStep(v: number) { _C(this, 11022, v); }
+
+    /**
+     * Emitted when the scrollbar is being scrolled.
+     */
+    get scrolling(): Signal<() => void> { return _G(this, 10305) as Signal<() => void>; }
+    set scrolling(v: (() => void) | null) { _G(this, 10305, v); }
+
+    static readonly name = _R(684, ScrollBar);
+}

package/gen/classes/ScrollContainer.ts

@@ -0,0 +1,199 @@
+// 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 { Signal } from '../heap-types/index.ts';
+import type { Control } from './Control.ts';
+import type { HScrollBar } from './HScrollBar.ts';
+import type { VScrollBar } from './VScrollBar.ts';
+
+/**
+ * A container used to provide a child control with scrollbars when needed. Scrollbars will automatically be drawn at the right (for vertical) or bottom (for horizontal) and will enable dragging to move the viewable Control (and its children) within the ScrollContainer. Scrollbars will also automatically resize the grabber based on the {@link Control.customMinimumSize} of the Control relative to the ScrollContainer.
+ */
+export class ScrollContainer extends Container {
+    constructor(name = 685) { super(name); }
+
+    /**
+     * Returns the horizontal scrollbar {@link HScrollBar} of this {@link ScrollContainer}.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to disable or hide a scrollbar, you can use {@link horizontalScrollMode}.
+     */
+    getHScrollBar(): HScrollBar { return _C(this, 5003) as HScrollBar; }
+
+    /**
+     * Returns the vertical scrollbar {@link VScrollBar} of this {@link ScrollContainer}.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to disable or hide a scrollbar, you can use {@link verticalScrollMode}.
+     */
+    getVScrollBar(): VScrollBar { return _C(this, 7014) as VScrollBar; }
+
+    /**
+     * Ensures the given `control` is visible (must be a direct or indirect child of the ScrollContainer). Used by {@link followFocus}.
+     * **Note:** This will not work on a node that was just added during the same frame. If you want to scroll to a newly added child, you must wait until the next frame using {@link SceneTree.process_frame}:
+     *
+     * ```text
+     *
+     * add_child(child_node)
+     * await get_tree().process_frame
+     * ensure_control_visible(child_node)
+     *
+     * ```
+     */
+    ensureControlVisible(control: Control): void { _C(this, 3107, control); }
+
+    /**
+     * If `true`, the ScrollContainer will automatically scroll to focused children (including indirect children) to make sure they are fully visible.
+     */
+    get followFocus(): boolean { return _C(this, 7967) as boolean; }
+    set followFocus(v: boolean) { _C(this, 11449, v); }
+
+    /**
+     * If `true`, {@link focus} is drawn when the ScrollContainer or one of its descendant nodes is focused.
+     */
+    get drawFocusBorder(): boolean { return _C(this, 4566) as boolean; }
+    set drawFocusBorder(v: boolean) { _C(this, 11189, v); }
+
+    /**
+     * The current horizontal scroll value.
+     * **Note:** If you are setting this value in the {@link Node.Ready} function or earlier, it needs to be wrapped with {@link Object.setDeferred}, since scroll bar's {@link Range.maxValue} is not initialized yet.
+     *
+     * ```text
+     *
+     * func _ready():
+     * 	set_deferred("scroll_horizontal", 600)
+     *
+     * ```
+     */
+    get scrollHorizontal(): number { return _C(this, 5002) as number; }
+    set scrollHorizontal(v: number) { _C(this, 11587, v); }
+
+    /**
+     * The current vertical scroll value.
+     * **Note:** Setting it early needs to be deferred, just like in {@link scrollHorizontal}.
+     *
+     * ```text
+     *
+     * func _ready():
+     * 	set_deferred("scroll_vertical", 600)
+     *
+     * ```
+     */
+    get scrollVertical(): number { return _C(this, 7013) as number; }
+    set scrollVertical(v: number) { _C(this, 13264, v); }
+
+    /**
+     * Overrides the {@link ScrollBar.customStep} used when clicking the internal scroll bar's horizontal increment and decrement buttons or when using arrow keys when the {@link ScrollBar} is focused.
+     */
+    get scrollHorizontalCustomStep(): number { return _C(this, 5045) as number; }
+    set scrollHorizontalCustomStep(v: number) { _C(this, 11639, v); }
+
+    /**
+     * Overrides the {@link ScrollBar.customStep} used when clicking the internal scroll bar's vertical increment and decrement buttons or when using arrow keys when the {@link ScrollBar} is focused.
+     */
+    get scrollVerticalCustomStep(): number { return _C(this, 7064) as number; }
+    set scrollVerticalCustomStep(v: number) { _C(this, 13304, v); }
+
+    /**
+     * Controls whether horizontal scrollbar can be used and when it should be visible.
+     */
+    get horizontalScrollMode(): ScrollMode { return _C(this, 5046) as ScrollMode; }
+    set horizontalScrollMode(v: ScrollMode) { _C(this, 11640, v); }
+
+    /**
+     * Controls whether vertical scrollbar can be used and when it should be visible.
+     */
+    get verticalScrollMode(): ScrollMode { return _C(this, 7066) as ScrollMode; }
+    set verticalScrollMode(v: ScrollMode) { _C(this, 13306, v); }
+
+    /**
+     * If `true`, the mouse wheel scrolls the view horizontally, and holding `Shift` scrolls vertically.
+     * If `false` (default), the mouse wheel scrolls the view vertically, and holding `Shift` scrolls horizontally.
+     */
+    get scrollHorizontalByDefault(): boolean { return _C(this, 8276) as boolean; }
+    set scrollHorizontalByDefault(v: boolean) { _C(this, 12639, v); }
+
+    /**
+     * Deadzone for touch scrolling. Lower deadzone makes the scrolling more sensitive.
+     */
+    get scrollDeadzone(): number { return _C(this, 4427) as number; }
+    set scrollDeadzone(v: number) { _C(this, 11037, v); }
+
+    /**
+     * The way which scroll hints (indicators that show that the content can still be scrolled in a certain direction) will be shown.
+     * **Note:** Hints won't be shown if the content can be scrolled both vertically and horizontally.
+     */
+    get scrollHintMode(): ScrollHintMode { return _C(this, 6280) as ScrollHintMode; }
+    set scrollHintMode(v: ScrollHintMode) { _C(this, 12638, v); }
+
+    /**
+     * If `true`, the scroll hint texture will be tiled instead of stretched. See {@link scrollHintMode}.
+     */
+    get tileScrollHint(): boolean { return _C(this, 8275) as boolean; }
+    set tileScrollHint(v: boolean) { _C(this, 13074, v); }
+
+    /**
+     * Emitted when scrolling starts when dragging the scrollable area *with a touch event*. This signal is *not* emitted when scrolling by dragging the scrollbar, scrolling with the mouse wheel or scrolling with keyboard/gamepad events.
+     * **Note:** This signal is only emitted on Android or iOS, or on desktop/web platforms when {@link ProjectSettings.inputDevices/pointing/emulateTouchFromMouse} is enabled.
+     */
+    get scrollStarted(): Signal<() => void> { return _G(this, 10294) as Signal<() => void>; }
+    set scrollStarted(v: (() => void) | null) { _G(this, 10294, v); }
+
+    /**
+     * Emitted when scrolling stops when dragging the scrollable area *with a touch event*. This signal is *not* emitted when scrolling by dragging the scrollbar, scrolling with the mouse wheel or scrolling with keyboard/gamepad events.
+     * **Note:** This signal is only emitted on Android or iOS, or on desktop/web platforms when {@link ProjectSettings.inputDevices/pointing/emulateTouchFromMouse} is enabled.
+     */
+    get scrollEnded(): Signal<() => void> { return _G(this, 10276) as Signal<() => void>; }
+    set scrollEnded(v: (() => void) | null) { _G(this, 10276, v); }
+
+    static readonly name = _R(685, ScrollContainer);
+}
+
+export const ScrollMode = {
+    /**
+     * Scrolling disabled, scrollbar will be invisible.
+     */
+    SCROLL_MODE_DISABLED: 0,
+    /**
+     * Scrolling enabled, scrollbar will be visible only if necessary, i.e. container's content is bigger than the container.
+     */
+    SCROLL_MODE_AUTO: 1,
+    /**
+     * Scrolling enabled, scrollbar will be always visible.
+     */
+    SCROLL_MODE_SHOW_ALWAYS: 2,
+    /**
+     * Scrolling enabled, scrollbar will be hidden.
+     */
+    SCROLL_MODE_SHOW_NEVER: 3,
+    /**
+     * Combines {@link SCROLL_MODE_AUTO} and {@link SCROLL_MODE_SHOW_ALWAYS}. The scrollbar is only visible if necessary, but the content size is adjusted as if it was always visible. It's useful for ensuring that content size stays the same regardless if the scrollbar is visible.
+     */
+    SCROLL_MODE_RESERVE: 4,
+    /**
+     * Behaves like {@link SCROLL_MODE_AUTO}, but makes the {@link ScrollContainer} report a minimum size based on its content (limited by {@link Control.customMaximumSize} when set on the corresponding axis). This allows it to grow first and only start scrolling once constrained.
+     */
+    SCROLL_MODE_MAXIMIZE_FIRST: 5,
+} as const;
+
+export type ScrollMode = (typeof ScrollMode)[keyof typeof ScrollMode];
+
+export const ScrollHintMode = {
+    /**
+     * Scroll hints will never be shown.
+     */
+    SCROLL_HINT_MODE_DISABLED: 0,
+    /**
+     * Scroll hints will be shown at the top and bottom (if vertical), or left and right (if horizontal).
+     */
+    SCROLL_HINT_MODE_ALL: 1,
+    /**
+     * Scroll hints will be shown at the top (if vertical), or the left (if horizontal).
+     */
+    SCROLL_HINT_MODE_TOP_AND_LEFT: 2,
+    /**
+     * Scroll hints will be shown at the bottom (if horizontal), or the right (if horizontal).
+     */
+    SCROLL_HINT_MODE_BOTTOM_AND_RIGHT: 3,
+} as const;
+
+export type ScrollHintMode = (typeof ScrollHintMode)[keyof typeof ScrollHintMode];
+

package/gen/classes/SegmentShape2D.ts

@@ -0,0 +1,27 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Shape2D } from './Shape2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * A 2D line segment shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape2D}.
+ */
+export class SegmentShape2D extends Shape2D {
+    constructor(name = 686) { super(name); }
+
+    /**
+     * The segment's first point position.
+     */
+    get a(): Vector2 { return _C(this, 3657) as Vector2; }
+    set a(v: Vector2) { _C(this, 10393, v); }
+
+    /**
+     * The segment's second point position.
+     */
+    get b(): Vector2 { return _C(this, 3863) as Vector2; }
+    set b(v: Vector2) { _C(this, 10615, v); }
+
+    static readonly name = _R(686, SegmentShape2D);
+}

package/gen/classes/Semaphore.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 { RefCounted } from './RefCounted.ts';
+
+/**
+ * A synchronization semaphore that can be used to synchronize multiple {@link Thread}s. Initialized to zero on creation. For a binary version, see {@link Mutex}.
+ * **Warning:** Semaphores must be used carefully to avoid deadlocks.
+ * **Warning:** To guarantee that the operating system is able to perform proper cleanup (no crashes, no deadlocks), these conditions must be met:
+ * - When a {@link Semaphore}'s reference count reaches zero and it is therefore destroyed, no threads must be waiting on it.
+ * - When a {@link Thread}'s reference count reaches zero and it is therefore destroyed, it must not be waiting on any semaphore.
+ */
+export class Semaphore extends RefCounted {
+    constructor(name = 687) { super(name); }
+
+    /**
+     * Waits for the {@link Semaphore}, if its value is zero, blocks until non-zero.
+     */
+    wait(): void { _C(this, 14834); }
+
+    /**
+     * Like {@link wait}, but won't block, so if the value is zero, fails immediately and returns `false`. If non-zero, it returns `true` to report success.
+     */
+    tryWait(): boolean { return _C(this, 14423) as boolean; }
+
+    /**
+     * Lowers the {@link Semaphore}, allowing one thread in, or more if `count` is specified.
+     */
+    post(count?: number /* = 1 */): void { _C(this, 9520, count); }
+
+    static readonly name = _R(687, Semaphore);
+}

package/gen/classes/SeparationRayShape2D.ts

@@ -0,0 +1,27 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Shape2D } from './Shape2D.ts';
+
+/**
+ * A 2D ray shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape2D}. When a {@link SeparationRayShape2D} collides with an object, it tries to separate itself from it by moving its endpoint to the collision point. For example, a {@link SeparationRayShape2D} next to a character can allow it to instantly move up when touching stairs.
+ */
+export class SeparationRayShape2D extends Shape2D {
+    constructor(name = 688) { super(name); }
+
+    /**
+     * The ray's length.
+     */
+    get length(): number { return _C(this, 5331) as number; }
+    set length(v: number) { _C(this, 11891, v); }
+
+    /**
+     * If `false` (default), the shape always separates and returns a normal along its own direction.
+     * If `true`, the shape can return the correct normal and separate in any direction, allowing sliding motion on slopes.
+     */
+    get slideOnSlope(): boolean { return _C(this, 6434) as boolean; }
+    set slideOnSlope(v: boolean) { _C(this, 12780, v); }
+
+    static readonly name = _R(688, SeparationRayShape2D);
+}