typescript-to-gdscript 0.1.0

package/typings/classes/PhysicsServer3DExtension.d.ts

@@ -0,0 +1,204 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Provides virtual methods that can be overridden to create custom {@link PhysicsServer3D} implementations.
+ */
+declare class PhysicsServer3DExtension extends PhysicsServer3D {
+  _area_add_shape(area: RID, shape: RID, transform: Transform3D | Projection, disabled: boolean): void;
+  _area_attach_object_instance_id(area: RID, id: int): void;
+  _area_clear_shapes(area: RID): void;
+  _area_create(): RID;
+  _area_get_collision_layer(area: RID): int;
+  _area_get_collision_mask(area: RID): int;
+  _area_get_object_instance_id(area: RID): int;
+  _area_get_param(area: RID, param: int): unknown;
+  _area_get_shape(area: RID, shape_idx: int): RID;
+  _area_get_shape_count(area: RID): int;
+  _area_get_shape_transform(area: RID, shape_idx: int): Transform3D;
+  _area_get_space(area: RID): RID;
+  _area_get_transform(area: RID): Transform3D;
+  _area_remove_shape(area: RID, shape_idx: int): void;
+  _area_set_area_monitor_callback(area: RID, callback: Callable): void;
+  _area_set_collision_layer(area: RID, layer: int): void;
+  _area_set_collision_mask(area: RID, mask: int): void;
+  _area_set_monitor_callback(area: RID, callback: Callable): void;
+  _area_set_monitorable(area: RID, monitorable: boolean): void;
+  _area_set_param(area: RID, param: int, value: unknown): void;
+  _area_set_ray_pickable(area: RID, enable: boolean): void;
+  _area_set_shape(area: RID, shape_idx: int, shape: RID): void;
+  _area_set_shape_disabled(area: RID, shape_idx: int, disabled: boolean): void;
+  _area_set_shape_transform(area: RID, shape_idx: int, transform: Transform3D | Projection): void;
+  _area_set_space(area: RID, space: RID): void;
+  _area_set_transform(area: RID, transform: Transform3D | Projection): void;
+  _body_add_collision_exception(body: RID, excepted_body: RID): void;
+  _body_add_constant_central_force(body: RID, force: Vector3 | Vector3i): void;
+  _body_add_constant_force(body: RID, force: Vector3 | Vector3i, position: Vector3 | Vector3i): void;
+  _body_add_constant_torque(body: RID, torque: Vector3 | Vector3i): void;
+  _body_add_shape(body: RID, shape: RID, transform: Transform3D | Projection, disabled: boolean): void;
+  _body_apply_central_force(body: RID, force: Vector3 | Vector3i): void;
+  _body_apply_central_impulse(body: RID, impulse: Vector3 | Vector3i): void;
+  _body_apply_force(body: RID, force: Vector3 | Vector3i, position: Vector3 | Vector3i): void;
+  _body_apply_impulse(body: RID, impulse: Vector3 | Vector3i, position: Vector3 | Vector3i): void;
+  _body_apply_torque(body: RID, torque: Vector3 | Vector3i): void;
+  _body_apply_torque_impulse(body: RID, impulse: Vector3 | Vector3i): void;
+  _body_attach_object_instance_id(body: RID, id: int): void;
+  _body_clear_shapes(body: RID): void;
+  _body_create(): RID;
+  _body_get_collision_exceptions(body: RID): Array<RID>;
+  _body_get_collision_layer(body: RID): int;
+  _body_get_collision_mask(body: RID): int;
+  _body_get_collision_priority(body: RID): float;
+  _body_get_constant_force(body: RID): Vector3;
+  _body_get_constant_torque(body: RID): Vector3;
+  _body_get_contacts_reported_depth_threshold(body: RID): float;
+  _body_get_direct_state(body: RID): PhysicsDirectBodyState3D | null;
+  _body_get_max_contacts_reported(body: RID): int;
+  _body_get_mode(body: RID): int;
+  _body_get_object_instance_id(body: RID): int;
+  _body_get_param(body: RID, param: int): unknown;
+  _body_get_shape(body: RID, shape_idx: int): RID;
+  _body_get_shape_count(body: RID): int;
+  _body_get_shape_transform(body: RID, shape_idx: int): Transform3D;
+  _body_get_space(body: RID): RID;
+  _body_get_state(body: RID, state: int): unknown;
+  _body_get_user_flags(body: RID): int;
+  _body_is_axis_locked(body: RID, axis: int): boolean;
+  _body_is_continuous_collision_detection_enabled(body: RID): boolean;
+  _body_is_omitting_force_integration(body: RID): boolean;
+  _body_remove_collision_exception(body: RID, excepted_body: RID): void;
+  _body_remove_shape(body: RID, shape_idx: int): void;
+  _body_reset_mass_properties(body: RID): void;
+  _body_set_axis_lock(body: RID, axis: int, lock: boolean): void;
+  _body_set_axis_velocity(body: RID, axis_velocity: Vector3 | Vector3i): void;
+  _body_set_collision_layer(body: RID, layer: int): void;
+  _body_set_collision_mask(body: RID, mask: int): void;
+  _body_set_collision_priority(body: RID, priority: float): void;
+  _body_set_constant_force(body: RID, force: Vector3 | Vector3i): void;
+  _body_set_constant_torque(body: RID, torque: Vector3 | Vector3i): void;
+  _body_set_contacts_reported_depth_threshold(body: RID, threshold: float): void;
+  _body_set_enable_continuous_collision_detection(body: RID, enable: boolean): void;
+  _body_set_force_integration_callback(body: RID, callable: Callable, userdata: unknown): void;
+  _body_set_max_contacts_reported(body: RID, amount: int): void;
+  _body_set_mode(body: RID, mode: int): void;
+  _body_set_omit_force_integration(body: RID, enable: boolean): void;
+  _body_set_param(body: RID, param: int, value: unknown): void;
+  _body_set_ray_pickable(body: RID, enable: boolean): void;
+  _body_set_shape(body: RID, shape_idx: int, shape: RID): void;
+  _body_set_shape_disabled(body: RID, shape_idx: int, disabled: boolean): void;
+  _body_set_shape_transform(body: RID, shape_idx: int, transform: Transform3D | Projection): void;
+  _body_set_space(body: RID, space: RID): void;
+  _body_set_state(body: RID, state: int, value: unknown): void;
+  _body_set_state_sync_callback(body: RID, callable: Callable): void;
+  _body_set_user_flags(body: RID, flags: int): void;
+  _body_test_motion(body: RID, from_: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, max_collisions: int, collide_separation_ray: boolean, recovery_as_collision: boolean, result: unknown): boolean;
+  _box_shape_create(): RID;
+  _capsule_shape_create(): RID;
+  _concave_polygon_shape_create(): RID;
+  _cone_twist_joint_get_param(joint: RID, param: int): float;
+  _cone_twist_joint_set_param(joint: RID, param: int, value: float): void;
+  _convex_polygon_shape_create(): RID;
+  _custom_shape_create(): RID;
+  _cylinder_shape_create(): RID;
+  _end_sync(): void;
+  _finish(): void;
+  _flush_queries(): void;
+  _free_rid(rid: RID): void;
+  _generic_6dof_joint_get_flag(joint: RID, axis: int, flag: int): boolean;
+  _generic_6dof_joint_get_param(joint: RID, axis: int, param: int): float;
+  _generic_6dof_joint_set_flag(joint: RID, axis: int, flag: int, enable: boolean): void;
+  _generic_6dof_joint_set_param(joint: RID, axis: int, param: int, value: float): void;
+  _get_process_info(process_info: int): int;
+  _heightmap_shape_create(): RID;
+  _hinge_joint_get_flag(joint: RID, flag: int): boolean;
+  _hinge_joint_get_param(joint: RID, param: int): float;
+  _hinge_joint_set_flag(joint: RID, flag: int, enabled: boolean): void;
+  _hinge_joint_set_param(joint: RID, param: int, value: float): void;
+  _init(): void;
+  _is_flushing_queries(): boolean;
+  _joint_clear(joint: RID): void;
+  _joint_create(): RID;
+  _joint_disable_collisions_between_bodies(joint: RID, disable: boolean): void;
+  _joint_get_solver_priority(joint: RID): int;
+  _joint_get_type(joint: RID): int;
+  _joint_is_disabled_collisions_between_bodies(joint: RID): boolean;
+  _joint_make_cone_twist(joint: RID, body_A: RID, local_ref_A: Transform3D | Projection, body_B: RID, local_ref_B: Transform3D | Projection): void;
+  _joint_make_generic_6dof(joint: RID, body_A: RID, local_ref_A: Transform3D | Projection, body_B: RID, local_ref_B: Transform3D | Projection): void;
+  _joint_make_hinge(joint: RID, body_A: RID, hinge_A: Transform3D | Projection, body_B: RID, hinge_B: Transform3D | Projection): void;
+  _joint_make_hinge_simple(joint: RID, body_A: RID, pivot_A: Vector3 | Vector3i, axis_A: Vector3 | Vector3i, body_B: RID, pivot_B: Vector3 | Vector3i, axis_B: Vector3 | Vector3i): void;
+  _joint_make_pin(joint: RID, body_A: RID, local_A: Vector3 | Vector3i, body_B: RID, local_B: Vector3 | Vector3i): void;
+  _joint_make_slider(joint: RID, body_A: RID, local_ref_A: Transform3D | Projection, body_B: RID, local_ref_B: Transform3D | Projection): void;
+  _joint_set_solver_priority(joint: RID, priority: int): void;
+  _pin_joint_get_local_a(joint: RID): Vector3;
+  _pin_joint_get_local_b(joint: RID): Vector3;
+  _pin_joint_get_param(joint: RID, param: int): float;
+  _pin_joint_set_local_a(joint: RID, local_A: Vector3 | Vector3i): void;
+  _pin_joint_set_local_b(joint: RID, local_B: Vector3 | Vector3i): void;
+  _pin_joint_set_param(joint: RID, param: int, value: float): void;
+  _separation_ray_shape_create(): RID;
+  _set_active(active: boolean): void;
+  _shape_get_custom_solver_bias(shape: RID): float;
+  _shape_get_data(shape: RID): unknown;
+  _shape_get_margin(shape: RID): float;
+  _shape_get_type(shape: RID): int;
+  _shape_set_custom_solver_bias(shape: RID, bias: float): void;
+  _shape_set_data(shape: RID, data: unknown): void;
+  _shape_set_margin(shape: RID, margin: float): void;
+  _slider_joint_get_param(joint: RID, param: int): float;
+  _slider_joint_set_param(joint: RID, param: int, value: float): void;
+  _soft_body_add_collision_exception(body: RID, body_b: RID): void;
+  _soft_body_apply_central_force(body: RID, force: Vector3 | Vector3i): void;
+  _soft_body_apply_central_impulse(body: RID, impulse: Vector3 | Vector3i): void;
+  _soft_body_apply_point_force(body: RID, point_index: int, force: Vector3 | Vector3i): void;
+  _soft_body_apply_point_impulse(body: RID, point_index: int, impulse: Vector3 | Vector3i): void;
+  _soft_body_create(): RID;
+  _soft_body_get_bounds(body: RID): AABB;
+  _soft_body_get_collision_exceptions(body: RID): Array<RID>;
+  _soft_body_get_collision_layer(body: RID): int;
+  _soft_body_get_collision_mask(body: RID): int;
+  _soft_body_get_damping_coefficient(body: RID): float;
+  _soft_body_get_drag_coefficient(body: RID): float;
+  _soft_body_get_linear_stiffness(body: RID): float;
+  _soft_body_get_point_global_position(body: RID, point_index: int): Vector3;
+  _soft_body_get_pressure_coefficient(body: RID): float;
+  _soft_body_get_shrinking_factor(body: RID): float;
+  _soft_body_get_simulation_precision(body: RID): int;
+  _soft_body_get_space(body: RID): RID;
+  _soft_body_get_state(body: RID, state: int): unknown;
+  _soft_body_get_total_mass(body: RID): float;
+  _soft_body_is_point_pinned(body: RID, point_index: int): boolean;
+  _soft_body_move_point(body: RID, point_index: int, global_position: Vector3 | Vector3i): void;
+  _soft_body_pin_point(body: RID, point_index: int, pin: boolean): void;
+  _soft_body_remove_all_pinned_points(body: RID): void;
+  _soft_body_remove_collision_exception(body: RID, body_b: RID): void;
+  _soft_body_set_collision_layer(body: RID, layer: int): void;
+  _soft_body_set_collision_mask(body: RID, mask: int): void;
+  _soft_body_set_damping_coefficient(body: RID, damping_coefficient: float): void;
+  _soft_body_set_drag_coefficient(body: RID, drag_coefficient: float): void;
+  _soft_body_set_linear_stiffness(body: RID, linear_stiffness: float): void;
+  _soft_body_set_mesh(body: RID, mesh: RID): void;
+  _soft_body_set_pressure_coefficient(body: RID, pressure_coefficient: float): void;
+  _soft_body_set_ray_pickable(body: RID, enable: boolean): void;
+  _soft_body_set_shrinking_factor(body: RID, shrinking_factor: float): void;
+  _soft_body_set_simulation_precision(body: RID, simulation_precision: int): void;
+  _soft_body_set_space(body: RID, space: RID): void;
+  _soft_body_set_state(body: RID, state: int, variant: unknown): void;
+  _soft_body_set_total_mass(body: RID, total_mass: float): void;
+  _soft_body_set_transform(body: RID, transform: Transform3D | Projection): void;
+  _soft_body_update_rendering_server(body: RID, rendering_server_handler: PhysicsServer3DRenderingServerHandler): void;
+  _space_create(): RID;
+  _space_get_contact_count(space: RID): int;
+  _space_get_contacts(space: RID): PackedVector3Array;
+  _space_get_direct_state(space: RID): PhysicsDirectSpaceState3D | null;
+  _space_get_param(space: RID, param: int): float;
+  _space_is_active(space: RID): boolean;
+  _space_set_active(space: RID, active: boolean): void;
+  _space_set_debug_contacts(space: RID, max_contacts: int): void;
+  _space_set_param(space: RID, param: int, value: float): void;
+  _sphere_shape_create(): RID;
+  _step(step: float): void;
+  _sync(): void;
+  _world_boundary_shape_create(): RID;
+  body_test_motion_is_excluding_body(body: RID): boolean;
+  body_test_motion_is_excluding_object(object: int): boolean;
+}

