@ringozz/godot 0.1.0

package/gen/classes/RDUniform.ts

@@ -0,0 +1,43 @@
+// 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, RID } from '../heap-types/index.ts';
+import type { UniformType } from './RenderingDevice.ts';
+
+/**
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDUniform extends RefCounted {
+    constructor(name = 633) { super(name); }
+
+    /**
+     * Binds the given id to the uniform. The data associated with the id is then used when the uniform is passed to a shader.
+     */
+    addId(id: RID): void { _C(this, 1234, id); }
+
+    /**
+     * Unbinds all ids currently bound to the uniform.
+     */
+    clearIds(): void { _C(this, 2275); }
+
+    /**
+     * Returns an array of all ids currently bound to the uniform.
+     */
+    getIds(): GodotArray<RID> { return _C(this, 5065) as GodotArray<RID>; }
+
+    /**
+     * The uniform's data type.
+     */
+    get uniformType(): UniformType { return _C(this, 6949) as UniformType; }
+    set uniformType(v: UniformType) { _C(this, 13170, v); }
+
+    /**
+     * The uniform's binding.
+     */
+    get binding(): number { return _C(this, 3919) as number; }
+    set binding(v: number) { _C(this, 10666, v); }
+
+    static readonly name = _R(633, RDUniform);
+}

package/gen/classes/RDVertexAttribute.ts

@@ -0,0 +1,52 @@
+// 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 { DataFormat, VertexFrequency } from './RenderingDevice.ts';
+
+/**
+ * This object is used by {@link RenderingDevice}.
+ */
+export class RDVertexAttribute extends RefCounted {
+    constructor(name = 634) { super(name); }
+
+    /**
+     * The index of the buffer in the vertex buffer array to bind this vertex attribute. When set to `-1`, it defaults to the index of the attribute.
+     * **Note:** You cannot mix binding explicitly assigned attributes with implicitly assigned ones (i.e. `-1`). Either all attributes must have their binding set to `-1`, or all must have explicit bindings.
+     */
+    get binding(): number { return _C(this, 3919) as number; }
+    set binding(v: number) { _C(this, 10666, v); }
+
+    /**
+     * The location in the shader that this attribute is bound to.
+     */
+    get location(): number { return _C(this, 5409) as number; }
+    set location(v: number) { _C(this, 11945, v); }
+
+    /**
+     * The number of bytes between the start of the vertex buffer and the first instance of this attribute.
+     */
+    get offset(): number { return _C(this, 5703) as number; }
+    set offset(v: number) { _C(this, 12170, v); }
+
+    /**
+     * The way that this attribute's data is interpreted when sent to a shader.
+     */
+    get format(): DataFormat { return _C(this, 4861) as DataFormat; }
+    set format(v: DataFormat) { _C(this, 11465, v); }
+
+    /**
+     * The number of bytes between the starts of consecutive instances of this attribute.
+     */
+    get stride(): number { return _C(this, 6573) as number; }
+    set stride(v: number) { _C(this, 12911, v); }
+
+    /**
+     * The rate at which this attribute is pulled from its vertex buffer.
+     */
+    get frequency(): VertexFrequency { return _C(this, 4896) as VertexFrequency; }
+    set frequency(v: VertexFrequency) { _C(this, 11489, v); }
+
+    static readonly name = _R(634, RDVertexAttribute);
+}

package/gen/classes/RandomNumberGenerator.ts

