@ringozz/godot 0.1.0

package/gen/classes/LinkButton.ts

@@ -0,0 +1,99 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { BaseButton } from './BaseButton.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { TextDirection } from './Control.ts';
+import type { OverrunBehavior, StructuredTextParser } from './TextServer.ts';
+
+/**
+ * A button that represents a link. This type of button is primarily used for interactions that cause a context change (like linking to a web page).
+ * See also {@link BaseButton} which contains common properties and methods associated with this node.
+ */
+export class LinkButton extends BaseButton {
+    constructor(name = 399) { super(name); }
+
+    /**
+     * The button's text that will be displayed inside the button's area.
+     */
+    get text(): string { return _C(this, 6718) as string; }
+    set text(v: string) { _C(this, 13020, v); }
+
+    /**
+     * The underline mode to use for the text.
+     */
+    get underline(): UnderlineMode { return _C(this, 6944) as UnderlineMode; }
+    set underline(v: UnderlineMode) { _C(this, 13168, v); }
+
+    /**
+     * The [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) for this {@link LinkButton}. If set to a valid URI, pressing the button opens the URI using the operating system's default program for the protocol (via {@link OS.shellOpen}). HTTP and HTTPS URLs open the default web browser.
+     *
+     *
+     * ```gdscript
+     *
+     * uri = "https://godotengine.org"  # Opens the URL in the default web browser.
+     * uri = "C:\SomeFolder"  # Opens the file explorer at the given path.
+     * uri = "C:\SomeImage.png"  # Opens the given image in the default viewing app.
+     *
+     * ```
+     */
+    get uri(): string { return _C(this, 6967) as string; }
+    set uri(v: string) { _C(this, 13188, v); }
+
+    /**
+     * Sets the clipping behavior when the text exceeds the node's bounding rectangle.
+     */
+    get textOverrunBehavior(): OverrunBehavior { return _C(this, 6724) as OverrunBehavior; }
+    set textOverrunBehavior(v: OverrunBehavior) { _C(this, 13023, v); }
+
+    /**
+     * Ellipsis character used for text clipping.
+     */
+    get ellipsisChar(): string { return _C(this, 4610) as string; }
+    set ellipsisChar(v: string) { _C(this, 11226, v); }
+
+    /**
+     * Base text writing direction.
+     */
+    get textDirection(): TextDirection { return _C(this, 6720) as TextDirection; }
+    set textDirection(v: TextDirection) { _C(this, 13022, v); }
+
+    /**
+     * Language code used for line-breaking and text shaping algorithms. If left empty, the current locale is used instead.
+     */
+    get language(): string { return _C(this, 5299) as string; }
+    set language(v: string) { _C(this, 11871, v); }
+
+    /**
+     * Set BiDi algorithm override for the structured text.
+     */
+    get structuredTextBidiOverride(): StructuredTextParser { return _C(this, 6585) as StructuredTextParser; }
+    set structuredTextBidiOverride(v: StructuredTextParser) { _C(this, 12913, v); }
+
+    /**
+     * Set additional options for BiDi override.
+     */
+    get structuredTextBidiOverrideOptions(): GodotArray { return _C(this, 6586) as GodotArray; }
+    set structuredTextBidiOverrideOptions(v: GodotArray) { _C(this, 12914, v); }
+
+    static readonly name = _R(399, LinkButton);
+}
+
+export const UnderlineMode = {
+    /**
+     * The LinkButton will always show an underline at the bottom of its text.
+     */
+    UNDERLINE_MODE_ALWAYS: 0,
+    /**
+     * The LinkButton will show an underline at the bottom of its text when the mouse cursor is over it.
+     */
+    UNDERLINE_MODE_ON_HOVER: 1,
+    /**
+     * The LinkButton will never show an underline at the bottom of its text.
+     */
+    UNDERLINE_MODE_NEVER: 2,
+} as const;
+
+export type UnderlineMode = (typeof UnderlineMode)[keyof typeof UnderlineMode];
+

package/gen/classes/Logger.ts