package/typings/classes/PhysicsServer3DManager.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A singleton for managing {@link PhysicsServer3D} implementations. */
+declare interface PhysicsServer3DManager extends GodotObject {
+  /**
+   * Register a {@link PhysicsServer3D} implementation by passing a `name` and a {@link Callable} that returns a {@link PhysicsServer3D} object.
+   */
+  register_server(name: string | NodePath, create_callback: Callable): void;
+  /**
+   * Set the default {@link PhysicsServer3D} implementation to the one identified by `name`, if `priority` is greater than the priority of the current default implementation.
+   */
+  set_default_server(name: string | NodePath, priority: int): void;
+}
+declare const PhysicsServer3DManager: PhysicsServer3DManager;
+

package/typings/classes/PhysicsServer3DRenderingServerHandler.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A class used to provide {@link PhysicsServer3DExtension._soft_body_update_rendering_server} with a rendering handler for soft bodies.
+ */
+declare class PhysicsServer3DRenderingServerHandler extends GodotObject {
+  /** Called by the {@link PhysicsServer3D} to set the bounding box for the {@link SoftBody3D}. */
+  _set_aabb(aabb: AABB): void;
+  /**
+   * Called by the {@link PhysicsServer3D} to set the normal for the {@link SoftBody3D} vertex at the index specified by `vertex_id`.
+   * **Note:** The `normal` parameter used to be of type `const void*` prior to Godot 4.2.
+   */
+  _set_normal(vertex_id: int, normal: Vector3 | Vector3i): void;
+  /**
+   * Called by the {@link PhysicsServer3D} to set the position for the {@link SoftBody3D} vertex at the index specified by `vertex_id`.
+   * **Note:** The `vertex` parameter used to be of type `const void*` prior to Godot 4.2.
+   */
+  _set_vertex(vertex_id: int, vertex: Vector3 | Vector3i): void;
+  /** Sets the bounding box for the {@link SoftBody3D}. */
+  set_aabb(aabb: AABB): void;
+  /** Sets the normal for the {@link SoftBody3D} vertex at the index specified by `vertex_id`. */
+  set_normal(vertex_id: int, normal: Vector3 | Vector3i): void;
+  /** Sets the position for the {@link SoftBody3D} vertex at the index specified by `vertex_id`. */
+  set_vertex(vertex_id: int, vertex: Vector3 | Vector3i): void;
+}

