@ringozz/godot 0.1.0

package/gen/classes/SeparationRayShape3D.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 { Shape3D } from './Shape3D.ts';
+
+/**
+ * A 3D ray shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape3D}. When a {@link SeparationRayShape3D} collides with an object, it tries to separate itself from it by moving its endpoint to the collision point. For example, a {@link SeparationRayShape3D} next to a character can allow it to instantly move up when touching stairs.
+ */
+export class SeparationRayShape3D extends Shape3D {
+    constructor(name = 689) { super(name); }
+
+    /**
+     * The ray's length.
+     */
+    get length(): number { return _C(this, 5331) as number; }
+    set length(v: number) { _C(this, 11891, v); }
+
+    /**
+     * If `false` (default), the shape always separates and returns a normal along its own direction.
+     * If `true`, the shape can return the correct normal and separate in any direction, allowing sliding motion on slopes.
+     */
+    get slideOnSlope(): boolean { return _C(this, 6434) as boolean; }
+    set slideOnSlope(v: boolean) { _C(this, 12780, v); }
+
+    static readonly name = _R(689, SeparationRayShape3D);
+}

package/gen/classes/Separator.ts

@@ -0,0 +1,13 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+
+/**
+ * Abstract base class for separators, used for separating other controls. {@link Separator}s are purely visual and normally drawn as a {@link StyleBoxLine}.
+ */
+export class Separator extends Control {
+
+    static readonly name = _R(690, Separator);
+}

package/gen/classes/Shader.ts

@@ -0,0 +1,83 @@
+// 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 { GodotArray, StringName } from '../heap-types/index.ts';
+import type { Texture } from './Texture.ts';
+
+/**
+ * A custom shader program implemented in the Godot shading language, saved with the `.gdshader` extension.
+ * This class is used by a {@link ShaderMaterial} and allows you to write your own custom behavior for rendering visual items or updating particle information. For a detailed explanation and usage, please see the tutorials linked below.
+ */
+export class Shader extends Resource {
+    constructor(name = 691) { super(name); }
+
+    /**
+     * Returns the shader mode for the shader.
+     */
+    getMode(): Mode { return _C(this, 5568) as Mode; }
+
+    /**
+     * Sets the default texture to be used with a texture uniform. The default is used if a texture is not set in the {@link ShaderMaterial}.
+     * **Note:** `name` must match the name of the uniform in the code exactly.
+     * **Note:** If the sampler array is used use `index` to access the specified texture.
+     */
+    setDefaultTextureParameter(name: StringName, texture: Texture, index?: number /* = 0 */): void { _C(this, 11068, name, texture, index); }
+
+    /**
+     * Returns the texture that is set as default for the specified parameter.
+     * **Note:** `name` must match the name of the uniform in the code exactly.
+     * **Note:** If the sampler array is used use `index` to access the specified texture.
+     */
+    getDefaultTextureParameter(name: StringName, index?: number /* = 0 */): Texture { return _C(this, 4454, name, index) as Texture; }
+
+    /**
+     * Returns the list of shader uniforms that can be assigned to a {@link ShaderMaterial}, for use with {@link ShaderMaterial.setShaderParameter} and {@link ShaderMaterial.getShaderParameter}. The parameters returned are contained in dictionaries in a similar format to the ones returned by {@link Object.getPropertyList}.
+     * If argument `getGroups` is `true`, parameter grouping hints are also included in the list.
+     */
+    getShaderUniformList(getGroups?: boolean /* = false */): GodotArray { return _C(this, 6357, getGroups) as GodotArray; }
+
+    /**
+     * 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 Material.inspectNativeShaderCode}.
+     */
+    inspectNativeShaderCode(): void { _C(this, 7638); }
+
+    /**
+     * Returns the shader's code as the user has written it, not the full generated code used internally.
+     */
+    get code(): string { return _C(this, 4181) as string; }
+    set code(v: string) { _C(this, 10874, v); }
+
+    static readonly name = _R(691, Shader);
+}
+
+export const Mode = {
+    /**
+     * Mode used to draw all 3D objects.
+     */
+    MODE_SPATIAL: 0,
+    /**
+     * Mode used to draw all 2D objects.
+     */
+    MODE_CANVAS_ITEM: 1,
+    /**
+     * Mode used to calculate particle information on a per-particle basis. Not used for drawing.
+     */
+    MODE_PARTICLES: 2,
+    /**
+     * Mode used for drawing skies. Only works with shaders attached to {@link Sky} objects.
+     */
+    MODE_SKY: 3,
+    /**
+     * Mode used for setting the color and density of volumetric fog effect.
+     */
+    MODE_FOG: 4,
+    /**
+     * Mode used for drawing to DrawableTexture resources via blit calls.
+     */
+    MODE_TEXTURE_BLIT: 5,
+} as const;
+
+export type Mode = (typeof Mode)[keyof typeof Mode];
+