@@ -0,0 +1,114 @@
+// 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 { PackedFloat32Array } from '../heap-types/index.ts';
+
+/**
+ * RandomNumberGenerator is a class for generating pseudo-random numbers. It currently uses [PCG32](https://www.pcg-random.org/).
+ * **Note:** The underlying algorithm is an implementation detail and should not be depended upon.
+ * To generate a random float number (within a given range) based on a time-dependent seed:
+ *
+ * ```text
+ *
+ * var rng = RandomNumberGenerator.new()
+ * func _ready():
+ * 	var my_random_number = rng.randf_range(-10.0, 10.0)
+ *
+ * ```
+ */
+export class RandomNumberGenerator extends RefCounted {
+    constructor(name = 635) { super(name); }
+
+    /**
+     * Returns a pseudo-random 32-bit unsigned integer between `0` and `4294967295` (inclusive).
+     */
+    randi(): number { return _C(this, 9724) as number; }
+
+    /**
+     * Returns a pseudo-random float between `0.0` and `1.0` (inclusive).
+     */
+    randf(): number { return _C(this, 9721) as number; }
+
+    /**
+     * Returns a [normally-distributed](https://en.wikipedia.org/wiki/Normal_distribution), pseudo-random floating-point number from the specified `mean` and a standard `deviation`. This is also known as a Gaussian distribution.
+     * **Note:** This method uses the [Box-Muller transform](https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform) algorithm.
+     */
+    randfn(mean?: number /* = 0.0 */, deviation?: number /* = 1.0 */): number { return _C(this, 9723, mean, deviation) as number; }
+
+    /**
+     * Returns a pseudo-random float between `from` and `to` (inclusive).
+     */
+    randfRange(from: number, to: number): number { return _C(this, 9722, from, to) as number; }
+
+    /**
+     * Returns a pseudo-random 32-bit signed integer between `from` and `to` (inclusive).
+     */
+    randiRange(from: number, to: number): number { return _C(this, 9725, from, to) as number; }
+
+    /**
+     * Returns a random integer between `0` and the size of the array that is passed as a parameter. Each value in the array should be a floating-point number that represents the relative likelihood that it will be returned as an index. A higher value means the value is more likely to be returned as an index, while a value of `0` means it will never be returned as an index.
+     * For example, if {@link code skip-lint}{@link 0.5, 1, 1, 2} is passed as a parameter, then the method is twice as likely to return `3` (the index of the value `2`) and twice as unlikely to return `0` (the index of the value `0.5`) compared to the indices `1` and `2`.
+     * Prints an error and returns `-1` if the array is empty.
+     *
+     *
+     * ```gdscript
+     *
+     * var rng = RandomNumberGenerator.new()
+     *
+     * var my_array = ["one", "two", "three", "four"]
+     * var weights = PackedFloat32Array([0.5, 1, 1, 2])
+     *
+     * # Prints one of the four elements in `my_array`.
+     * # It is more likely to print "four", and less likely to print "one".
+     * print(my_array[rng.rand_weighted(weights)])
+     *
+     * ```
+     */
+    randWeighted(weights: PackedFloat32Array): number { return _C(this, 9720, weights) as number; }
+
+    /**
+     * Sets up a time-based seed for this {@link RandomNumberGenerator} instance. Unlike the `@GlobalScope` random number generation functions, different {@link RandomNumberGenerator} instances can use different seeds.
+     */
+    randomize(): void { _C(this, 9729); }
+
+    /**
+     * Initializes the random number generator state based on the given seed value. A given seed will give a reproducible sequence of pseudo-random numbers.
+     * **Note:** The RNG does not have an avalanche effect, and can output similar random streams given similar seeds. Consider using a hash function to improve your seed quality if they're sourced externally.
+     * **Note:** The default value of this property is pseudo-random, and changes when calling {@link randomize}. The `0` value documented here is a placeholder, and not the actual default seed.
+     * **Note:** Setting this property produces a side effect of changing the internal {@link state}, so make sure to initialize the seed *before* modifying the {@link state}:
+     *
+     * ```text
+     *
+     * var rng = RandomNumberGenerator.new()
+     * rng.seed = hash("Godot")
+     * rng.state = 100 # Restore to some previously saved state.
+     *
+     * ```
+     */
+    get seed(): number { return _C(this, 6317) as number; }
+    set seed(v: number) { _C(this, 12682, v); }
+
+    /**
+     * The current state of the random number generator. Save and restore this property to restore the generator to a previous state:
+     *
+     * ```text
+     *
+     * var rng = RandomNumberGenerator.new()
+     * print(rng.randf())
+     * var saved_state = rng.state # Store current state.
+     * print(rng.randf()) # Advance internal state.
+     * rng.state = saved_state # Restore the state.
+     * print(rng.randf()) # Prints the same value as previously.
+     *
+     * ```
+     *
+     * **Note:** Do not set state to arbitrary values, since the random number generator requires the state to have certain qualities to behave properly. It should only be set to values that came from the state property itself. To initialize the random number generator with arbitrary input, use {@link seed} instead.
+     * **Note:** The default value of this property is pseudo-random, and changes when calling {@link randomize}. The `0` value documented here is a placeholder, and not the actual default state.
+     */
+    get state(): number { return _C(this, 6537) as number; }
+    set state(v: number) { _C(this, 12882, v); }
+
+    static readonly name = _R(635, RandomNumberGenerator);
+}