package/typings/classes/PhysicsShapeQueryParameters2D.d.ts

@@ -0,0 +1,51 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for {@link PhysicsDirectSpaceState2D}'s methods. */
+declare class PhysicsShapeQueryParameters2D extends RefCounted {
+  /** If `true`, the query will take {@link Area2D}s into account. */
+  collide_with_areas: boolean;
+  /** If `true`, the query will take {@link PhysicsBody2D}s into account. */
+  collide_with_bodies: boolean;
+  /**
+   * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * The list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject2D.get_rid} to get the {@link RID} associated with a {@link CollisionObject2D}-derived node.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+   */
+  exclude: Array<RID>;
+  /** The collision margin for the shape. */
+  margin: float;
+  /** The motion of the shape being queried for. */
+  motion: Vector2;
+  /**
+   * The {@link Shape2D} that will be used for collision/intersection queries. This stores the actual reference which avoids the shape to be released while being used for queries, so always prefer using this over {@link shape_rid}.
+   */
+  shape: Resource | null;
+  /**
+   * The queried shape's {@link RID} that will be used for collision/intersection queries. Use this over {@link shape} if you want to optimize for performance using the Servers API:
+   */
+  shape_rid: RID;
+  /** The queried shape's transform matrix. */
+  transform: Transform2D;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_exclude(value: Array<RID>): void;
+  get_exclude(): Array<RID>;
+  set_margin(value: float): void;
+  get_margin(): float;
+  set_motion(value: Vector2 | Vector2i): void;
+  get_motion(): Vector2;
+  set_shape(value: Resource | null): void;
+  get_shape(): Resource | null;
+  set_shape_rid(value: RID): void;
+  get_shape_rid(): RID;
+  set_transform(value: Transform2D): void;
+  get_transform(): Transform2D;
+}

