@ringozz/godot 0.1.0

package/gen/classes/UPNPDevice.ts

@@ -0,0 +1,116 @@
+// 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';
+
+/**
+ * Universal Plug and Play (UPnP) device. See {@link UPNP} for UPnP discovery and utility functions. Provides low-level access to UPNP control commands. Allows to manage port mappings (port forwarding) and to query network information of the device (like local and external IP address and status). Note that methods on this class are synchronous and block the calling thread.
+ */
+export class UPNPDevice extends RefCounted {
+    constructor(name = 818) { super(name); }
+
+    /**
+     * Returns `true` if this is a valid IGD (InternetGatewayDevice) which potentially supports port forwarding.
+     */
+    isValidGateway(): boolean { return _C(this, 8437) as boolean; }
+
+    /**
+     * Returns the external IP address of this {@link UPNPDevice} or an empty string.
+     */
+    queryExternalAddress(): string { return _C(this, 9688) as string; }
+
+    /**
+     * Adds a port mapping to forward the given external port on this {@link UPNPDevice} for the given protocol to the local machine. See {@link UPNP.addPortMapping}.
+     */
+    addPortMapping(port: number, portInternal?: number /* = 0 */, desc?: string /* = "" */, proto?: string /* = "UDP" */, duration?: number /* = 0 */): number { return _C(this, 1274, port, portInternal, desc, proto, duration) as number; }
+
+    /**
+     * Deletes the port mapping identified by the given port and protocol combination on this device. See {@link UPNP.deletePortMapping}.
+     */
+    deletePortMapping(port: number, proto?: string /* = "UDP" */): number { return _C(this, 2724, port, proto) as number; }
+
+    /**
+     * URL to the device description.
+     */
+    get descriptionUrl(): string { return _C(this, 4485) as string; }
+    set descriptionUrl(v: string) { _C(this, 11097, v); }
+
+    /**
+     * Service type.
+     */
+    get serviceType(): string { return _C(this, 6345) as string; }
+    set serviceType(v: string) { _C(this, 12697, v); }
+
+    /**
+     * IDG control URL.
+     */
+    get igdControlUrl(): string { return _C(this, 5066) as string; }
+    set igdControlUrl(v: string) { _C(this, 11657, v); }
+
+    /**
+     * IGD service type.
+     */
+    get igdServiceType(): string { return _C(this, 5068) as string; }
+    set igdServiceType(v: string) { _C(this, 11659, v); }
+
+    /**
+     * Address of the local machine in the network connecting it to this {@link UPNPDevice}.
+     */
+    get igdOurAddr(): string { return _C(this, 5067) as string; }
+    set igdOurAddr(v: string) { _C(this, 11658, v); }
+
+    /**
+     * IGD status.
+     */
+    get igdStatus(): IGDStatus { return _C(this, 5069) as IGDStatus; }
+    set igdStatus(v: IGDStatus) { _C(this, 11660, v); }
+
+    static readonly name = _R(818, UPNPDevice);
+}
+
+export const IGDStatus = {
+    /**
+     * OK.
+     */
+    IGD_STATUS_OK: 0,
+    /**
+     * HTTP error.
+     */
+    IGD_STATUS_HTTP_ERROR: 1,
+    /**
+     * Empty HTTP response.
+     */
+    IGD_STATUS_HTTP_EMPTY: 2,
+    /**
+     * Returned response contained no URLs.
+     */
+    IGD_STATUS_NO_URLS: 3,
+    /**
+     * Not a valid IGD.
+     */
+    IGD_STATUS_NO_IGD: 4,
+    /**
+     * Disconnected.
+     */
+    IGD_STATUS_DISCONNECTED: 5,
+    /**
+     * Unknown device.
+     */
+    IGD_STATUS_UNKNOWN_DEVICE: 6,
+    /**
+     * Invalid control.
+     */
+    IGD_STATUS_INVALID_CONTROL: 7,
+    /**
+     * Memory allocation error.
+     */
+    IGD_STATUS_MALLOC_ERROR: 8,
+    /**
+     * Unknown error.
+     */
+    IGD_STATUS_UNKNOWN_ERROR: 9,
+} as const;
+
+export type IGDStatus = (typeof IGDStatus)[keyof typeof IGDStatus];
+