package/gen/classes/ShaderGlobalsOverride.ts

@@ -0,0 +1,16 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+
+/**
+ * Similar to how a {@link WorldEnvironment} node can be used to override the environment while a specific scene is loaded, {@link ShaderGlobalsOverride} can be used to override global shader parameters temporarily. Once the node is removed, the project-wide values for the global shader parameters are restored. See the {@link RenderingServer} `global_shader_parameter_*` methods for more information.
+ * **Note:** Only one {@link ShaderGlobalsOverride} can be used per scene. If there is more than one {@link ShaderGlobalsOverride} node in the scene tree, only the first node (in tree order) will be taken into account.
+ * **Note:** All {@link ShaderGlobalsOverride} nodes are made part of a `"shader_overrides_group"` group when they are added to the scene tree. The currently active {@link ShaderGlobalsOverride} node also has a `"shader_overrides_group_active"` group added to it. You can use this to check which {@link ShaderGlobalsOverride} node is currently active.
+ */
+export class ShaderGlobalsOverride extends Node {
+    constructor(name = 692) { super(name); }
+
+    static readonly name = _R(692, ShaderGlobalsOverride);
+}

package/gen/classes/ShaderInclude.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 { Resource } from './Resource.ts';
+
+/**
+ * A shader include file, saved with the `.gdshaderinc` extension. This class allows you to define a custom shader snippet that can be included in a {@link Shader} by using the preprocessor directive `#include`, followed by the file path (e.g. `#include "res://shader_lib.gdshaderinc"`). The snippet doesn't have to be a valid shader on its own.
+ */
+export class ShaderInclude extends Resource {
+    constructor(name = 693) { super(name); }
+
+    /**
+     * Returns the code of the shader include file. The returned text is what the user has written, not the full generated code used internally.
+     */
+    get code(): string { return _C(this, 4181) as string; }
+    set code(v: string) { _C(this, 10874, v); }
+
+    static readonly name = _R(693, ShaderInclude);
+}

package/gen/classes/ShaderIncludeDB.ts

@@ -0,0 +1,30 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { PackedStringArray } from '../heap-types/index.ts';
+
+/**
+ * This object contains shader fragments from Godot's internal shaders. These can be used when access to internal uniform buffers and/or internal functions is required for instance when composing compositor effects or compute shaders. Only fragments for the current rendering device are loaded.
+ */
+export class ShaderIncludeDB extends Object {
+    constructor(name = 694) { super(name); }
+
+    /**
+     * Returns a list of built-in include files that are currently registered.
+     */
+    static listBuiltInIncludeFiles(): PackedStringArray { return _C(694, 8660) as PackedStringArray; }
+
+    /**
+     * Returns `true` if an include file with this name exists.
+     */
+    static hasBuiltInIncludeFile(filename: string): boolean { return _C(694, 7370, filename) as boolean; }
+
+    /**
+     * Returns the code for the built-in shader fragment. You can also access this in your shader code through `#include "filename"`.
+     */
+    static getBuiltInIncludeFile(filename: string): string { return _C(694, 4012, filename) as string; }
+
+    static readonly name = _R(694, ShaderIncludeDB);
+}

package/gen/classes/ShaderMaterial.ts