@@ -0,0 +1,38 @@
+// 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 { GodotArray } from '../heap-types/index.ts';
+import type { ScriptBacktrace } from './ScriptBacktrace.ts';
+
+/**
+ * Custom logger to receive messages from the internal error/warning stream. Loggers are registered via {@link OS.addLogger}.
+ */
+export class Logger extends RefCounted {
+    constructor(name = 400) { super(name); }
+
+    static readonly name = _R(400, Logger);
+}
+
+export const ErrorType = {
+    /**
+     * The message received is an error.
+     */
+    ERROR_TYPE_ERROR: 0,
+    /**
+     * The message received is a warning.
+     */
+    ERROR_TYPE_WARNING: 1,
+    /**
+     * The message received is a script error.
+     */
+    ERROR_TYPE_SCRIPT: 2,
+    /**
+     * The message received is a shader error.
+     */
+    ERROR_TYPE_SHADER: 3,
+} as const;
+
+export type ErrorType = (typeof ErrorType)[keyof typeof ErrorType];
+

package/gen/classes/LookAtModifier3D.ts

@@ -0,0 +1,245 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModifier3D } from './SkeletonModifier3D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { BoneAxis } from './SkeletonModifier3D.ts';
+import type { EaseType, TransitionType } from './Tween.ts';
+
+/**
+ * This {@link SkeletonModifier3D} rotates a bone to look at a target. This is helpful for moving a character's head to look at the player, rotating a turret to look at a target, or any other case where you want to make a bone rotate towards something quickly and easily.
+ * When applying multiple {@link LookAtModifier3D}s, the {@link LookAtModifier3D} assigned to the parent bone must be put above the {@link LookAtModifier3D} assigned to the child bone in the list in order for the child bone results to be correct.
+ */
+export class LookAtModifier3D extends SkeletonModifier3D {
+    constructor(name = 401) { super(name); }
+
+    /**
+     * Returns the remaining seconds of the time-based interpolation.
+     */
+    getInterpolationRemaining(): number { return _C(this, 5157) as number; }
+
+    /**
+     * Returns `true` if time-based interpolation is running. If `true`, it is equivalent to {@link getInterpolationRemaining} returning `0.0`.
+     * This is useful to determine whether a {@link LookAtModifier3D} can be removed safely.
+     */
+    isInterpolating(): boolean { return _C(this, 8036) as boolean; }
+
+    /**
+     * Returns whether the target is within the angle limitations. It is useful for unsetting the {@link targetNode} when the target is outside of the angle limitations.
+     * **Note:** The value is updated after {@link SkeletonModifier3D.ProcessModification}. To retrieve this value correctly, we recommend using the signal {@link SkeletonModifier3D.modification_processed}.
+     */
+    isTargetWithinLimitation(): boolean { return _C(this, 8361) as boolean; }
+
+    /**
+     * The {@link NodePath} to the node that is the target for the look at modification. This node is what the modification will rotate the bone to.
+     */
+    get targetNode(): NodePath { return _C(this, 6701) as NodePath; }
+    set targetNode(v: NodePath) { _C(this, 13005, v); }
+
+    /**
+     * The bone name of the {@link Skeleton3D} that the modification will operate on.
+     */
+    get boneName(): string { return _C(this, 3972) as string; }
+    set boneName(v: string) { _C(this, 10710, v); }
+
+    /**
+     * Index of the {@link boneName} in the parent {@link Skeleton3D}.
+     */
+    get bone(): number { return _C(this, 3953) as number; }
+    set bone(v: number) { _C(this, 10698, v); }
+
+    /**
+     * The forward axis of the bone. This {@link SkeletonModifier3D} modifies the bone so that this axis points toward the {@link targetNode}.
+     */
+    get forwardAxis(): BoneAxis { return _C(this, 4864) as BoneAxis; }
+    set forwardAxis(v: BoneAxis) { _C(this, 11467, v); }
+
+    /**
+     * The axis of the first rotation. This {@link SkeletonModifier3D} works by compositing the rotation by Euler angles to prevent to rotate the {@link forwardAxis}.
+     */
+    get primaryRotationAxis(): number { return _C(this, 6011) as number; }
+    set primaryRotationAxis(v: number) { _C(this, 12416, v); }
+
+    /**
+     * If `true`, provides rotation by two axes.
+     */
+    get useSecondaryRotation(): boolean { return _C(this, 8420) as boolean; }
+    set useSecondaryRotation(v: boolean) { _C(this, 13238, v); }
+
+    /**
+     * The relative option. If `true`, the rotation is applied relative to the pose. If `false`, the rotation is applied relative to the rest. It means to replace the current pose with the {@link LookAtModifier3D}'s result.
+     * **Note:** This option affects the base angle for {@link useAngleLimitation}. Since the {@link LookAtModifier3D} relies strongly on Euler rotation, the axis that determines the limitation and the actual rotation are strongly tied together.
+     */
+    get relative(): boolean { return _C(this, 8237) as boolean; }
+    set relative(v: boolean) { _C(this, 12511, v); }
+
+    /**
+     * This value determines from what origin is retrieved for use in the calculation of the forward vector.
+     */
+    get originFrom(): OriginFrom { return _C(this, 5743) as OriginFrom; }
+    set originFrom(v: OriginFrom) { _C(this, 12204, v); }
+
+    /**
+     * If {@link originFrom} is {@link ORIGIN_FROM_SPECIFIC_BONE}, the bone global pose position specified for this is used as origin.
+     */
+    get originBoneName(): string { return _C(this, 5741) as string; }
+    set originBoneName(v: string) { _C(this, 12202, v); }
+
+    /**
+     * Index of the {@link originBoneName} in the parent {@link Skeleton3D}.
+     */
+    get originBone(): number { return _C(this, 5740) as number; }
+    set originBone(v: number) { _C(this, 12201, v); }
+
+    /**
+     * If {@link originFrom} is {@link ORIGIN_FROM_EXTERNAL_NODE}, the global position of the {@link Node3D} specified for this is used as origin.
+     */
+    get originExternalNode(): NodePath { return _C(this, 5742) as NodePath; }
+    set originExternalNode(v: NodePath) { _C(this, 12203, v); }
+
+    /**
+     * The offset of the bone pose origin. Matching the origins by offset is useful for cases where multiple bones must always face the same direction, such as the eyes.
+     * **Note:** This value indicates the local position of the object set in {@link originFrom}.
+     */
+    get originOffset(): Vector3 { return _C(this, 5744) as Vector3; }
+    set originOffset(v: Vector3) { _C(this, 12205, v); }
+
+    /**
+     * If the target passes through too close to the origin than this value, time-based interpolation is used even if the target is within the angular limitations, to prevent the angular velocity from becoming too high.
+     */
+    get originSafeMargin(): number { return _C(this, 5745) as number; }
+    set originSafeMargin(v: number) { _C(this, 12206, v); }
+
+    /**
+     * The duration of the time-based interpolation. Interpolation is triggered at the following cases:
+     * - When the target node is changed
+     * - When an axis is flipped due to angle limitation
+     * **Note:** The flipping occurs when the target is outside the angle limitation and the internally computed secondary rotation axis of the forward vector is flipped. Visually, it occurs when the target is outside the angle limitation and crosses the plane of the {@link forwardAxis} and {@link primaryRotationAxis}.
+     */
+    get duration(): number { return _C(this, 4590) as number; }
+    set duration(v: number) { _C(this, 11204, v); }
+
+    /**
+     * The transition type of the time-based interpolation. See also {@link Tween.TransitionType}.
+     */
+    get transitionType(): TransitionType { return _C(this, 6890) as TransitionType; }
+    set transitionType(v: TransitionType) { _C(this, 13141, v); }
+
+    /**
+     * The ease type of the time-based interpolation. See also {@link Tween.EaseType}.
+     */
+    get easeType(): EaseType { return _C(this, 4592) as EaseType; }
+    set easeType(v: EaseType) { _C(this, 11207, v); }
+
+    /**
+     * If `true`, limits the amount of rotation. For example, this helps to prevent a character's neck from rotating 360 degrees.
+     * **Note:** As with {@link AnimationTree} blending, interpolation is provided that favors {@link Skeleton3D.getBoneRest} or {@link Skeleton3D.getBonePose} depends on the {@link relative} option. This means that interpolation does not select the shortest path in some cases.
+     * **Note:** Some values for {@link transitionType} (such as {@link Tween.TRANS_BACK}, {@link Tween.TRANS_ELASTIC}, and {@link Tween.TRANS_SPRING}) may exceed the limitations. If interpolation occurs while overshooting the limitations, the result might not respect the bone rest.
+     */
+    get useAngleLimitation(): boolean { return _C(this, 8393) as boolean; }
+    set useAngleLimitation(v: boolean) { _C(this, 13195, v); }
+
+    /**
+     * If `true`, the limitations are spread from the bone symmetrically.
+     * If `false`, the limitation can be specified separately for each side of the bone rest.
+     */
+    get symmetryLimitation(): boolean { return _C(this, 8073) as boolean; }
+    set symmetryLimitation(v: boolean) { _C(this, 12958, v); }
+
+    /**
+     * The limit angle of the primary rotation when {@link symmetryLimitation} is `true`, in radians.
+     */
+    get primaryLimitAngle(): number { return _C(this, 6006) as number; }
+    set primaryLimitAngle(v: number) { _C(this, 12411, v); }
+
+    /**
+     * The threshold to start damping for {@link primaryLimitAngle}. It provides non-linear (b-spline) interpolation, let it feel more resistance the more it rotate to the edge limit. This is useful for simulating the limits of human motion.
+     * If `1.0`, no damping is performed. If `0.0`, damping is always performed.
+     */
+    get primaryDampThreshold(): number { return _C(this, 6004) as number; }
+    set primaryDampThreshold(v: number) { _C(this, 12409, v); }
+
+    /**
+     * The limit angle of positive side of the primary rotation when {@link symmetryLimitation} is `false`, in radians.
+     */
+    get primaryPositiveLimitAngle(): number { return _C(this, 6010) as number; }
+    set primaryPositiveLimitAngle(v: number) { _C(this, 12415, v); }
+
+    /**
+     * The threshold to start damping for {@link primaryPositiveLimitAngle}.
+     */
+    get primaryPositiveDampThreshold(): number { return _C(this, 6009) as number; }
+    set primaryPositiveDampThreshold(v: number) { _C(this, 12414, v); }
+
+    /**
+     * The limit angle of negative side of the primary rotation when {@link symmetryLimitation} is `false`, in radians.
+     */
+    get primaryNegativeLimitAngle(): number { return _C(this, 6008) as number; }
+    set primaryNegativeLimitAngle(v: number) { _C(this, 12413, v); }
+
+    /**
+     * The threshold to start damping for {@link primaryNegativeLimitAngle}.
+     */
+    get primaryNegativeDampThreshold(): number { return _C(this, 6007) as number; }
+    set primaryNegativeDampThreshold(v: number) { _C(this, 12412, v); }
+
+    /**
+     * The limit angle of the secondary rotation when {@link symmetryLimitation} is `true`, in radians.
+     */
+    get secondaryLimitAngle(): number { return _C(this, 6304) as number; }
+    set secondaryLimitAngle(v: number) { _C(this, 12669, v); }
+
+    /**
+     * The threshold to start damping for {@link secondaryLimitAngle}.
+     */
+    get secondaryDampThreshold(): number { return _C(this, 6303) as number; }
+    set secondaryDampThreshold(v: number) { _C(this, 12668, v); }
+
+    /**
+     * The limit angle of positive side of the secondary rotation when {@link symmetryLimitation} is `false`, in radians.
+     */
+    get secondaryPositiveLimitAngle(): number { return _C(this, 6308) as number; }
+    set secondaryPositiveLimitAngle(v: number) { _C(this, 12673, v); }
+
+    /**
+     * The threshold to start damping for {@link secondaryPositiveLimitAngle}.
+     */
+    get secondaryPositiveDampThreshold(): number { return _C(this, 6307) as number; }
+    set secondaryPositiveDampThreshold(v: number) { _C(this, 12672, v); }
+
+    /**
+     * The limit angle of negative side of the secondary rotation when {@link symmetryLimitation} is `false`, in radians.
+     */
+    get secondaryNegativeLimitAngle(): number { return _C(this, 6306) as number; }
+    set secondaryNegativeLimitAngle(v: number) { _C(this, 12671, v); }
+
+    /**
+     * The threshold to start damping for {@link secondaryNegativeLimitAngle}.
+     */
+    get secondaryNegativeDampThreshold(): number { return _C(this, 6305) as number; }
+    set secondaryNegativeDampThreshold(v: number) { _C(this, 12670, v); }
+
+    static readonly name = _R(401, LookAtModifier3D);
+}
+
+export const OriginFrom = {
+    /**
+     * The bone rest position of the bone specified in {@link bone} is used as origin.
+     */
+    ORIGIN_FROM_SELF: 0,
+    /**
+     * The bone global pose position of the bone specified in {@link originBone} is used as origin.
+     * **Note:** It is recommended that you select only the parent bone unless you are familiar with the bone processing process. The specified bone pose at the time the {@link LookAtModifier3D} is processed is used as a reference. In other words, if you specify a child bone and the {@link LookAtModifier3D} causes the child bone to move, the rendered result and direction will not match.
+     */
+    ORIGIN_FROM_SPECIFIC_BONE: 1,
+    /**
+     * The global position of the {@link Node3D} specified in {@link originExternalNode} is used as origin.
+     * **Note:** Same as {@link ORIGIN_FROM_SPECIFIC_BONE}, when specifying a {@link BoneAttachment3D} with a child bone assigned, the rendered result and direction will not match.
+     */
+    ORIGIN_FROM_EXTERNAL_NODE: 2,
+} as const;
+
+export type OriginFrom = (typeof OriginFrom)[keyof typeof OriginFrom];
+