package/gen/classes/UndoRedo.ts

@@ -0,0 +1,226 @@
+// 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 { Callable, Signal, StringName, Variant } from '../heap-types/index.ts';
+
+/**
+ * UndoRedo works by registering methods and property changes inside "actions". You can create an action, then provide ways to do and undo this action using function calls and property changes, then commit the action.
+ * When an action is committed, all of the `do_*` methods will run. If the {@link undo} method is used, the `undo_*` methods will run. If the {@link redo} method is used, once again, all of the `do_*` methods will run.
+ * Here's an example on how to add an action:
+ *
+ *
+ * ```gdscript
+ *
+ * var undo_redo = UndoRedo.new()
+ *
+ * func do_something():
+ * 	pass # Put your code here.
+ *
+ * func undo_something():
+ * 	pass # Put here the code that reverts what's done by "do_something()".
+ *
+ * func _on_my_button_pressed():
+ * 	var node = get_node("MyNode2D")
+ * 	undo_redo.create_action("Move the node")
+ * 	undo_redo.add_do_method(do_something)
+ * 	undo_redo.add_undo_method(undo_something)
+ * 	undo_redo.add_do_property(node, "position", Vector2(100, 100))
+ * 	undo_redo.add_undo_property(node, "position", node.position)
+ * 	undo_redo.commit_action()
+ *
+ * ```
+ *
+ *
+ *
+ * Before calling any of the `add_(un)do_*` methods, you need to first call {@link createAction}. Afterwards you need to call {@link commitAction}.
+ * If you don't need to register a method, you can leave {@link addDoMethod} and {@link addUndoMethod} out; the same goes for properties. You can also register more than one method/property.
+ * If you are making an {@link EditorPlugin} and want to integrate into the editor's undo history, use {@link EditorUndoRedoManager} instead.
+ * If you are registering multiple properties/method which depend on one another, be aware that by default undo operation are called in the same order they have been added. Therefore instead of grouping do operation with their undo operations it is better to group do on one side and undo on the other as shown below.
+ *
+ *
+ * ```gdscript
+ *
+ * undo_redo.create_action("Add object")
+ *
+ * # DO
+ * undo_redo.add_do_method(_create_object)
+ * undo_redo.add_do_method(_add_object_to_singleton)
+ *
+ * # UNDO
+ * undo_redo.add_undo_method(_remove_object_from_singleton)
+ * undo_redo.add_undo_method(_destroy_that_object)
+ *
+ * undo_redo.commit_action()
+ *
+ * ```
+ */
+export class UndoRedo extends Object {
+    constructor(name = 819) { super(name); }
+
+    /**
+     * Create a new action. After this is called, do all your calls to {@link addDoMethod}, {@link addUndoMethod}, {@link addDoProperty}, and {@link addUndoProperty}, then commit the action with {@link commitAction}.
+     * The way actions are merged is dictated by `mergeMode`.
+     * The way undo operation are ordered in actions is dictated by `backwardUndoOps`. When `backwardUndoOps` is `false` undo option are ordered in the same order they were added. Which means the first operation to be added will be the first to be undone.
+     */
+    createAction(name: string, mergeMode?: MergeMode /* = 0 */, backwardUndoOps?: boolean /* = false */): void { _C(this, 2507, name, mergeMode, backwardUndoOps); }
+
+    /**
+     * Commit the action. If `execute` is `true` (which it is by default), all "do" methods/properties are called/set when this function is called.
+     */
+    commitAction(execute?: boolean /* = true */): void { _C(this, 2383, execute); }
+
+    /**
+     * Returns `true` if the {@link UndoRedo} is currently committing the action, i.e. running its "do" method or property change (see {@link commitAction}).
+     */
+    isCommittingAction(): boolean { return _C(this, 7850) as boolean; }
+
+    /**
+     * Register a {@link Callable} that will be called when the action is committed.
+     */
+    addDoMethod(callable: Callable): void { _C(this, 1209, callable); }
+
+    /**
+     * Register a {@link Callable} that will be called when the action is undone.
+     */
+    addUndoMethod(callable: Callable): void { _C(this, 1324, callable); }
+
+    /**
+     * Register a `property` that would change its value to `value` when the action is committed.
+     */
+    addDoProperty(object: Object, property: StringName, value: Variant): void { _C(this, 1210, object, property, value); }
+
+    /**
+     * Register a `property` that would change its value to `value` when the action is undone.
+     */
+    addUndoProperty(object: Object, property: StringName, value: Variant): void { _C(this, 1325, object, property, value); }
+
+    /**
+     * Register a reference to an object that will be erased if the "do" history is deleted. This is useful for objects added by the "do" action and removed by the "undo" action.
+     * When the "do" history is deleted, if the object is a {@link RefCounted}, it will be unreferenced. Otherwise, it will be freed. Do not use for resources.
+     *
+     * ```text
+     *
+     * var node = Node2D.new()
+     * undo_redo.create_action("Add node")
+     * undo_redo.add_do_method(add_child.bind(node))
+     * undo_redo.add_do_reference(node)
+     * undo_redo.add_undo_method(remove_child.bind(node))
+     * undo_redo.commit_action()
+     *
+     * ```
+     */
+    addDoReference(object: Object): void { _C(this, 1211, object); }
+
+    /**
+     * Register a reference to an object that will be erased if the "undo" history is deleted. This is useful for objects added by the "undo" action and removed by the "do" action.
+     * When the "undo" history is deleted, if the object is a {@link RefCounted}, it will be unreferenced. Otherwise, it will be freed. Do not use for resources.
+     *
+     * ```text
+     *
+     * var node = $Node2D
+     * undo_redo.create_action("Remove node")
+     * undo_redo.add_do_method(remove_child.bind(node))
+     * undo_redo.add_undo_method(add_child.bind(node))
+     * undo_redo.add_undo_reference(node)
+     * undo_redo.commit_action()
+     *
+     * ```
+     */
+    addUndoReference(object: Object): void { _C(this, 1326, object); }
+
+    /**
+     * Marks the next "do" and "undo" operations to be processed even if the action gets merged with another in the {@link MERGE_ENDS} mode. Return to normal operation using {@link endForceKeepInMergeEnds}.
+     */
+    startForceKeepInMergeEnds(): void { _C(this, 13836); }
+
+    /**
+     * Stops marking operations as to be processed even if the action gets merged with another in the {@link MERGE_ENDS} mode. See {@link startForceKeepInMergeEnds}.
+     */
+    endForceKeepInMergeEnds(): void { _C(this, 3099); }
+
+    /**
+     * Returns how many elements are in the history.
+     */
+    getHistoryCount(): number { return _C(this, 5040) as number; }
+
+    /**
+     * Gets the index of the current action.
+     */
+    getCurrentAction(): number { return _C(this, 4342) as number; }
+
+    /**
+     * Gets the action name from its index.
+     */
+    getActionName(id: number): string { return _C(this, 3682, id) as string; }
+
+    /**
+     * Clear the undo/redo history and associated references.
+     * Passing `false` to `increaseVersion` will prevent the version number from increasing when the history is cleared.
+     */
+    clearHistory(increaseVersion?: boolean /* = true */): void { _C(this, 2273, increaseVersion); }
+
+    /**
+     * Gets the name of the current action, equivalent to `get_action_name(get_current_action())`.
+     */
+    getCurrentActionName(): string { return _C(this, 4343) as string; }
+
+    /**
+     * Returns `true` if an "undo" action is available.
+     */
+    hasUndo(): boolean { return _C(this, 7479) as boolean; }
+
+    /**
+     * Returns `true` if a "redo" action is available.
+     */
+    hasRedo(): boolean { return _C(this, 7434) as boolean; }
+
+    /**
+     * Gets the version. Every time a new action is committed, the {@link UndoRedo}'s version number is increased automatically.
+     * This is useful mostly to check if something changed from a saved version.
+     */
+    getVersion(): number { return _C(this, 7041) as number; }
+
+    /**
+     * Redo the last action. Returns `false` if there was no action to redo.
+     */
+    redo(): boolean { return _C(this, 9770) as boolean; }
+
+    /**
+     * Undo the last action. Returns `false` if there was no action to undo.
+     */
+    undo(): boolean { return _C(this, 14462) as boolean; }
+
+    /**
+     * The maximum number of steps that can be stored in the undo/redo history. If the number of stored steps exceeds this limit, older steps are removed from history and can no longer be reached by calling {@link undo}. A value of `0` or lower means no limit.
+     */
+    get maxSteps(): number { return _C(this, 5489) as number; }
+    set maxSteps(v: number) { _C(this, 12011, v); }
+
+    /**
+     * Called when {@link undo} or {@link redo} was called.
+     */
+    get versionChanged(): Signal<() => void> { return _G(this, 14689) as Signal<() => void>; }
+    set versionChanged(v: (() => void) | null) { _G(this, 14689, v); }
+
+    static readonly name = _R(819, UndoRedo);
+}
+
+export const MergeMode = {
+    /**
+     * Makes "do"/"undo" operations stay in separate actions.
+     */
+    MERGE_DISABLE: 0,
+    /**
+     * Merges this action with the previous one if they have the same name. Keeps only the first action's "undo" operations and the last action's "do" operations. Useful for sequential changes to a single value.
+     */
+    MERGE_ENDS: 1,
+    /**
+     * Merges this action with the previous one if they have the same name.
+     */
+    MERGE_ALL: 2,
+} as const;
+
+export type MergeMode = (typeof MergeMode)[keyof typeof MergeMode];
+