@@ -0,0 +1,36 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Material } from './Material.ts';
+import type { StringName, Variant } from '../heap-types/index.ts';
+import type { Shader } from './Shader.ts';
+
+/**
+ * A material that uses a custom {@link Shader} program to render visual items (canvas items, meshes, skies, fog), or to process particles. Compared to other materials, {@link ShaderMaterial} gives deeper control over the generated shader code. For more information, see the shaders documentation index below.
+ * Multiple {@link ShaderMaterial}s can use the same shader and configure different values for the shader uniforms.
+ * **Note:** For performance reasons, the {@link Resource.changed} signal is only emitted when the {@link Resource.resourceName} changes. Only in editor, it is also emitted for {@link shader} changes.
+ */
+export class ShaderMaterial extends Material {
+    constructor(name = 695) { super(name); }
+
+    /**
+     * Changes the value set for this material of a uniform in the shader.
+     * **Note:** `param` is case-sensitive and must match the name of the uniform in the code exactly (not the capitalized name in the inspector).
+     * **Note:** Changes to the shader uniform will be effective on all instances using this {@link ShaderMaterial}. To prevent this, use per-instance uniforms with {@link CanvasItem.setInstanceShaderParameter}, {@link GeometryInstance3D.setInstanceShaderParameter} or duplicate the {@link ShaderMaterial} resource using {@link Resource.duplicate}. Per-instance uniforms allow for better shader reuse and are therefore faster, so they should be preferred over duplicating the {@link ShaderMaterial} when possible.
+     */
+    setShaderParameter(param: StringName, value: Variant): void { _C(this, 12702, param, value); }
+
+    /**
+     * Returns the current value set for this material of a uniform in the shader.
+     */
+    getShaderParameter(param: StringName): Variant { return _C(this, 6355, param) as Variant; }
+
+    /**
+     * The {@link Shader} program used to render this material.
+     */
+    get shader(): Shader { return _C(this, 6354) as Shader; }
+    set shader(v: Shader) { _C(this, 12701, v); }
+
+    static readonly name = _R(695, ShaderMaterial);
+}

package/gen/classes/Shape2D.ts

@@ -0,0 +1,61 @@
+// 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 { PackedVector2Array, RID } from '../heap-types/index.ts';
+import type { Color, Rect2, Transform2D, Vector2 } from '../value-types/index.ts';
+
+/**
+ * Abstract base class for all 2D shapes, intended for use in physics.
+ * **Performance:** Primitive shapes, especially {@link CircleShape2D}, are fast to check collisions against. {@link ConvexPolygonShape2D} is slower, and {@link ConcavePolygonShape2D} is the slowest.
+ */
+export class Shape2D extends Resource {
+
+    /**
+     * Returns `true` if this shape is colliding with another.
+     * This method needs the transformation matrix for this shape (`localXform`), the shape to check collisions with (`withShape`), and the transformation matrix of that shape (`shapeXform`).
+     */
+    collide(localXform: Transform2D, withShape: Shape2D, shapeXform: Transform2D): boolean { return _C(this, 2344, localXform, withShape, shapeXform) as boolean; }
+
+    /**
+     * Returns whether this shape would collide with another, if a given movement was applied.
+     * This method needs the transformation matrix for this shape (`localXform`), the movement to test on this shape (`localMotion`), the shape to check collisions with (`withShape`), the transformation matrix of that shape (`shapeXform`), and the movement to test onto the other object (`shapeMotion`).
+     */
+    collideWithMotion(localXform: Transform2D, localMotion: Vector2, withShape: Shape2D, shapeXform: Transform2D, shapeMotion: Vector2): boolean { return _C(this, 2350, localXform, localMotion, withShape, shapeXform, shapeMotion) as boolean; }
+
+    /**
+     * Returns a list of contact point pairs where this shape touches another.
+     * If there are no collisions, the returned list is empty. Otherwise, the returned list contains contact points arranged in pairs, with entries alternating between points on the boundary of this shape and points on the boundary of `withShape`.
+     * A collision pair A, B can be used to calculate the collision normal with `(B - A).normalized()`, and the collision depth with `(B - A).length()`. This information is typically used to separate shapes, particularly in collision solvers.
+     * This method needs the transformation matrix for this shape (`localXform`), the shape to check collisions with (`withShape`), and the transformation matrix of that shape (`shapeXform`).
+     */
+    collideAndGetContacts(localXform: Transform2D, withShape: Shape2D, shapeXform: Transform2D): PackedVector2Array { return _C(this, 2345, localXform, withShape, shapeXform) as PackedVector2Array; }
+
+    /**
+     * Returns a list of contact point pairs where this shape would touch another, if a given movement was applied.
+     * If there would be no collisions, the returned list is empty. Otherwise, the returned list contains contact points arranged in pairs, with entries alternating between points on the boundary of this shape and points on the boundary of `withShape`.
+     * A collision pair A, B can be used to calculate the collision normal with `(B - A).normalized()`, and the collision depth with `(B - A).length()`. This information is typically used to separate shapes, particularly in collision solvers.
+     * This method needs the transformation matrix for this shape (`localXform`), the movement to test on this shape (`localMotion`), the shape to check collisions with (`withShape`), the transformation matrix of that shape (`shapeXform`), and the movement to test onto the other object (`shapeMotion`).
+     */
+    collideWithMotionAndGetContacts(localXform: Transform2D, localMotion: Vector2, withShape: Shape2D, shapeXform: Transform2D, shapeMotion: Vector2): PackedVector2Array { return _C(this, 2351, localXform, localMotion, withShape, shapeXform, shapeMotion) as PackedVector2Array; }
+
+    /**
+     * Draws a solid shape onto a {@link CanvasItem} with the {@link RenderingServer} API filled with the specified `color`. The exact drawing method is specific for each shape and cannot be configured.
+     */
+    draw(canvasItem: RID, color: Color): void { _C(this, 2902, canvasItem, color); }
+
+    /**
+     * Returns a {@link Rect2} representing the shapes boundary.
+     */
+    getRect(): Rect2 { return _C(this, 6092) as Rect2; }
+
+    /**
+     * The shape's custom solver bias. Defines how much bodies react to enforce contact separation when this shape is involved.
+     * When set to `0`, the default value from {@link ProjectSettings.physics/2d/solver/defaultContactBias} is used.
+     */
+    get customSolverBias(): number { return _C(this, 4398) as number; }
+    set customSolverBias(v: number) { _C(this, 11021, v); }
+
+    static readonly name = _R(696, Shape2D);
+}