package/gen/classes/MainLoop.ts

@@ -0,0 +1,115 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Signal } from '../heap-types/index.ts';
+
+/**
+ * {@link MainLoop} is the abstract base class for a Godot project's game loop. It is inherited by {@link SceneTree}, which is the default game loop implementation used in Godot projects, though it is also possible to write and use one's own {@link MainLoop} subclass instead of the scene tree.
+ * Upon the application start, a {@link MainLoop} implementation must be provided to the OS; otherwise, the application will exit. This happens automatically (and a {@link SceneTree} is created) unless a {@link MainLoop} {@link Script} is provided from the command line (with e.g. `godot -s my_loop.gd`) or the {@link ProjectSettings.application/run/mainLoopType} project setting is overwritten.
+ * Here is an example script implementing a simple {@link MainLoop}:
+ *
+ *
+ * ```gdscript
+ *
+ * class_name CustomMainLoop
+ * extends MainLoop
+ *
+ * var time_elapsed = 0
+ *
+ * func _initialize():
+ * 	print("Initialized:")
+ * 	print("  Starting time: %s" % str(time_elapsed))
+ *
+ * func _process(delta):
+ * 	time_elapsed += delta
+ * 	# Return true to end the main loop.
+ * 	return Input.get_mouse_button_mask() != 0 || Input.is_key_pressed(KEY_ESCAPE)
+ *
+ * func _finalize():
+ * 	print("Finalized:")
+ * 	print("  End time: %s" % str(time_elapsed))
+ *
+ * ```
+ */
+export class MainLoop extends Object {
+    constructor(name = 402) { super(name); }
+
+    /**
+     * Notification received from the OS when the application is exceeding its allocated memory.
+     * Specific to the iOS platform.
+     */
+    static readonly NOTIFICATION_OS_MEMORY_WARNING = 2009;
+
+    /**
+     * Notification received when translations may have changed. Can be triggered by the user changing the locale. Can be used to respond to language changes, for example to change the UI strings on the fly. Useful when working with the built-in translation support, like {@link Object.tr}.
+     */
+    static readonly NOTIFICATION_TRANSLATION_CHANGED = 2010;
+
+    /**
+     * Notification received from the OS when a request for "About" information is sent.
+     * Specific to the macOS platform.
+     */
+    static readonly NOTIFICATION_WM_ABOUT = 2011;
+
+    /**
+     * Notification received from Godot's crash handler when the engine is about to crash.
+     * Implemented on desktop platforms if the crash handler is enabled.
+     */
+    static readonly NOTIFICATION_CRASH = 2012;
+
+    /**
+     * Notification received from the OS when an update of the Input Method Engine occurs (e.g. change of IME cursor position or composition string).
+     * Implemented on desktop and web platforms.
+     */
+    static readonly NOTIFICATION_OS_IME_UPDATE = 2013;
+
+    /**
+     * Notification received from the OS when the application is resumed.
+     * Specific to the Android and iOS platforms.
+     */
+    static readonly NOTIFICATION_APPLICATION_RESUMED = 2014;
+
+    /**
+     * Notification received from the OS when the application is paused.
+     * Specific to the Android and iOS platforms.
+     * **Note:** On iOS, you only have approximately 5 seconds to finish a task started by this signal. If you go over this allotment, iOS will kill the app instead of pausing it.
+     */
+    static readonly NOTIFICATION_APPLICATION_PAUSED = 2015;
+
+    /**
+     * Notification received from the OS when the application is focused, i.e. when changing the focus from the OS desktop or a thirdparty application to any open window of the Godot instance.
+     * Implemented on desktop and mobile platforms.
+     */
+    static readonly NOTIFICATION_APPLICATION_FOCUS_IN = 2016;
+
+    /**
+     * Notification received from the OS when the application is defocused, i.e. when changing the focus from any open window of the Godot instance to the OS desktop or a thirdparty application.
+     * Implemented on desktop and mobile platforms.
+     */
+    static readonly NOTIFICATION_APPLICATION_FOCUS_OUT = 2017;
+
+    /**
+     * Notification received when text server is changed.
+     */
+    static readonly NOTIFICATION_TEXT_SERVER_CHANGED = 2018;
+
+    /**
+     * Notification received when the application enters picture-in-picture mode.
+     */
+    static readonly NOTIFICATION_APPLICATION_PIP_MODE_ENTERED = 2019;
+
+    /**
+     * Notification received when the application exits picture-in-picture mode.
+     */
+    static readonly NOTIFICATION_APPLICATION_PIP_MODE_EXITED = 2020;
+
+    /**
+     * Emitted when a user responds to a permission request.
+     */
+    get onRequestPermissionsResult(): Signal<(permission: string, granted: boolean) => void> { return _G(this, 9180) as Signal<(permission: string, granted: boolean) => void>; }
+    set onRequestPermissionsResult(v: ((permission: string, granted: boolean) => void) | null) { _G(this, 9180, v); }
+
+    static readonly name = _R(402, MainLoop);
+}