package/gen/classes/UniformSetCacheRD.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';
+import type { GodotArray, RID } from '../heap-types/index.ts';
+import type { RDUniform } from './RDUniform.ts';
+
+/**
+ * Uniform set cache manager for {@link RenderingDevice}-based renderers. Provides a way to create a uniform set and reuse it in subsequent calls for as long as the uniform set exists. Uniform set will automatically be cleaned up when dependent objects are freed.
+ */
+export class UniformSetCacheRD extends Object {
+    constructor(name = 820) { super(name); }
+
+    /**
+     * Creates/returns a cached uniform set based on the provided uniforms for a given shader.
+     */
+    static getCache(shader: RID, set: number /* uint32 */, uniforms: GodotArray<RDUniform>): RID { return _C(820, 4042, shader, set, uniforms) as RID; }
+
+    static readonly name = _R(820, UniformSetCacheRD);
+}

package/gen/classes/VBoxContainer.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { BoxContainer } from './BoxContainer.ts';
+
+/**
+ * A variant of {@link BoxContainer} that can only arrange its child controls vertically. Child controls are rearranged automatically when their minimum size changes.
+ */
+export class VBoxContainer extends BoxContainer {
+    constructor(name = 821) { super(name); }
+
+    static readonly name = _R(821, VBoxContainer);
+}