package/typings/classes/PhysicsShapeQueryParameters3D.d.ts

@@ -0,0 +1,51 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for {@link PhysicsDirectSpaceState3D}'s methods. */
+declare class PhysicsShapeQueryParameters3D extends RefCounted {
+  /** If `true`, the query will take {@link Area3D}s into account. */
+  collide_with_areas: boolean;
+  /** If `true`, the query will take {@link PhysicsBody3D}s into account. */
+  collide_with_bodies: boolean;
+  /**
+   * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * The list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject3D.get_rid} to get the {@link RID} associated with a {@link CollisionObject3D}-derived node.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+   */
+  exclude: Array<RID>;
+  /** The collision margin for the shape. */
+  margin: float;
+  /** The motion of the shape being queried for. */
+  motion: Vector3;
+  /**
+   * The {@link Shape3D} that will be used for collision/intersection queries. This stores the actual reference which avoids the shape to be released while being used for queries, so always prefer using this over {@link shape_rid}.
+   */
+  shape: Resource | null;
+  /**
+   * The queried shape's {@link RID} that will be used for collision/intersection queries. Use this over {@link shape} if you want to optimize for performance using the Servers API:
+   */
+  shape_rid: RID;
+  /** The queried shape's transform matrix. */
+  transform: Transform3D;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_exclude(value: Array<RID>): void;
+  get_exclude(): Array<RID>;
+  set_margin(value: float): void;
+  get_margin(): float;
+  set_motion(value: Vector3 | Vector3i): void;
+  get_motion(): Vector3;
+  set_shape(value: Resource | null): void;
+  get_shape(): Resource | null;
+  set_shape_rid(value: RID): void;
+  get_shape_rid(): RID;
+  set_transform(value: Transform3D | Projection): void;
+  get_transform(): Transform3D;
+}