package/gen/classes/MarginContainer.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 { Container } from './Container.ts';
+
+/**
+ * {@link MarginContainer} adds an adjustable margin on each side of its child controls. The margins are added around all children, not around each individual one. To control the {@link MarginContainer}'s margins, use the `margin_*` theme properties listed below.
+ * **Note:** The margin sizes are theme overrides, not normal properties. This is an example of how to change them in code:
+ *
+ *
+ * ```gdscript
+ *
+ * # This code sample assumes the current script is extending MarginContainer.
+ * var margin_value = 100
+ * add_theme_constant_override("margin_top", margin_value)
+ * add_theme_constant_override("margin_left", margin_value)
+ * add_theme_constant_override("margin_bottom", margin_value)
+ * add_theme_constant_override("margin_right", margin_value)
+ *
+ * ```
+ */
+export class MarginContainer extends Container {
+    constructor(name = 403) { super(name); }
+
+    static readonly name = _R(403, MarginContainer);
+}

package/gen/classes/Marker2D.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+
+/**
+ * Generic 2D position hint for editing. It's just like a plain {@link Node2D}, but it displays as a cross in the 2D editor at all times. You can set the cross' visual size by using the gizmo in the 2D editor while the node is selected.
+ */
+export class Marker2D extends Node2D {
+    constructor(name = 404) { super(name); }
+
+    /**
+     * Size of the gizmo cross that appears in the editor.
+     */
+    get gizmoExtents(): number { return _C(this, 4920) as number; }
+    set gizmoExtents(v: number) { _C(this, 11512, v); }
+
+    static readonly name = _R(404, Marker2D);
+}