package/gen/classes/VFlowContainer.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { FlowContainer } from './FlowContainer.ts';
+
+/**
+ * A variant of {@link FlowContainer} that can only arrange its child controls vertically, wrapping them around at the borders. This is similar to how text in a book wraps around when no more words can fit on a line, except vertically.
+ */
+export class VFlowContainer extends FlowContainer {
+    constructor(name = 822) { super(name); }
+
+    static readonly name = _R(822, VFlowContainer);
+}

package/gen/classes/VScrollBar.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { ScrollBar } from './ScrollBar.ts';
+
+/**
+ * A vertical scrollbar, typically used to navigate through content that extends beyond the visible height of a control. It is a {@link Range}-based control and goes from top (min) to bottom (max). Note that this direction is the opposite of {@link VSlider}'s.
+ */
+export class VScrollBar extends ScrollBar {
+    constructor(name = 823) { super(name); }
+
+    static readonly name = _R(823, VScrollBar);
+}

package/gen/classes/VSeparator.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Separator } from './Separator.ts';
+
+/**
+ * A vertical separator used for separating other controls that are arranged **horizontally**. {@link VSeparator} is purely visual and normally drawn as a {@link StyleBoxLine}.
+ */
+export class VSeparator extends Separator {
+    constructor(name = 824) { super(name); }
+
+    static readonly name = _R(824, VSeparator);
+}