package/typings/classes/PhysicsTestMotionParameters2D.d.ts

@@ -0,0 +1,46 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for {@link PhysicsServer2D.body_test_motion}. */
+declare class PhysicsTestMotionParameters2D extends RefCounted {
+  /**
+   * If set to `true`, shapes of type {@link PhysicsServer2D.SHAPE_SEPARATION_RAY} are used to detect collisions and can stop the motion. Can be useful when snapping to the ground.
+   * If set to `false`, shapes of type {@link PhysicsServer2D.SHAPE_SEPARATION_RAY} are only used for separation when overlapping with other bodies. That's the main use for separation ray shapes.
+   */
+  collide_separation_ray: boolean;
+  /**
+   * Optional array of body {@link RID} to exclude from collision. Use {@link CollisionObject2D.get_rid} to get the {@link RID} associated with a {@link CollisionObject2D}-derived node.
+   */
+  exclude_bodies: Array<RID>;
+  /**
+   * Optional array of object unique instance ID to exclude from collision. See {@link Object.get_instance_id}.
+   */
+  exclude_objects: Array<int>;
+  /**
+   * Transform in global space where the motion should start. Usually set to {@link Node2D.global_transform} for the current body's transform.
+   */
+  from: Transform2D;
+  /** Increases the size of the shapes involved in the collision detection. */
+  margin: float;
+  /** Motion vector to define the length and direction of the motion to test. */
+  motion: Vector2;
+  /**
+   * If set to `true`, any depenetration from the recovery phase is reported as a collision; this is used e.g. by {@link CharacterBody2D} for improving floor detection during floor snapping.
+   * If set to `false`, only collisions resulting from the motion are reported, which is generally the desired behavior.
+   */
+  recovery_as_collision: boolean;
+  set_collide_separation_ray_enabled(value: boolean): void;
+  is_collide_separation_ray_enabled(): boolean;
+  set_exclude_bodies(value: Array<RID>): void;
+  get_exclude_bodies(): Array<RID>;
+  set_exclude_objects(value: Array<int>): void;
+  get_exclude_objects(): Array<int>;
+  set_from(value: Transform2D): void;
+  get_from(): Transform2D;
+  set_margin(value: float): void;
+  get_margin(): float;
+  set_motion(value: Vector2 | Vector2i): void;
+  get_motion(): Vector2;
+  set_recovery_as_collision_enabled(value: boolean): void;
+  is_recovery_as_collision_enabled(): boolean;
+}