package/gen/classes/Shape3D.ts

@@ -0,0 +1,35 @@
+// 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 { ArrayMesh } from './ArrayMesh.ts';
+
+/**
+ * Abstract base class for all 3D shapes, intended for use in physics.
+ * **Performance:** Primitive shapes, especially {@link SphereShape3D}, are fast to check collisions against. {@link ConvexPolygonShape3D} and {@link HeightMapShape3D} are slower, and {@link ConcavePolygonShape3D} is the slowest.
+ */
+export class Shape3D extends Resource {
+
+    /**
+     * Returns the {@link ArrayMesh} used to draw the debug collision for this {@link Shape3D}.
+     */
+    getDebugMesh(): ArrayMesh { return _C(this, 4433) as ArrayMesh; }
+
+    /**
+     * The shape's custom solver bias. Defines how much bodies react to enforce contact separation when this shape is involved.
+     * When set to `0`, the default value from {@link ProjectSettings.physics/3d/solver/defaultContactBias} is used.
+     * **Note:** {@link customSolverBias} is only effective when using GodotPhysics3D. It has no effect when using Jolt Physics.
+     */
+    get customSolverBias(): number { return _C(this, 4398) as number; }
+    set customSolverBias(v: number) { _C(this, 11021, v); }
+
+    /**
+     * The collision margin for the shape. This is not used in Godot Physics.
+     * Collision margins allow collision detection to be more efficient by adding an extra shell around shapes. Collision algorithms are more expensive when objects overlap by more than their margin, so a higher value for margins is better for performance, at the cost of accuracy around edges as it makes them less sharp.
+     */
+    get margin(): number { return _C(this, 5441) as number; }
+    set margin(v: number) { _C(this, 11969, v); }
+
+    static readonly name = _R(697, Shape3D);
+}

package/gen/classes/ShapeCast2D.ts