package/gen/classes/Range.ts

@@ -0,0 +1,104 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Node } from './Node.ts';
+
+/**
+ * Range is an abstract base class for controls that represent a number within a range, using a configured {@link step} and {@link page} size. See e.g. {@link ScrollBar} and {@link Slider} for examples of higher-level nodes using Range.
+ */
+export class Range extends Control {
+    constructor(name = 636) { super(name); }
+
+    /**
+     * Sets the {@link Range}'s current value to the specified `value`, without emitting the {@link value_changed} signal.
+     */
+    setValueNoSignal(value: number /* double */): void { _C(this, 13270, value); }
+
+    /**
+     * Binds two {@link Range}s together along with any ranges previously grouped with either of them. When any of range's member variables change, it will share the new value with all other ranges in its group.
+     */
+    share(_with: Node): void { _C(this, 13561, _with); }
+
+    /**
+     * Stops the {@link Range} from sharing its member variables with any other.
+     */
+    unshare(): void { _C(this, 14499); }
+
+    /**
+     * Minimum value. Range is clamped if {@link value} is less than {@link minValue}.
+     */
+    get minValue(): number { return _C(this, 5537) as number; }
+    set minValue(v: number) { _C(this, 12048, v); }
+
+    /**
+     * Maximum value. Range is clamped if {@link value} is greater than {@link maxValue}.
+     */
+    get maxValue(): number { return _C(this, 5456) as number; }
+    set maxValue(v: number) { _C(this, 11982, v); }
+
+    /**
+     * If greater than `0.0`, {@link value} will always be rounded to a multiple of this property's value above {@link minValue}. For example, if {@link minValue} is `0.1` and step is `0.2`, then {@link value} is limited to `0.1`, `0.3`, `0.5`, and so on. If {@link rounded} is also `true`, {@link value} will first be rounded to a multiple of this property's value, then rounded to the nearest integer.
+     */
+    get step(): number { return _C(this, 6553) as number; }
+    set step(v: number) { _C(this, 12891, v); }
+
+    /**
+     * Page size. Used mainly for {@link ScrollBar}. A {@link ScrollBar}'s grabber length is the {@link ScrollBar}'s size multiplied by {@link page} over the difference between {@link minValue} and {@link maxValue}.
+     */
+    get page(): number { return _C(this, 5794) as number; }
+    set page(v: number) { _C(this, 12237, v); }
+
+    /**
+     * Range's current value. Changing this property (even via code) will trigger {@link value_changed} signal. Use {@link setValueNoSignal} if you want to avoid it.
+     */
+    get value(): number { return _C(this, 7018) as number; }
+    set value(v: number) { _C(this, 13268, v); }
+
+    /**
+     * The value mapped between 0 and 1.
+     */
+    get ratio(): number { return _C(this, 3797) as number; }
+    set ratio(v: number) { _C(this, 10541, v); }
+
+    /**
+     * If `true`, and {@link minValue} is greater or equal to `0`, {@link value} will be represented exponentially rather than linearly.
+     */
+    get expEdit(): boolean { return _C(this, 8225) as boolean; }
+    set expEdit(v: boolean) { _C(this, 11319, v); }
+
+    /**
+     * If `true`, {@link value} will always be rounded to the nearest integer.
+     */
+    get rounded(): boolean { return _C(this, 8418) as boolean; }
+    set rounded(v: boolean) { _C(this, 13236, v); }
+
+    /**
+     * If `true`, {@link value} may be greater than {@link maxValue}.
+     */
+    get allowGreater(): boolean { return _C(this, 7977) as boolean; }
+    set allowGreater(v: boolean) { _C(this, 10454, v); }
+
+    /**
+     * If `true`, {@link value} may be less than {@link minValue}.
+     */
+    get allowLesser(): boolean { return _C(this, 8068) as boolean; }
+    set allowLesser(v: boolean) { _C(this, 10455, v); }
+
+    /**
+     * Emitted when {@link value} changes. When used on a {@link Slider}, this is called continuously while dragging (potentially every frame). If you are performing an expensive operation in a function connected to {@link value_changed}, consider using a *debouncing* {@link Timer} to call the function less often.
+     * **Note:** Unlike signals such as {@link LineEdit.text_changed}, {@link value_changed} is also emitted when `value` is set directly via code.
+     */
+    get valueChanged(): Signal<(value: number) => void> { return _G(this, 14667) as Signal<(value: number) => void>; }
+    set valueChanged(v: ((value: number) => void) | null) { _G(this, 14667, v); }
+
+    /**
+     * Emitted when {@link minValue}, {@link maxValue}, {@link page}, or {@link step} change.
+     */
+    get changed(): Signal<() => void> { return _G(this, 2190) as Signal<() => void>; }
+    set changed(v: (() => void) | null) { _G(this, 2190, v); }
+
+    static readonly name = _R(636, Range);
+}