package/typings/classes/PhysicsTestMotionParameters3D.d.ts

@@ -0,0 +1,52 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for {@link PhysicsServer3D.body_test_motion}. */
+declare class PhysicsTestMotionParameters3D extends RefCounted {
+  /**
+   * If set to `true`, shapes of type {@link PhysicsServer3D.SHAPE_SEPARATION_RAY} are used to detect collisions and can stop the motion. Can be useful when snapping to the ground.
+   * If set to `false`, shapes of type {@link PhysicsServer3D.SHAPE_SEPARATION_RAY} are only used for separation when overlapping with other bodies. That's the main use for separation ray shapes.
+   */
+  collide_separation_ray: boolean;
+  /**
+   * Optional array of body {@link RID} to exclude from collision. Use {@link CollisionObject3D.get_rid} to get the {@link RID} associated with a {@link CollisionObject3D}-derived node.
+   */
+  exclude_bodies: Array<RID>;
+  /**
+   * Optional array of object unique instance ID to exclude from collision. See {@link Object.get_instance_id}.
+   */
+  exclude_objects: Array<int>;
+  /**
+   * Transform in global space where the motion should start. Usually set to {@link Node3D.global_transform} for the current body's transform.
+   */
+  from: Transform3D;
+  /** Increases the size of the shapes involved in the collision detection. */
+  margin: float;
+  /**
+   * Maximum number of returned collisions, between `1` and `32`. Always returns the deepest detected collisions.
+   */
+  max_collisions: int;
+  /** Motion vector to define the length and direction of the motion to test. */
+  motion: Vector3;
+  /**
+   * If set to `true`, any depenetration from the recovery phase is reported as a collision; this is used e.g. by {@link CharacterBody3D} for improving floor detection during floor snapping.
+   * If set to `false`, only collisions resulting from the motion are reported, which is generally the desired behavior.
+   */
+  recovery_as_collision: boolean;
+  set_collide_separation_ray_enabled(value: boolean): void;
+  is_collide_separation_ray_enabled(): boolean;
+  set_exclude_bodies(value: Array<RID>): void;
+  get_exclude_bodies(): Array<RID>;
+  set_exclude_objects(value: Array<int>): void;
+  get_exclude_objects(): Array<int>;
+  set_from(value: Transform3D | Projection): void;
+  get_from(): Transform3D;
+  set_margin(value: float): void;
+  get_margin(): float;
+  set_max_collisions(value: int): void;
+  get_max_collisions(): int;
+  set_motion(value: Vector3 | Vector3i): void;
+  get_motion(): Vector3;
+  set_recovery_as_collision_enabled(value: boolean): void;
+  is_recovery_as_collision_enabled(): boolean;
+}