@@ -0,0 +1,168 @@
+// 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 { GodotArray, 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';
+import type { Shape2D } from './Shape2D.ts';
+
+/**
+ * Shape casting allows to detect collision objects by sweeping its {@link shape} along the cast direction determined by {@link targetPosition}. This is similar to {@link RayCast2D}, but it allows for sweeping a region of space, rather than just a straight line. {@link ShapeCast2D} can detect multiple collision objects. It is useful for things like wide laser beams or snapping a simple shape to a floor.
+ * Immediate collision overlaps can be done with the {@link targetPosition} set to `Vector2(0, 0)` and by calling {@link forceShapecastUpdate} within the same physics frame. This helps to overcome some limitations of {@link Area2D} when used as an instantaneous detection area, as collision information isn't immediately available to it.
+ * **Note:** Shape casting is more computationally expensive than ray casting.
+ */
+export class ShapeCast2D extends Node2D {
+    constructor(name = 698) { super(name); }
+
+    /**
+     * Returns whether any object is intersecting with the shape's vector (considering the vector length).
+     */
+    isColliding(): boolean { return _C(this, 7841) as boolean; }
+
+    /**
+     * The number of collisions detected at the point of impact. Use this to iterate over multiple collisions as provided by {@link getCollider}, {@link getColliderShape}, {@link getCollisionPoint}, and {@link getCollisionNormal} methods.
+     */
+    getCollisionCount(): number { return _C(this, 4197) as number; }
+
+    /**
+     * Updates the collision information for the shape immediately, without waiting for the next `_physics_process` call. Use this method, for example, when the shape or its parent has changed state.
+     * **Note:** Setting {@link enabled} to `true` is not required for this to work.
+     */
+    forceShapecastUpdate(): void { _C(this, 3535); }
+
+    /**
+     * Returns the collided {@link Object} of one of the multiple collisions at `index`, or `null` if no object is intersecting the shape (i.e. {@link isColliding} returns `false`).
+     */
+    getCollider(index: number): Object | null { return _C(this, 4188, index) as Object | null; }
+
+    /**
+     * Returns the {@link RID} of the collided object of one of the multiple collisions at `index`.
+     */
+    getColliderRid(index: number): RID { return _C(this, 4190, index) as RID; }
+
+    /**
+     * Returns the shape ID of the colliding shape of one of the multiple collisions at `index`, or `0` if no object is intersecting the shape (i.e. {@link isColliding} returns `false`).
+     */
+    getColliderShape(index: number): number { return _C(this, 4191, index) as number; }
+
+    /**
+     * Returns the collision point of one of the multiple collisions at `index` where the shape intersects the colliding object.
+     * **Note:** This point is in the **global** coordinate system.
+     */
+    getCollisionPoint(index: number): Vector2 { return _C(this, 4210, index) as Vector2; }
+
+    /**
+     * Returns the normal of one of the multiple collisions at `index` of the intersecting object.
+     */
+    getCollisionNormal(index: number): Vector2 { return _C(this, 4208, index) as Vector2; }
+
+    /**
+     * Returns the fraction from this cast's origin to its {@link targetPosition} of how far the shape can move without triggering a collision, as a value between `0.0` and `1.0`.
+     */
+    getClosestCollisionSafeFraction(): number { return _C(this, 4169) as number; }
+
+    /**
+     * Returns the fraction from this cast's origin to its {@link targetPosition} of how far the shape must move to trigger a collision, as a value between `0.0` and `1.0`.
+     * In ideal conditions this would be the same as {@link getClosestCollisionSafeFraction}, however shape casting is calculated in discrete steps, so the precise point of collision can occur between two calculated positions.
+     */
+    getClosestCollisionUnsafeFraction(): number { return _C(this, 4170) as number; }
+
+    /**
+     * Adds a collision exception so the shape does not report collisions with the specified {@link RID}.
+     */
+    addExceptionRid(rid: RID): void { _C(this, 1213, rid); }
+
+    /**
+     * Adds a collision exception so the shape does not report collisions with the specified node.
+     */
+    addException(node: CollisionObject2D): void { _C(this, 1212, node); }
+
+    /**
+     * Removes a collision exception so the shape does report collisions with the specified {@link RID}.
+     */
+    removeExceptionRid(rid: RID): void { _C(this, 9909, rid); }
+
+    /**
+     * Removes a collision exception so the shape does report collisions with the specified node.
+     */
+    removeException(node: CollisionObject2D): void { _C(this, 9908, node); }
+
+    /**
+     * Removes all collision exceptions for this shape.
+     */
+    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); }
+
+    /**
+     * The shape to be used for collision queries.
+     */
+    get shape(): Shape2D { return _C(this, 6370) as Shape2D; }
+    set shape(v: Shape2D) { _C(this, 12717, v); }
+
+    /**
+     * If `true`, the parent node will be excluded from collision detection.
+     */
+    get excludeParent(): boolean { return _C(this, 4699) as boolean; }
+    set excludeParent(v: boolean) { _C(this, 11315, v); }
+
+    /**
+     * The shape's destination point, relative to this node's {@link Node2D.position}.
+     */
+    get targetPosition(): Vector2 { return _C(this, 6702) as Vector2; }
+    set targetPosition(v: Vector2) { _C(this, 13007, v); }
+
+    /**
+     * The collision margin for the shape. A larger margin helps detecting collisions more consistently, at the cost of precision.
+     */
+    get margin(): number { return _C(this, 5441) as number; }
+    set margin(v: number) { _C(this, 11969, v); }
+
+    /**
+     * The number of intersections can be limited with this parameter, to reduce the processing time.
+     */
+    get maxResults(): number { return _C(this, 5483) as number; }
+    set maxResults(v: number) { _C(this, 12006, v); }
+
+    /**
+     * The shape'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); }
+
+    /**
+     * Returns the complete collision information from the collision sweep. The data returned is the same as in the {@link PhysicsDirectSpaceState2D.getRestInfo} method.
+     */
+    get collisionResult(): GodotArray { return _C(this, 4215) as GodotArray; }
+
+    /**
+     * 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(698, ShapeCast2D);
+}