package/gen/classes/VSlider.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Slider } from './Slider.ts';
+
+/**
+ * A vertical slider, used to adjust a value by moving a grabber along a vertical axis. It is a {@link Range}-based control and goes from bottom (min) to top (max). Note that this direction is the opposite of {@link VScrollBar}'s.
+ */
+export class VSlider extends Slider {
+    constructor(name = 825) { super(name); }
+
+    static readonly name = _R(825, VSlider);
+}

package/gen/classes/VSplitContainer.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SplitContainer } from './SplitContainer.ts';
+
+/**
+ * A container that accepts only two child controls, then arranges them vertically and creates a divisor between them. The divisor can be dragged around to change the size relation between the child controls.
+ */
+export class VSplitContainer extends SplitContainer {
+    constructor(name = 826) { super(name); }
+
+    static readonly name = _R(826, VSplitContainer);
+}

package/gen/classes/VehicleBody3D.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 { RigidBody3D } from './RigidBody3D.ts';
+
+/**
+ * This physics body implements all the physics logic needed to simulate a car. It is based on the raycast vehicle system commonly found in physics engines. Aside from a {@link CollisionShape3D} for the main body of the vehicle, you must also add a {@link VehicleWheel3D} node for each wheel. You should also add a {@link MeshInstance3D} to this node for the 3D model of the vehicle, but this model should generally not include meshes for the wheels. You can control the vehicle by using the {@link brake}, {@link engineForce}, and {@link steering} properties. The position or orientation of this node shouldn't be changed directly.
+ * **Note:** The local forward for this node is {@link Vector3.MODEL_FRONT}.
+ * **Note:** The origin point of your VehicleBody3D will determine the center of gravity of your vehicle. To make the vehicle more grounded, the origin point is usually kept low, moving the {@link CollisionShape3D} and {@link MeshInstance3D} upwards.
+ * **Note:** This class has known issues and isn't designed to provide realistic 3D vehicle physics. If you want advanced vehicle physics, you may have to write your own physics integration using {@link CharacterBody3D} or {@link RigidBody3D}.
+ */
+export class VehicleBody3D extends RigidBody3D {
+    constructor(name = 827) { super(name); }
+
+    /**
+     * Accelerates the vehicle by applying an engine force. The vehicle is only sped up if the wheels that have {@link VehicleWheel3D.useAsTraction} set to `true` and are in contact with a surface. The {@link RigidBody3D.mass} of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration.
+     * **Note:** The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears.
+     * A negative value will result in the vehicle reversing.
+     */
+    get engineForce(): number { return _C(this, 4670) as number; }
+    set engineForce(v: number) { _C(this, 11297, v); }
+
+    /**
+     * Slows down the vehicle by applying a braking force. The vehicle is only slowed down if the wheels are in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the {@link RigidBody3D.mass} of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking.
+     */
+    get brake(): number { return _C(this, 4000) as number; }
+    set brake(v: number) { _C(this, 10736, v); }
+
+    /**
+     * The steering angle for the vehicle. Setting this to a non-zero value will result in the vehicle turning when it's moving. Wheels that have {@link VehicleWheel3D.useAsSteering} set to `true` will automatically be rotated.
+     * **Note:** This property is edited in the inspector in degrees. In code the property is set in radians.
+     */
+    get steering(): number { return _C(this, 6546) as number; }
+    set steering(v: number) { _C(this, 12884, v); }
+
+    static readonly name = _R(827, VehicleBody3D);
+}

package/gen/classes/VehicleWheel3D.ts