package/typings/classes/PhysicsTestMotionResult2D.d.ts

@@ -0,0 +1,38 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Describes the motion and collision result from {@link PhysicsServer2D.body_test_motion}. */
+declare class PhysicsTestMotionResult2D extends RefCounted {
+  /** Returns the colliding body's attached {@link Object}, if a collision occurred. */
+  get_collider(): GodotObject | null;
+  /**
+   * Returns the unique instance ID of the colliding body's attached {@link Object}, if a collision occurred. See {@link Object.get_instance_id}.
+   */
+  get_collider_id(): int;
+  /**
+   * Returns the colliding body's {@link RID} used by the {@link PhysicsServer2D}, if a collision occurred.
+   */
+  get_collider_rid(): RID;
+  /** Returns the colliding body's shape index, if a collision occurred. See {@link CollisionObject2D}. */
+  get_collider_shape(): int;
+  /** Returns the colliding body's velocity, if a collision occurred. */
+  get_collider_velocity(): Vector2;
+  /** Returns the length of overlap along the collision normal, if a collision occurred. */
+  get_collision_depth(): float;
+  /** Returns the moving object's colliding shape, if a collision occurred. */
+  get_collision_local_shape(): int;
+  /** Returns the colliding body's shape's normal at the point of collision, if a collision occurred. */
+  get_collision_normal(): Vector2;
+  /** Returns the point of collision in global coordinates, if a collision occurred. */
+  get_collision_point(): Vector2;
+  /** Returns the maximum fraction of the motion that can occur without a collision, between `0` and `1`. */
+  get_collision_safe_fraction(): float;
+  /**
+   * Returns the minimum fraction of the motion needed to collide, if a collision occurred, between `0` and `1`.
+   */
+  get_collision_unsafe_fraction(): float;
+  /** Returns the moving object's remaining movement vector. */
+  get_remainder(): Vector2;
+  /** Returns the moving object's travel before collision. */
+  get_travel(): Vector2;
+}

package/typings/classes/PhysicsTestMotionResult3D.d.ts

@@ -0,0 +1,54 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Describes the motion and collision result from {@link PhysicsServer3D.body_test_motion}. */
+declare class PhysicsTestMotionResult3D extends RefCounted {
+  /**
+   * Returns the colliding body's attached {@link Object} given a collision index (the deepest collision by default), if a collision occurred.
+   */
+  get_collider(collision_index?: int): GodotObject | null;
+  /**
+   * Returns the unique instance ID of the colliding body's attached {@link Object} given a collision index (the deepest collision by default), if a collision occurred. See {@link Object.get_instance_id}.
+   */
+  get_collider_id(collision_index?: int): int;
+  /**
+   * Returns the colliding body's {@link RID} used by the {@link PhysicsServer3D} given a collision index (the deepest collision by default), if a collision occurred.
+   */
+  get_collider_rid(collision_index?: int): RID;
+  /**
+   * Returns the colliding body's shape index given a collision index (the deepest collision by default), if a collision occurred. See {@link CollisionObject3D}.
+   */
+  get_collider_shape(collision_index?: int): int;
+  /**
+   * Returns the colliding body's velocity given a collision index (the deepest collision by default), if a collision occurred.
+   */
+  get_collider_velocity(collision_index?: int): Vector3;
+  /** Returns the number of detected collisions. */
+  get_collision_count(): int;
+  /**
+   * Returns the length of overlap along the collision normal given a collision index (the deepest collision by default), if a collision occurred.
+   */
+  get_collision_depth(collision_index?: int): float;
+  /**
+   * Returns the moving object's colliding shape given a collision index (the deepest collision by default), if a collision occurred.
+   */
+  get_collision_local_shape(collision_index?: int): int;
+  /**
+   * Returns the colliding body's shape's normal at the point of collision given a collision index (the deepest collision by default), if a collision occurred.
+   */
+  get_collision_normal(collision_index?: int): Vector3;
+  /**
+   * Returns the point of collision in global coordinates given a collision index (the deepest collision by default), if a collision occurred.
+   */
+  get_collision_point(collision_index?: int): Vector3;
+  /** Returns the maximum fraction of the motion that can occur without a collision, between `0` and `1`. */
+  get_collision_safe_fraction(): float;
+  /**
+   * Returns the minimum fraction of the motion needed to collide, if a collision occurred, between `0` and `1`.
+   */
+  get_collision_unsafe_fraction(): float;
+  /** Returns the moving object's remaining movement vector. */
+  get_remainder(): Vector3;
+  /** Returns the moving object's travel before collision. */
+  get_travel(): Vector3;
+}