package/gen/classes/RayCast2D.ts

@@ -0,0 +1,148 @@
+// 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';
+import type { RID } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { CollisionObject2D } from './CollisionObject2D.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * A raycast represents a ray from its origin to its {@link targetPosition} that finds the closest object along its path, if it intersects any.
+ * {@link RayCast2D} can ignore some objects by adding them to an exception list, by making its detection reporting ignore {@link Area2D}s ({@link collideWithAreas}) or {@link PhysicsBody2D}s ({@link collideWithBodies}), or by configuring physics layers.
+ * {@link RayCast2D} calculates intersection every physics frame, and it holds the result until the next physics frame. For an immediate raycast, or if you want to configure a {@link RayCast2D} multiple times within the same physics frame, use {@link forceRaycastUpdate}.
+ * To sweep over a region of 2D space, you can approximate the region with multiple {@link RayCast2D}s or use {@link ShapeCast2D}.
+ */
+export class RayCast2D extends Node2D {
+    constructor(name = 637) { super(name); }
+
+    /**
+     * Returns whether any object is intersecting with the ray's vector (considering the vector length).
+     */
+    isColliding(): boolean { return _C(this, 7841) as boolean; }
+
+    /**
+     * Updates the collision information for the ray immediately, without waiting for the next `_physics_process` call. Use this method, for example, when the ray or its parent has changed state.
+     * **Note:** {@link enabled} does not need to be `true` for this to work.
+     */
+    forceRaycastUpdate(): void { _C(this, 3534); }
+
+    /**
+     * Returns the first object that the ray intersects, or `null` if no object is intersecting the ray (i.e. {@link isColliding} returns `false`).
+     * **Note:** This object is not guaranteed to be a {@link CollisionObject2D}. For example, if the ray intersects a {@link TileMapLayer}, the method will return a {@link TileMapLayer} instance.
+     */
+    getCollider(): Object | null { return _C(this, 4188) as Object | null; }
+
+    /**
+     * Returns the {@link RID} of the first object that the ray intersects, or an empty {@link RID} if no object is intersecting the ray (i.e. {@link isColliding} returns `false`).
+     */
+    getColliderRid(): RID { return _C(this, 4190) as RID; }
+
+    /**
+     * Returns the shape ID of the first object that the ray intersects, or `0` if no object is intersecting the ray (i.e. {@link isColliding} returns `false`).
+     * To get the intersected shape node, for a {@link CollisionObject2D} target, use:
+     *
+     *
+     * ```gdscript
+     *
+     * var target = get_collider() # A CollisionObject2D.
+     * var shape_id = get_collider_shape() # The shape index in the collider.
+     * var owner_id = target.shape_find_owner(shape_id) # The owner ID in the collider.
+     * var shape = target.shape_owner_get_owner(owner_id)
+     *
+     * ```
+     */
+    getColliderShape(): number { return _C(this, 4191) as number; }
+
+    /**
+     * Returns the collision point at which the ray intersects the closest object, in the global coordinate system. If {@link hitFromInside} is `true` and the ray starts inside of a collision shape, this function will return the origin point of the ray.
+     * **Note:** Check that {@link isColliding} returns `true` before calling this method to ensure the returned point is valid and up-to-date.
+     */
+    getCollisionPoint(): Vector2 { return _C(this, 4210) as Vector2; }
+
+    /**
+     * Returns the normal of the intersecting object's shape at the collision point, or `Vector2(0, 0)` if the ray starts inside the shape and {@link hitFromInside} is `true`.
+     * **Note:** Check that {@link isColliding} returns `true` before calling this method to ensure the returned normal is valid and up-to-date.
+     */
+    getCollisionNormal(): Vector2 { return _C(this, 4208) as Vector2; }
+
+    /**
+     * Adds a collision exception so the ray does not report collisions with the specified {@link RID}.
+     */
+    addExceptionRid(rid: RID): void { _C(this, 1213, rid); }
+
+    /**
+     * Adds a collision exception so the ray does not report collisions with the specified `node`.
+     */
+    addException(node: CollisionObject2D): void { _C(this, 1212, node); }
+
+    /**
+     * Removes a collision exception so the ray can report collisions with the specified {@link RID}.
+     */
+    removeExceptionRid(rid: RID): void { _C(this, 9909, rid); }
+
+    /**
+     * Removes a collision exception so the ray can report collisions with the specified `node`.
+     */
+    removeException(node: CollisionObject2D): void { _C(this, 9908, node); }
+
+    /**
+     * Removes all collision exceptions for this ray.
+     */
+    clearExceptions(): void { _C(this, 2262); }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link collisionMask}, given a `layerNumber` between 1 and 32.
+     */
+    setCollisionMaskValue(layerNumber: number, value: boolean): void { _C(this, 10895, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link collisionMask} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getCollisionMaskValue(layerNumber: number): boolean { return _C(this, 4206, layerNumber) as boolean; }
+
+    /**
+     * If `true`, collisions will be reported.
+     */
+    get enabled(): boolean { return _C(this, 7935) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * If `true`, this raycast will not report collisions with its parent node. This property only has an effect if the parent node is a {@link CollisionObject2D}. See also {@link Node.getParent} and {@link addException}.
+     */
+    get excludeParent(): boolean { return _C(this, 4699) as boolean; }
+    set excludeParent(v: boolean) { _C(this, 11315, v); }
+
+    /**
+     * The ray's destination point, relative to this raycast's {@link Node2D.position}.
+     */
+    get targetPosition(): Vector2 { return _C(this, 6702) as Vector2; }
+    set targetPosition(v: Vector2) { _C(this, 13007, v); }
+
+    /**
+     * The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See [Collision layers and masks]($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+     */
+    get collisionMask(): number { return _C(this, 4205) as number; }
+    set collisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * If `true`, the ray will detect a hit when starting inside shapes. In this case the collision normal will be `Vector2(0, 0)`. Does not affect concave polygon shapes.
+     */
+    get hitFromInside(): boolean { return _C(this, 8000) as boolean; }
+    set hitFromInside(v: boolean) { _C(this, 11636, v); }
+
+    /**
+     * If `true`, collisions with {@link Area2D}s will be reported.
+     */
+    get collideWithAreas(): boolean { return _C(this, 7839) as boolean; }
+    set collideWithAreas(v: boolean) { _C(this, 10884, v); }
+
+    /**
+     * If `true`, collisions with {@link PhysicsBody2D}s will be reported.
+     */
+    get collideWithBodies(): boolean { return _C(this, 7840) as boolean; }
+    set collideWithBodies(v: boolean) { _C(this, 10885, v); }
+
+    static readonly name = _R(637, RayCast2D);
+}

package/gen/classes/RayCast3D.ts

@@ -0,0 +1,172 @@
+// 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 { RID } from '../heap-types/index.ts';
+import type { Color, Vector3 } from '../value-types/index.ts';
+import type { CollisionObject3D } from './CollisionObject3D.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * A raycast represents a ray from its origin to its {@link targetPosition} that finds the closest object along its path, if it intersects any.
+ * {@link RayCast3D} can ignore some objects by adding them to an exception list, by making its detection reporting ignore {@link Area3D}s ({@link collideWithAreas}) or {@link PhysicsBody3D}s ({@link collideWithBodies}), or by configuring physics layers.
+ * {@link RayCast3D} calculates intersection every physics frame, and it holds the result until the next physics frame. For an immediate raycast, or if you want to configure a {@link RayCast3D} multiple times within the same physics frame, use {@link forceRaycastUpdate}.
+ * To sweep over a region of 3D space, you can approximate the region with multiple {@link RayCast3D}s or use {@link ShapeCast3D}.
+ */
+export class RayCast3D extends Node3D {
+    constructor(name = 638) { super(name); }
+
+    /**
+     * Returns whether any object is intersecting with the ray's vector (considering the vector length).
+     */
+    isColliding(): boolean { return _C(this, 7841) as boolean; }
+
+    /**
+     * Updates the collision information for the ray immediately, without waiting for the next `_physics_process` call. Use this method, for example, when the ray or its parent has changed state.
+     * **Note:** {@link enabled} does not need to be `true` for this to work.
+     */
+    forceRaycastUpdate(): void { _C(this, 3534); }
+
+    /**
+     * Returns the first object that the ray intersects, or `null` if no object is intersecting the ray (i.e. {@link isColliding} returns `false`).
+     * **Note:** This object is not guaranteed to be a {@link CollisionObject3D}. For example, if the ray intersects a {@link CSGShape3D} or a {@link GridMap}, the method will return a {@link CSGShape3D} or {@link GridMap} instance.
+     */
+    getCollider(): Object | null { return _C(this, 4188) as Object | null; }
+
+    /**
+     * Returns the {@link RID} of the first object that the ray intersects, or an empty {@link RID} if no object is intersecting the ray (i.e. {@link isColliding} returns `false`).
+     */
+    getColliderRid(): RID { return _C(this, 4190) as RID; }
+
+    /**
+     * Returns the shape ID of the first object that the ray intersects, or `0` if no object is intersecting the ray (i.e. {@link isColliding} returns `false`).
+     * To get the intersected shape node, for a {@link CollisionObject3D} target, use:
+     *
+     *
+     * ```gdscript
+     *
+     * var target = get_collider() # A CollisionObject3D.
+     * var shape_id = get_collider_shape() # The shape index in the collider.
+     * var owner_id = target.shape_find_owner(shape_id) # The owner ID in the collider.
+     * var shape = target.shape_owner_get_owner(owner_id)
+     *
+     * ```
+     */
+    getColliderShape(): number { return _C(this, 4191) as number; }
+
+    /**
+     * Returns the collision point at which the ray intersects the closest object, in the global coordinate system. If {@link hitFromInside} is `true` and the ray starts inside of a collision shape, this function will return the origin point of the ray.
+     * **Note:** Check that {@link isColliding} returns `true` before calling this method to ensure the returned point is valid and up-to-date.
+     */
+    getCollisionPoint(): Vector3 { return _C(this, 4210) as Vector3; }
+
+    /**
+     * Returns the normal of the intersecting object's shape at the collision point, or `Vector3(0, 0, 0)` if the ray starts inside the shape and {@link hitFromInside} is `true`.
+     * **Note:** Check that {@link isColliding} returns `true` before calling this method to ensure the returned normal is valid and up-to-date.
+     */
+    getCollisionNormal(): Vector3 { return _C(this, 4208) as Vector3; }
+
+    /**
+     * Returns the collision object's face index at the collision point, or `-1` if the shape intersecting the ray is not a {@link ConcavePolygonShape3D}.
+     */
+    getCollisionFaceIndex(): number { return _C(this, 4200) as number; }
+
+    /**
+     * Adds a collision exception so the ray does not report collisions with the specified {@link RID}.
+     */
+    addExceptionRid(rid: RID): void { _C(this, 1213, rid); }
+
+    /**
+     * Adds a collision exception so the ray does not report collisions with the specified `node`.
+     */
+    addException(node: CollisionObject3D): void { _C(this, 1212, node); }
+
+    /**
+     * Removes a collision exception so the ray can report collisions with the specified {@link RID}.
+     */
+    removeExceptionRid(rid: RID): void { _C(this, 9909, rid); }
+
+    /**
+     * Removes a collision exception so the ray can report collisions with the specified `node`.
+     */
+    removeException(node: CollisionObject3D): void { _C(this, 9908, node); }
+
+    /**
+     * Removes all collision exceptions for this ray.
+     */
+    clearExceptions(): void { _C(this, 2262); }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link collisionMask}, given a `layerNumber` between 1 and 32.
+     */
+    setCollisionMaskValue(layerNumber: number, value: boolean): void { _C(this, 10895, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link collisionMask} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getCollisionMaskValue(layerNumber: number): boolean { return _C(this, 4206, layerNumber) as boolean; }
+
+    /**
+     * If `true`, collisions will be reported.
+     */
+    get enabled(): boolean { return _C(this, 7935) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * If `true`, this raycast will not report collisions with its parent node. This property only has an effect if the parent node is a {@link CollisionObject3D}. See also {@link Node.getParent} and {@link addException}.
+     */
+    get excludeParent(): boolean { return _C(this, 4699) as boolean; }
+    set excludeParent(v: boolean) { _C(this, 11315, v); }
+
+    /**
+     * The ray's destination point, relative to this raycast's {@link Node3D.position}.
+     */
+    get targetPosition(): Vector3 { return _C(this, 6702) as Vector3; }
+    set targetPosition(v: Vector3) { _C(this, 13007, v); }
+
+    /**
+     * The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See [Collision layers and masks]($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+     */
+    get collisionMask(): number { return _C(this, 4205) as number; }
+    set collisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * If `true`, the ray will detect a hit when starting inside shapes. In this case the collision normal will be `Vector3(0, 0, 0)`. Does not affect shapes with no volume like concave polygon or heightmap.
+     */
+    get hitFromInside(): boolean { return _C(this, 8000) as boolean; }
+    set hitFromInside(v: boolean) { _C(this, 11636, v); }
+
+    /**
+     * If `true`, the ray will hit back faces with concave polygon shapes with back face enabled or heightmap shapes.
+     */
+    get hitBackFaces(): boolean { return _C(this, 7999) as boolean; }
+    set hitBackFaces(v: boolean) { _C(this, 11635, v); }
+
+    /**
+     * If `true`, collisions with {@link Area3D}s will be reported.
+     */
+    get collideWithAreas(): boolean { return _C(this, 7839) as boolean; }
+    set collideWithAreas(v: boolean) { _C(this, 10884, v); }
+
+    /**
+     * If `true`, collisions with {@link PhysicsBody3D}s will be reported.
+     */
+    get collideWithBodies(): boolean { return _C(this, 7840) as boolean; }
+    set collideWithBodies(v: boolean) { _C(this, 10885, v); }
+
+    /**
+     * The custom color to use to draw the shape in the editor and at run-time if **Visible Collision Shapes** is enabled in the **Debug** menu. This color will be highlighted at run-time if the {@link RayCast3D} is colliding with something.
+     * If set to `Color(0.0, 0.0, 0.0)` (by default), the color set in {@link ProjectSettings.debug/shapes/collision/shapeColor} is used.
+     */
+    get debugShapeCustomColor(): Color { return _C(this, 4437) as Color; }
+    set debugShapeCustomColor(v: Color) { _C(this, 11050, v); }
+
+    /**
+     * If set to `1`, a line is used as the debug shape. Otherwise, a truncated pyramid is drawn to represent the {@link RayCast3D}. Requires **Visible Collision Shapes** to be enabled in the **Debug** menu for the debug shape to be visible at run-time.
+     */
+    get debugShapeThickness(): number { return _C(this, 4438) as number; }
+    set debugShapeThickness(v: number) { _C(this, 11051, v); }
+
+    static readonly name = _R(638, RayCast3D);
+}

package/gen/classes/RectangleShape2D.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 { Shape2D } from './Shape2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * A 2D rectangle shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape2D}.
+ * **Performance:** {@link RectangleShape2D} is fast to check collisions against. It is faster than {@link CapsuleShape2D}, but slower than {@link CircleShape2D}.
+ */
+export class RectangleShape2D extends Shape2D {
+    constructor(name = 639) { super(name); }
+
+    /**
+     * The rectangle's width and height.
+     */
+    get size(): Vector2 { return _C(this, 6399) as Vector2; }
+    set size(v: Vector2) { _C(this, 12752, v); }
+
+    static readonly name = _R(639, RectangleShape2D);
+}