@@ -0,0 +1,134 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * A node used as a child of a {@link VehicleBody3D} parent to simulate the behavior of one of its wheels. This node also acts as a collider to detect if the wheel is touching a surface.
+ * **Note:** This class has known issues and isn't designed to provide realistic 3D vehicle physics. If you want advanced vehicle physics, you may need to write your own physics integration using another {@link PhysicsBody3D} class.
+ */
+export class VehicleWheel3D extends Node3D {
+    constructor(name = 828) { super(name); }
+
+    /**
+     * Returns `true` if this wheel is in contact with a surface.
+     */
+    isInContact(): boolean { return _C(this, 8013) as boolean; }
+
+    /**
+     * Returns the contacting body node if valid in the tree, as {@link Node3D}. At the moment, {@link GridMap} is not supported so the node will be always of type {@link PhysicsBody3D}.
+     * Returns `null` if the wheel is not in contact with a surface, or the contact body is not a {@link PhysicsBody3D}.
+     */
+    getContactBody(): Node3D | null { return _C(this, 4294) as Node3D | null; }
+
+    /**
+     * Returns the point of the suspension's collision in world space if the wheel is in contact. If the wheel isn't in contact with anything, returns the maximum point of the wheel's ray cast in world space, which is defined by `wheel_rest_length + wheel_radius`.
+     */
+    getContactPoint(): Vector3 { return _C(this, 4308) as Vector3; }
+
+    /**
+     * Returns the normal of the suspension's collision in world space if the wheel is in contact. If the wheel isn't in contact with anything, returns a vector pointing directly along the suspension axis toward the vehicle in world space.
+     */
+    getContactNormal(): Vector3 { return _C(this, 4307) as Vector3; }
+
+    /**
+     * Returns a value between 0.0 and 1.0 that indicates whether this wheel is skidding. 0.0 is skidding (the wheel has lost grip, e.g. icy terrain), 1.0 means not skidding (the wheel has full grip, e.g. dry asphalt road).
+     */
+    getSkidinfo(): number { return _C(this, 6412) as number; }
+
+    /**
+     * Returns the rotational speed of the wheel in revolutions per minute.
+     */
+    getRpm(): number { return _C(this, 6223) as number; }
+
+    /**
+     * Accelerates the wheel by applying an engine force. The wheel is only sped up if it is in contact with a surface. The {@link RigidBody3D.mass} of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration.
+     * **Note:** The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears.
+     * A negative value will result in the wheel reversing.
+     */
+    get engineForce(): number { return _C(this, 4670) as number; }
+    set engineForce(v: number) { _C(this, 11297, v); }
+
+    /**
+     * Slows down the wheel by applying a braking force. The wheel is only slowed down if it is in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the {@link RigidBody3D.mass} of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking.
+     */
+    get brake(): number { return _C(this, 4000) as number; }
+    set brake(v: number) { _C(this, 10736, v); }
+
+    /**
+     * The steering angle for the wheel, in radians. Setting this to a non-zero value will result in the vehicle turning when it's moving.
+     */
+    get steering(): number { return _C(this, 6546) as number; }
+    set steering(v: number) { _C(this, 12884, v); }
+
+    /**
+     * If `true`, this wheel transfers engine force to the ground to propel the vehicle forward. This value is used in conjunction with {@link VehicleBody3D.engineForce} and ignored if you are using the per-wheel {@link engineForce} value instead.
+     */
+    get useAsTraction(): boolean { return _C(this, 8388) as boolean; }
+    set useAsTraction(v: boolean) { _C(this, 13198, v); }
+
+    /**
+     * If `true`, this wheel will be turned when the car steers. This value is used in conjunction with {@link VehicleBody3D.steering} and ignored if you are using the per-wheel {@link steering} value instead.
+     */
+    get useAsSteering(): boolean { return _C(this, 8387) as boolean; }
+    set useAsSteering(v: boolean) { _C(this, 13197, v); }
+
+    /**
+     * This value affects the roll of your vehicle. If set to 1.0 for all wheels, your vehicle will resist body roll, while a value of 0.0 will be prone to rolling over.
+     */
+    get wheelRollInfluence(): number { return _C(this, 6186) as number; }
+    set wheelRollInfluence(v: number) { _C(this, 12563, v); }
+
+    /**
+     * The radius of the wheel in meters.
+     */
+    get wheelRadius(): number { return _C(this, 6068) as number; }
+    set wheelRadius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * This is the distance in meters the wheel is lowered from its origin point. Don't set this to 0.0 and move the wheel into position, instead move the origin point of your wheel (the gizmo in Godot) to the position the wheel will take when bottoming out, then use the rest length to move the wheel down to the position it should be in when the car is in rest.
+     */
+    get wheelRestLength(): number { return _C(this, 6639) as number; }
+    set wheelRestLength(v: number) { _C(this, 12944, v); }
+
+    /**
+     * This determines how much grip this wheel has. It is combined with the friction setting of the surface the wheel is in contact with. 0.0 means no grip, 1.0 is normal grip. For a drift car setup, try setting the grip of the rear wheels slightly lower than the front wheels, or use a lower value to simulate tire wear.
+     * It's best to set this to 1.0 when starting out.
+     */
+    get wheelFrictionSlip(): number { return _C(this, 4898) as number; }
+    set wheelFrictionSlip(v: number) { _C(this, 11491, v); }
+
+    /**
+     * This is the distance the suspension can travel. As Godot units are equivalent to meters, keep this setting relatively low. Try a value between 0.1 and 0.3 depending on the type of car.
+     */
+    get suspensionTravel(): number { return _C(this, 6641) as number; }
+    set suspensionTravel(v: number) { _C(this, 12946, v); }
+
+    /**
+     * The stiffness of the suspension, measured in Newtons per millimeter (N/mm), or megagrams per second squared (Mg/s²). Use a value lower than 50 for an off-road car, a value between 50 and 100 for a race car and try something around 200 for something like a Formula 1 car.
+     */
+    get suspensionStiffness(): number { return _C(this, 6640) as number; }
+    set suspensionStiffness(v: number) { _C(this, 12945, v); }
+
+    /**
+     * The maximum force the spring can resist. This value should be higher than a quarter of the {@link RigidBody3D.mass} of the {@link VehicleBody3D} or the spring will not carry the weight of the vehicle. Good results are often obtained by a value that is about 3× to 4× this number.
+     */
+    get suspensionMaxForce(): number { return _C(this, 6638) as number; }
+    set suspensionMaxForce(v: number) { _C(this, 12943, v); }
+
+    /**
+     * The damping applied to the suspension spring when being compressed, meaning when the wheel is moving up relative to the vehicle. It is measured in Newton-seconds per millimeter (N⋅s/mm), or megagrams per second (Mg/s). This value should be between 0.0 (no damping) and 1.0, but may be more. A value of 0.0 means the car will keep bouncing as the spring keeps its energy. A good value for this is around 0.3 for a normal car, 0.5 for a race car.
+     */
+    get dampingCompression(): number { return _C(this, 4407) as number; }
+    set dampingCompression(v: number) { _C(this, 11031, v); }
+
+    /**
+     * The damping applied to the suspension spring when rebounding or extending, meaning when the wheel is moving down relative to the vehicle. It is measured in Newton-seconds per millimeter (N⋅s/mm), or megagrams per second (Mg/s). This value should be between 0.0 (no damping) and 1.0, but may be more. This value should always be slightly higher than the {@link dampingCompression} property. For a {@link dampingCompression} value of 0.3, try a relaxation value of 0.5.
+     */
+    get dampingRelaxation(): number { return _C(this, 4409) as number; }
+    set dampingRelaxation(v: number) { _C(this, 11033, v); }
+
+    static readonly name = _R(828, VehicleWheel3D);
+}

package/gen/classes/VideoStream.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 { Resource } from './Resource.ts';
+import type { VideoStreamPlayback } from './VideoStreamPlayback.ts';
+
+/**
+ * Base resource type for all video streams. Classes that derive from {@link VideoStream} can all be used as resource types to play back videos in {@link VideoStreamPlayer}.
+ */
+export class VideoStream extends Resource {
+    constructor(name = 829) { super(name); }
+
+    /**
+     * The video file path or URI that this {@link VideoStream} resource handles.
+     * For {@link VideoStreamTheora}, this filename should be an Ogg Theora video file with the `.ogv` extension.
+     */
+    get file(): string { return _C(this, 4770) as string; }
+    set file(v: string) { _C(this, 11378, v); }
+
+    static readonly name = _R(829, VideoStream);
+}