package/typings/classes/PinJoint2D.d.ts

@@ -0,0 +1,34 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A physics joint that attaches two 2D physics bodies at a single point, allowing them to freely rotate.
+ */
+declare class PinJoint2D extends Joint2D {
+  /**
+   * If `true`, the pin maximum and minimum rotation, defined by {@link angular_limit_lower} and {@link angular_limit_upper} are applied.
+   */
+  angular_limit_enabled: boolean;
+  /** The minimum rotation. Only active if {@link angular_limit_enabled} is `true`. */
+  angular_limit_lower: float;
+  /** The maximum rotation. Only active if {@link angular_limit_enabled} is `true`. */
+  angular_limit_upper: float;
+  /** When activated, a motor turns the pin. */
+  motor_enabled: boolean;
+  /** Target speed for the motor. In radians per second. */
+  motor_target_velocity: float;
+  /** The higher this value, the more the bond to the pinned partner can flex. */
+  softness: float;
+  set_angular_limit_enabled(value: boolean): void;
+  is_angular_limit_enabled(): boolean;
+  set_angular_limit_lower(value: float): void;
+  get_angular_limit_lower(): float;
+  set_angular_limit_upper(value: float): void;
+  get_angular_limit_upper(): float;
+  set_motor_enabled(value: boolean): void;
+  is_motor_enabled(): boolean;
+  set_motor_target_velocity(value: float): void;
+  get_motor_target_velocity(): float;
+  set_softness(value: float): void;
+  get_softness(): float;
+}

package/typings/classes/PinJoint3D.d.ts

@@ -0,0 +1,35 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A physics joint that attaches two 3D physics bodies at a single point, allowing them to freely rotate.
+ */
+declare class PinJoint3D extends Joint3D {
+  /**
+   * The force with which the pinned objects stay in positional relation to each other. The higher, the stronger.
+   */
+  'params/bias': float;
+  /**
+   * The force with which the pinned objects stay in velocity relation to each other. The higher, the stronger.
+   */
+  'params/damping': float;
+  /** If above 0, this value is the maximum value for an impulse that this Joint3D produces. */
+  'params/impulse_clamp': float;
+
+  /** Returns the value of the specified parameter. */
+  get_param(param: int): float;
+  /** Sets the value of the specified parameter. */
+  set_param(param: int, value: float): void;
+
+  // enum Param
+  /**
+   * The force with which the pinned objects stay in positional relation to each other. The higher, the stronger.
+   */
+  static readonly PARAM_BIAS: int;
+  /**
+   * The force with which the pinned objects stay in velocity relation to each other. The higher, the stronger.
+   */
+  static readonly PARAM_DAMPING: int;
+  /** If above 0, this value is the maximum value for an impulse that this Joint3D produces. */
+  static readonly PARAM_IMPULSE_CLAMP: int;
+}

package/typings/classes/PlaceholderCubemap.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link Cubemap} without image data. */
+declare class PlaceholderCubemap extends PlaceholderTextureLayered {
+}

package/typings/classes/PlaceholderCubemapArray.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link CubemapArray} without image data. */
+declare class PlaceholderCubemapArray extends PlaceholderTextureLayered {
+}

package/typings/classes/PlaceholderMaterial.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Placeholder class for a material. */
+declare class PlaceholderMaterial extends Material {
+}

package/typings/classes/PlaceholderMesh.d.ts

@@ -0,0 +1,9 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Placeholder class for a mesh. */
+declare class PlaceholderMesh extends Mesh {
+  /** The smallest {@link AABB} enclosing this mesh in local space. */
+  aabb: AABB;
+  set_aabb(value: AABB): void;
+}