package/gen/classes/Marker3D.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+
+/**
+ * Generic 3D position hint for editing. It's just like a plain {@link Node3D}, but it displays as a cross in the 3D editor at all times.
+ */
+export class Marker3D extends Node3D {
+    constructor(name = 405) { super(name); }
+
+    /**
+     * Size of the gizmo cross that appears in the editor.
+     */
+    get gizmoExtents(): number { return _C(this, 4920) as number; }
+    set gizmoExtents(v: number) { _C(this, 11512, v); }
+
+    static readonly name = _R(405, Marker3D);
+}

package/gen/classes/Marshalls.ts

@@ -0,0 +1,50 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { PackedByteArray, Variant } from '../heap-types/index.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 406));
+
+/**
+ * Provides data transformation and encoding utility functions.
+ */
+export class Marshalls extends GodotVar {
+
+    /**
+     * Returns a Base64-encoded string of the {@link Variant} `variant`. If `fullObjects` is `true`, encoding objects is allowed (and can potentially include code).
+     * Internally, this uses the same encoding mechanism as the {@link varToBytes} method.
+     */
+    static variantToBase64(variant: Variant, fullObjects?: boolean /* = false */): string { return _C($(), 14676, variant, fullObjects) as string; }
+
+    /**
+     * Returns a decoded {@link Variant} corresponding to the Base64-encoded string `base64Str`. If `allowObjects` is `true`, decoding objects is allowed.
+     * Internally, this uses the same decoding mechanism as the {@link bytesToVar} method.
+     * **Warning:** Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution.
+     */
+    static base64ToVariant(base64Str: string, allowObjects?: boolean /* = false */): Variant { return _C($(), 1732, base64Str, allowObjects) as Variant; }
+
+    /**
+     * Returns a Base64-encoded string of a given {@link PackedByteArray}.
+     */
+    static rawToBase64(array: PackedByteArray): string { return _C($(), 9742, array) as string; }
+
+    /**
+     * Returns a decoded {@link PackedByteArray} corresponding to the Base64-encoded string `base64Str`.
+     */
+    static base64ToRaw(base64Str: string): PackedByteArray { return _C($(), 1730, base64Str) as PackedByteArray; }
+
+    /**
+     * Returns a Base64-encoded string of the UTF-8 string `utf8Str`.
+     */
+    static utf8ToBase64(utf8Str: string): string { return _C($(), 14646, utf8Str) as string; }
+
+    /**
+     * Returns a decoded string corresponding to the Base64-encoded string `base64Str`.
+     */
+    static base64ToUtf8(base64Str: string): string { return _C($(), 1731, base64Str) as string; }
+
+    static readonly name = _R(406, Marshalls);
+}

package/gen/classes/Material.ts

@@ -0,0 +1,53 @@
+// 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 { RID } from '../heap-types/index.ts';
+import type { Mode } from './CSGPolygon3D.ts';
+
+/**
+ * {@link Material} is a base resource used for coloring and shading geometry. All materials inherit from it and almost all {@link VisualInstance3D} derived nodes carry a {@link Material}. A few flags and parameters are shared between all material types and are configured here.
+ * Importantly, you can inherit from {@link Material} to create your own custom material type in script or in GDExtension.
+ */
+export class Material extends Resource {
+    constructor(name = 407) { super(name); }
+
+    /**
+     * Only available when running in the editor. Opens a popup that visualizes the generated shader code, including all variants and internal shader code. See also {@link Shader.inspectNativeShaderCode}.
+     */
+    inspectNativeShaderCode(): void { _C(this, 7638); }
+
+    /**
+     * Creates a placeholder version of this resource ({@link PlaceholderMaterial}).
+     */
+    createPlaceholder(): Resource { return _C(this, 2563) as Resource; }
+
+    /**
+     * Sets the render priority for objects in 3D scenes. Higher priority objects will be sorted in front of lower priority objects. In other words, all objects with {@link renderPriority} `1` will render on top of all objects with {@link renderPriority} `0`.
+     * **Note:** This only applies to {@link StandardMaterial3D}s and {@link ShaderMaterial}s with type "Spatial".
+     * **Note:** This will not impact how transparent objects are sorted relative to opaque objects or how dynamic meshes will be sorted relative to other opaque meshes. This is because all transparent objects are drawn after all opaque objects and all dynamic opaque meshes are drawn before other opaque meshes.
+     */
+    get renderPriority(): number { return _C(this, 6131) as number; }
+    set renderPriority(v: number) { _C(this, 12520, v); }
+
+    /**
+     * Sets the {@link Material} to be used for the next pass. This renders the object again using a different material.
+     * **Note:** {@link nextPass} materials are not necessarily drawn immediately after the source {@link Material}. Draw order is determined by material properties, {@link renderPriority}, and distance to camera.
+     * **Note:** This only applies to {@link StandardMaterial3D}s and {@link ShaderMaterial}s with type "Spatial".
+     */
+    get nextPass(): Material { return _C(this, 5628) as Material; }
+    set nextPass(v: Material) { _C(this, 12132, v); }
+
+    /**
+     * Maximum value for the {@link renderPriority} parameter.
+     */
+    static readonly RENDER_PRIORITY_MAX = 127;
+
+    /**
+     * Minimum value for the {@link renderPriority} parameter.
+     */
+    static readonly RENDER_PRIORITY_MIN = -128;
+
+    static readonly name = _R(407, Material);
+}