typescript-to-gdscript 0.1.0

package/typings/classes/PathFollow2D.d.ts

@@ -0,0 +1,45 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Point sampler for a {@link Path2D}. */
+declare class PathFollow2D extends Node2D {
+  /**
+   * If `true`, the position between two cached points is interpolated cubically, and linearly otherwise.
+   * The points along the {@link Curve2D} of the {@link Path2D} are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough.
+   * There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations.
+   */
+  cubic_interp: boolean;
+  /** The node's offset along the curve. */
+  h_offset: float;
+  /**
+   * If `true`, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths.
+   */
+  loop: boolean;
+  /**
+   * The distance along the path, in pixels. Changing this value sets this node's position to a point within the path.
+   */
+  progress: float;
+  /**
+   * The distance along the path as a number in the range 0.0 (for the first vertex) to 1.0 (for the last). This is just another way of expressing the progress within the path, as the offset supplied is multiplied internally by the path's length.
+   * It can be set or get only if the {@link PathFollow2D} is the child of a {@link Path2D} which is part of the scene tree, and that this {@link Path2D} has a {@link Curve2D} with a non-zero length. Otherwise, trying to set this field will print an error, and getting this field will return `0.0`.
+   */
+  progress_ratio: float;
+  /** If `true`, this node rotates to follow the path, with the +X direction facing forward on the path. */
+  rotates: boolean;
+  /** The node's offset perpendicular to the curve. */
+  v_offset: float;
+  set_cubic_interpolation(value: boolean): void;
+  get_cubic_interpolation(): boolean;
+  set_h_offset(value: float): void;
+  get_h_offset(): float;
+  set_loop(value: boolean): void;
+  has_loop(): boolean;
+  set_progress(value: float): void;
+  get_progress(): float;
+  set_progress_ratio(value: float): void;
+  get_progress_ratio(): float;
+  set_rotates(value: boolean): void;
+  is_rotating(): boolean;
+  set_v_offset(value: float): void;
+  get_v_offset(): float;
+}

package/typings/classes/PathFollow3D.d.ts

@@ -0,0 +1,76 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Point sampler for a {@link Path3D}. */
+declare class PathFollow3D extends Node3D {
+  /**
+   * If `true`, the position between two cached points is interpolated cubically, and linearly otherwise.
+   * The points along the {@link Curve3D} of the {@link Path3D} are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough.
+   * There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations.
+   */
+  cubic_interp: boolean;
+  /** The node's offset along the curve. */
+  h_offset: float;
+  /**
+   * If `true`, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths.
+   */
+  loop: boolean;
+  /**
+   * The distance from the first vertex, measured in 3D units along the path. Changing this value sets this node's position to a point within the path.
+   */
+  progress: float;
+  /**
+   * The distance from the first vertex, considering 0.0 as the first vertex and 1.0 as the last. This is just another way of expressing the progress within the path, as the progress supplied is multiplied internally by the path's length.
+   * It can be set or get only if the {@link PathFollow3D} is the child of a {@link Path3D} which is part of the scene tree, and that this {@link Path3D} has a {@link Curve3D} with a non-zero length. Otherwise, trying to set this field will print an error, and getting this field will return `0.0`.
+   */
+  progress_ratio: float;
+  /**
+   * Allows or forbids rotation on one or more axes, depending on the {@link RotationMode} constants being used.
+   */
+  rotation_mode: int;
+  /** If `true`, the tilt property of {@link Curve3D} takes effect. */
+  tilt_enabled: boolean;
+  /**
+   * If `true`, the node moves on the travel path with orienting the +Z axis as forward. See also {@link Vector3.FORWARD} and {@link Vector3.MODEL_FRONT}.
+   */
+  use_model_front: boolean;
+  /** The node's offset perpendicular to the curve. */
+  v_offset: float;
+  set_cubic_interpolation(value: boolean): void;
+  get_cubic_interpolation(): boolean;
+  set_h_offset(value: float): void;
+  get_h_offset(): float;
+  set_loop(value: boolean): void;
+  has_loop(): boolean;
+  set_progress(value: float): void;
+  get_progress(): float;
+  set_progress_ratio(value: float): void;
+  get_progress_ratio(): float;
+  set_rotation_mode(value: int): void;
+  get_rotation_mode(): int;
+  set_tilt_enabled(value: boolean): void;
+  is_tilt_enabled(): boolean;
+  set_use_model_front(value: boolean): void;
+  is_using_model_front(): boolean;
+  set_v_offset(value: float): void;
+  get_v_offset(): float;
+
+  /**
+   * Correct the `transform`. `rotation_mode` implicitly specifies how posture (forward, up and sideway direction) is calculated.
+   */
+  static correct_posture(transform: Transform3D | Projection, rotation_mode: int): Transform3D;
+
+  // enum RotationMode
+  /** Forbids the PathFollow3D to rotate. */
+  static readonly ROTATION_NONE: int;
+  /** Allows the PathFollow3D to rotate in the Y axis only. */
+  static readonly ROTATION_Y: int;
+  /** Allows the PathFollow3D to rotate in both the X, and Y axes. */
+  static readonly ROTATION_XY: int;
+  /** Allows the PathFollow3D to rotate in any axis. */
+  static readonly ROTATION_XYZ: int;
+  /**
+   * Uses the up vector information in a {@link Curve3D} to enforce orientation. This rotation mode requires the {@link Path3D}'s {@link Curve3D.up_vector_enabled} property to be set to `true`.
+   */
+  static readonly ROTATION_ORIENTED: int;
+}

package/typings/classes/Performance.d.ts

@@ -0,0 +1,229 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Exposes performance-related data. */
+declare interface Performance extends GodotObject {
+  /**
+   * Adds a custom monitor with the name `id`. You can specify the category of the monitor using slash delimiters in `id` (for example: `"Game/NumberOfNPCs"`). If there is more than one slash delimiter, then the default category is used. The default category is `"Custom"`. Prints an error if given `id` is already present.
+   * The debugger calls the callable to get the value of custom monitor. The callable must return a zero or positive integer or floating-point number.
+   * Callables are called with arguments supplied in argument array.
+   */
+  add_custom_monitor(id: string, callable: Callable, arguments?: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array, type_?: int): void;
+  /**
+   * Returns the value of custom monitor with given `id`. The callable is called to get the value of custom monitor. See also {@link has_custom_monitor}. Prints an error if the given `id` is absent.
+   */
+  get_custom_monitor(id: string): unknown;
+  /** Returns the names of active custom monitors in an {@link Array}. */
+  get_custom_monitor_names(): Array<string>;
+  /** Returns the {@link MonitorType} values of active custom monitors in an {@link Array}. */
+  get_custom_monitor_types(): PackedInt32Array;
+  /**
+   * Returns the value of one of the available built-in monitors. You should provide one of the {@link Monitor} constants as the argument, like this:
+   * See {@link get_custom_monitor} to query custom performance monitors' values.
+   */
+  get_monitor(monitor: int): float;
+  /**
+   * Returns the last tick in which custom monitor was added/removed (in microseconds since the engine started). This is set to {@link Time.get_ticks_usec} when the monitor is updated.
+   */
+  get_monitor_modification_time(): int;
+  /** Returns `true` if custom monitor with the given `id` is present, `false` otherwise. */
+  has_custom_monitor(id: string): boolean;
+  /** Removes the custom monitor with given `id`. Prints an error if the given `id` is already absent. */
+  remove_custom_monitor(id: string): void;
+
+  // enum Monitor
+  /**
+   * The number of frames rendered in the last second. This metric is only updated once per second, even if queried more often. *Higher is better.*
+   */
+  readonly TIME_FPS: int;
+  /** Time it took to complete one frame, in seconds. *Lower is better.* */
+  readonly TIME_PROCESS: int;
+  /** Time it took to complete one physics frame, in seconds. *Lower is better.* */
+  readonly TIME_PHYSICS_PROCESS: int;
+  /**
+   * Time it took to complete one navigation step, in seconds. This includes navigation map updates as well as agent avoidance calculations. *Lower is better.*
+   */
+  readonly TIME_NAVIGATION_PROCESS: int;
+  /** Static memory currently used, in bytes. Not available in release builds. *Lower is better.* */
+  readonly MEMORY_STATIC: int;
+  /** Available static memory. Not available in release builds. *Lower is better.* */
+  readonly MEMORY_STATIC_MAX: int;
+  /**
+   * Largest amount of memory the message queue buffer has used, in bytes. The message queue is used for deferred functions calls and notifications. *Lower is better.*
+   */
+  readonly MEMORY_MESSAGE_BUFFER_MAX: int;
+  /** Number of objects currently instantiated (including nodes). *Lower is better.* */
+  readonly OBJECT_COUNT: int;
+  /** Number of resources currently used. *Lower is better.* */
+  readonly OBJECT_RESOURCE_COUNT: int;
+  /**
+   * Number of nodes currently instantiated in the scene tree. This also includes the root node. *Lower is better.*
+   */
+  readonly OBJECT_NODE_COUNT: int;
+  /**
+   * Number of orphan nodes, i.e. nodes which are not parented to a node of the scene tree. *Lower is better.*
+   * **Note:** This is only available in debug mode and will always return `0` when used in a project exported in release mode.
+   */
+  readonly OBJECT_ORPHAN_NODE_COUNT: int;
+  /**
+   * The total number of objects in the last rendered frame. This metric doesn't include culled objects (either via hiding nodes, frustum culling or occlusion culling). *Lower is better.*
+   */
+  readonly RENDER_TOTAL_OBJECTS_IN_FRAME: int;
+  /**
+   * The total number of vertices or indices rendered in the last rendered frame. This metric doesn't include primitives from culled objects (either via hiding nodes, frustum culling or occlusion culling). Due to the depth prepass and shadow passes, the number of primitives is always higher than the actual number of vertices in the scene (typically double or triple the original vertex count). *Lower is better.*
+   */
+  readonly RENDER_TOTAL_PRIMITIVES_IN_FRAME: int;
+  /**
+   * The total number of draw calls performed in the last rendered frame. This metric doesn't include culled objects (either via hiding nodes, frustum culling or occlusion culling), since they do not result in draw calls. *Lower is better.*
+   */
+  readonly RENDER_TOTAL_DRAW_CALLS_IN_FRAME: int;
+  /**
+   * The amount of video memory used (texture and vertex memory combined, in bytes). Since this metric also includes miscellaneous allocations, this value is always greater than the sum of {@link RENDER_TEXTURE_MEM_USED} and {@link RENDER_BUFFER_MEM_USED}. *Lower is better.*
+   */
+  readonly RENDER_VIDEO_MEM_USED: int;
+  /** The amount of texture memory used (in bytes). *Lower is better.* */
+  readonly RENDER_TEXTURE_MEM_USED: int;
+  /** The amount of render buffer memory used (in bytes). *Lower is better.* */
+  readonly RENDER_BUFFER_MEM_USED: int;
+  /** Number of active {@link RigidBody2D} nodes in the game. *Lower is better.* */
+  readonly PHYSICS_2D_ACTIVE_OBJECTS: int;
+  /** Number of collision pairs in the 2D physics engine. *Lower is better.* */
+  readonly PHYSICS_2D_COLLISION_PAIRS: int;
+  /** Number of islands in the 2D physics engine. *Lower is better.* */
+  readonly PHYSICS_2D_ISLAND_COUNT: int;
+  /**
+   * Number of active {@link RigidBody3D} and {@link VehicleBody3D} nodes in the game. *Lower is better.*
+   */
+  readonly PHYSICS_3D_ACTIVE_OBJECTS: int;
+  /** Number of collision pairs in the 3D physics engine. *Lower is better.* */
+  readonly PHYSICS_3D_COLLISION_PAIRS: int;
+  /** Number of islands in the 3D physics engine. *Lower is better.* */
+  readonly PHYSICS_3D_ISLAND_COUNT: int;
+  /**
+   * Output latency of the {@link AudioServer}. Equivalent to calling {@link AudioServer.get_output_latency}, it is not recommended to call this every frame.
+   */
+  readonly AUDIO_OUTPUT_LATENCY: int;
+  /**
+   * Number of active navigation maps in {@link NavigationServer2D} and {@link NavigationServer3D}. This also includes the empty default navigation maps created by {@link World2D} and {@link World3D} instances.
+   */
+  readonly NAVIGATION_ACTIVE_MAPS: int;
+  /** Number of active navigation regions in {@link NavigationServer2D} and {@link NavigationServer3D}. */
+  readonly NAVIGATION_REGION_COUNT: int;
+  /**
+   * Number of active navigation agents processing avoidance in {@link NavigationServer2D} and {@link NavigationServer3D}.
+   */
+  readonly NAVIGATION_AGENT_COUNT: int;
+  /** Number of active navigation links in {@link NavigationServer2D} and {@link NavigationServer3D}. */
+  readonly NAVIGATION_LINK_COUNT: int;
+  /** Number of navigation mesh polygons in {@link NavigationServer2D} and {@link NavigationServer3D}. */
+  readonly NAVIGATION_POLYGON_COUNT: int;
+  /**
+   * Number of navigation mesh polygon edges in {@link NavigationServer2D} and {@link NavigationServer3D}.
+   */
+  readonly NAVIGATION_EDGE_COUNT: int;
+  /**
+   * Number of navigation mesh polygon edges that were merged due to edge key overlap in {@link NavigationServer2D} and {@link NavigationServer3D}.
+   */
+  readonly NAVIGATION_EDGE_MERGE_COUNT: int;
+  /**
+   * Number of polygon edges that are considered connected by edge proximity {@link NavigationServer2D} and {@link NavigationServer3D}.
+   */
+  readonly NAVIGATION_EDGE_CONNECTION_COUNT: int;
+  /**
+   * Number of navigation mesh polygon edges that could not be merged in {@link NavigationServer2D} and {@link NavigationServer3D}. The edges still may be connected by edge proximity or with links.
+   */
+  readonly NAVIGATION_EDGE_FREE_COUNT: int;
+  /**
+   * Number of active navigation obstacles in the {@link NavigationServer2D} and {@link NavigationServer3D}.
+   */
+  readonly NAVIGATION_OBSTACLE_COUNT: int;
+  /** Number of pipeline compilations that were triggered by the 2D canvas renderer. */
+  readonly PIPELINE_COMPILATIONS_CANVAS: int;
+  /**
+   * Number of pipeline compilations that were triggered by loading meshes. These compilations will show up as longer loading times the first time a user runs the game and the pipeline is required.
+   */
+  readonly PIPELINE_COMPILATIONS_MESH: int;
+  /**
+   * Number of pipeline compilations that were triggered by building the surface cache before rendering the scene. These compilations will show up as a stutter when loading a scene the first time a user runs the game and the pipeline is required.
+   */
+  readonly PIPELINE_COMPILATIONS_SURFACE: int;
+  /**
+   * Number of pipeline compilations that were triggered while drawing the scene. These compilations will show up as stutters during gameplay the first time a user runs the game and the pipeline is required.
+   */
+  readonly PIPELINE_COMPILATIONS_DRAW: int;
+  /**
+   * Number of pipeline compilations that were triggered to optimize the current scene. These compilations are done in the background and should not cause any stutters whatsoever.
+   */
+  readonly PIPELINE_COMPILATIONS_SPECIALIZATION: int;
+  /**
+   * Number of active navigation maps in the {@link NavigationServer2D}. This also includes the empty default navigation maps created by {@link World2D} instances.
+   */
+  readonly NAVIGATION_2D_ACTIVE_MAPS: int;
+  /** Number of active navigation regions in the {@link NavigationServer2D}. */
+  readonly NAVIGATION_2D_REGION_COUNT: int;
+  /** Number of active navigation agents processing avoidance in the {@link NavigationServer2D}. */
+  readonly NAVIGATION_2D_AGENT_COUNT: int;
+  /** Number of active navigation links in the {@link NavigationServer2D}. */
+  readonly NAVIGATION_2D_LINK_COUNT: int;
+  /** Number of navigation mesh polygons in the {@link NavigationServer2D}. */
+  readonly NAVIGATION_2D_POLYGON_COUNT: int;
+  /** Number of navigation mesh polygon edges in the {@link NavigationServer2D}. */
+  readonly NAVIGATION_2D_EDGE_COUNT: int;
+  /**
+   * Number of navigation mesh polygon edges that were merged due to edge key overlap in the {@link NavigationServer2D}.
+   */
+  readonly NAVIGATION_2D_EDGE_MERGE_COUNT: int;
+  /** Number of polygon edges that are considered connected by edge proximity {@link NavigationServer2D}. */
+  readonly NAVIGATION_2D_EDGE_CONNECTION_COUNT: int;
+  /**
+   * Number of navigation mesh polygon edges that could not be merged in the {@link NavigationServer2D}. The edges still may be connected by edge proximity or with links.
+   */
+  readonly NAVIGATION_2D_EDGE_FREE_COUNT: int;
+  /** Number of active navigation obstacles in the {@link NavigationServer2D}. */
+  readonly NAVIGATION_2D_OBSTACLE_COUNT: int;
+  /**
+   * Number of active navigation maps in the {@link NavigationServer3D}. This also includes the empty default navigation maps created by {@link World3D} instances.
+   */
+  readonly NAVIGATION_3D_ACTIVE_MAPS: int;
+  /** Number of active navigation regions in the {@link NavigationServer3D}. */
+  readonly NAVIGATION_3D_REGION_COUNT: int;
+  /** Number of active navigation agents processing avoidance in the {@link NavigationServer3D}. */
+  readonly NAVIGATION_3D_AGENT_COUNT: int;
+  /** Number of active navigation links in the {@link NavigationServer3D}. */
+  readonly NAVIGATION_3D_LINK_COUNT: int;
+  /** Number of navigation mesh polygons in the {@link NavigationServer3D}. */
+  readonly NAVIGATION_3D_POLYGON_COUNT: int;
+  /** Number of navigation mesh polygon edges in the {@link NavigationServer3D}. */
+  readonly NAVIGATION_3D_EDGE_COUNT: int;
+  /**
+   * Number of navigation mesh polygon edges that were merged due to edge key overlap in the {@link NavigationServer3D}.
+   */
+  readonly NAVIGATION_3D_EDGE_MERGE_COUNT: int;
+  /** Number of polygon edges that are considered connected by edge proximity {@link NavigationServer3D}. */
+  readonly NAVIGATION_3D_EDGE_CONNECTION_COUNT: int;
+  /**
+   * Number of navigation mesh polygon edges that could not be merged in the {@link NavigationServer3D}. The edges still may be connected by edge proximity or with links.
+   */
+  readonly NAVIGATION_3D_EDGE_FREE_COUNT: int;
+  /** Number of active navigation obstacles in the {@link NavigationServer3D}. */
+  readonly NAVIGATION_3D_OBSTACLE_COUNT: int;
+  /** Represents the size of the {@link Monitor} enum. */
+  readonly MONITOR_MAX: int;
+  // enum MonitorType
+  /** Monitor output is formatted as an integer value. */
+  readonly MONITOR_TYPE_QUANTITY: int;
+  /**
+   * Monitor output is formatted as computer memory. Submitted values should represent a number of bytes.
+   */
+  readonly MONITOR_TYPE_MEMORY: int;
+  /**
+   * Monitor output is formatted as time in milliseconds. Submitted values should represent a time in seconds (not milliseconds).
+   */
+  readonly MONITOR_TYPE_TIME: int;
+  /**
+   * Monitor output is formatted as a percentage. Submitted values should represent a fractional value rather than the percentage directly, e.g. `0.5` for `50.00%`.
+   */
+  readonly MONITOR_TYPE_PERCENTAGE: int;
+}
+declare const Performance: Performance;
+

package/typings/classes/PhysicalBone2D.d.ts

@@ -0,0 +1,44 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A {@link RigidBody2D}-derived node used to make {@link Bone2D}s in a {@link Skeleton2D} react to physics.
+ */
+declare class PhysicalBone2D extends RigidBody2D {
+  /**
+   * If `true`, the {@link PhysicalBone2D} will automatically configure the first {@link Joint2D} child node. The automatic configuration is limited to setting up the node properties and positioning the {@link Joint2D}.
+   */
+  auto_configure_joint: boolean;
+  /** The index of the {@link Bone2D} that this {@link PhysicalBone2D} should simulate. */
+  bone2d_index: int;
+  /** The {@link NodePath} to the {@link Bone2D} that this {@link PhysicalBone2D} should simulate. */
+  bone2d_nodepath: NodePath;
+  /**
+   * If `true`, the {@link PhysicalBone2D} will keep the transform of the bone it is bound to when simulating physics.
+   */
+  follow_bone_when_simulating: boolean;
+  /**
+   * If `true`, the {@link PhysicalBone2D} will start simulating using physics. If `false`, the {@link PhysicalBone2D} will follow the transform of the {@link Bone2D} node.
+   * **Note:** To have the {@link Bone2D}s visually follow the {@link PhysicalBone2D}, use a {@link SkeletonModification2DPhysicalBones} modification on the {@link Skeleton2D} node with the {@link Bone2D} nodes.
+   */
+  simulate_physics: boolean;
+  set_auto_configure_joint(value: boolean): void;
+  get_auto_configure_joint(): boolean;
+  set_bone2d_index(value: int): void;
+  get_bone2d_index(): int;
+  set_bone2d_nodepath(value: NodePath | string): void;
+  get_bone2d_nodepath(): NodePath;
+  set_follow_bone_when_simulating(value: boolean): void;
+  get_follow_bone_when_simulating(): boolean;
+  set_simulate_physics(value: boolean): void;
+  get_simulate_physics(): boolean;
+
+  /**
+   * Returns the first {@link Joint2D} child node, if one exists. This is mainly a helper function to make it easier to get the {@link Joint2D} that the {@link PhysicalBone2D} is autoconfiguring.
+   */
+  get_joint(): Joint2D | null;
+  /**
+   * Returns a boolean that indicates whether the {@link PhysicalBone2D} is running and simulating using the Godot 2D physics engine. When `true`, the PhysicalBone2D node is using physics.
+   */
+  is_simulating_physics(): boolean;
+}

package/typings/classes/PhysicalBone3D.d.ts

@@ -0,0 +1,130 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A physics body used to make bones in a {@link Skeleton3D} react to physics. */
+declare class PhysicalBone3D extends PhysicsBody3D {
+  /**
+   * Damps the body's rotation. By default, the body will use the {@link ProjectSettings.physics/3d/default_angular_damp} project setting or any value override set by an {@link Area3D} the body is in. Depending on {@link angular_damp_mode}, you can set {@link angular_damp} to be added to or to replace the body's damping value.
+   * See {@link ProjectSettings.physics/3d/default_angular_damp} for more details about damping.
+   */
+  angular_damp: float;
+  /** Defines how {@link angular_damp} is applied. */
+  angular_damp_mode: int;
+  /** The PhysicalBone3D's rotational velocity in *radians* per second. */
+  angular_velocity: Vector3;
+  /** Sets the body's transform. */
+  body_offset: Transform3D;
+  /**
+   * The body's bounciness. Values range from `0` (no bounce) to `1` (full bounciness).
+   * **Note:** Even with {@link bounce} set to `1.0`, some energy will be lost over time due to linear and angular damping. To have a {@link PhysicalBone3D} that preserves all its energy over time, set {@link bounce} to `1.0`, {@link linear_damp_mode} to {@link DAMP_MODE_REPLACE}, {@link linear_damp} to `0.0`, {@link angular_damp_mode} to {@link DAMP_MODE_REPLACE}, and {@link angular_damp} to `0.0`.
+   */
+  bounce: float;
+  /**
+   * If `true`, the body is deactivated when there is no movement, so it will not take part in the simulation until it is awakened by an external force.
+   */
+  can_sleep: boolean;
+  /**
+   * If `true`, the standard force integration (like gravity or damping) will be disabled for this body. Other than collision response, the body will only move as determined by the {@link _integrate_forces} method, if that virtual method is overridden.
+   * Setting this property will call the method {@link PhysicsServer3D.body_set_omit_force_integration} internally.
+   */
+  custom_integrator: boolean;
+  /** The body's friction, from `0` (frictionless) to `1` (max friction). */
+  friction: float;
+  /**
+   * This is multiplied by {@link ProjectSettings.physics/3d/default_gravity} to produce this body's gravity. For example, a value of `1.0` will apply normal gravity, `2.0` will apply double the gravity, and `0.5` will apply half the gravity to this body.
+   */
+  gravity_scale: float;
+  /** Sets the joint's transform. */
+  joint_offset: Transform3D;
+  /** Sets the joint's rotation in radians. */
+  joint_rotation: Vector3;
+  /** Sets the joint type. */
+  joint_type: int;
+  /**
+   * Damps the body's movement. By default, the body will use {@link ProjectSettings.physics/3d/default_linear_damp} or any value override set by an {@link Area3D} the body is in. Depending on {@link linear_damp_mode}, {@link linear_damp} may be added to or replace the body's damping value.
+   * See {@link ProjectSettings.physics/3d/default_linear_damp} for more details about damping.
+   */
+  linear_damp: float;
+  /** Defines how {@link linear_damp} is applied. */
+  linear_damp_mode: int;
+  /**
+   * The body's linear velocity in units per second. Can be used sporadically, but **don't set this every frame**, because physics may run in another thread and runs at a different granularity. Use {@link _integrate_forces} as your process loop for precise control of the body state.
+   */
+  linear_velocity: Vector3;
+  /** The body's mass. */
+  mass: float;
+  set_angular_damp(value: float): void;
+  get_angular_damp(): float;
+  set_angular_damp_mode(value: int): void;
+  get_angular_damp_mode(): int;
+  set_angular_velocity(value: Vector3 | Vector3i): void;
+  get_angular_velocity(): Vector3;
+  set_body_offset(value: Transform3D | Projection): void;
+  get_body_offset(): Transform3D;
+  set_bounce(value: float): void;
+  get_bounce(): float;
+  set_can_sleep(value: boolean): void;
+  is_able_to_sleep(): boolean;
+  set_use_custom_integrator(value: boolean): void;
+  is_using_custom_integrator(): boolean;
+  set_friction(value: float): void;
+  get_friction(): float;
+  set_gravity_scale(value: float): void;
+  get_gravity_scale(): float;
+  set_joint_offset(value: Transform3D | Projection): void;
+  get_joint_offset(): Transform3D;
+  set_joint_rotation(value: Vector3 | Vector3i): void;
+  get_joint_rotation(): Vector3;
+  set_joint_type(value: int): void;
+  get_joint_type(): int;
+  set_linear_damp(value: float): void;
+  get_linear_damp(): float;
+  set_linear_damp_mode(value: int): void;
+  get_linear_damp_mode(): int;
+  set_linear_velocity(value: Vector3 | Vector3i): void;
+  get_linear_velocity(): Vector3;
+  set_mass(value: float): void;
+  get_mass(): float;
+
+  /**
+   * Called during physics processing, allowing you to read and safely modify the simulation state for the object. By default, it is called before the standard force integration, but the {@link custom_integrator} property allows you to disable the standard force integration and do fully custom force integration for a body.
+   */
+  _integrate_forces(state: PhysicsDirectBodyState3D): void;
+  /**
+   * Applies a directional impulse without affecting rotation.
+   * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_integrate_forces" functions otherwise).
+   * This is equivalent to using {@link apply_impulse} at the body's center of mass.
+   */
+  apply_central_impulse(impulse: Vector3 | Vector3i): void;
+  /**
+   * Applies a positioned impulse to the PhysicsBone3D.
+   * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_integrate_forces" functions otherwise).
+   * `position` is the offset from the PhysicsBone3D origin in global coordinates.
+   */
+  apply_impulse(impulse: Vector3 | Vector3i, position?: Vector3 | Vector3i): void;
+  /** Returns the unique identifier of the PhysicsBone3D. */
+  get_bone_id(): int;
+  /** Returns `true` if the PhysicsBone3D is allowed to simulate physics. */
+  get_simulate_physics(): boolean;
+  /** Returns `true` if the PhysicsBone3D is currently simulating physics. */
+  is_simulating_physics(): boolean;
+
+  // enum DampMode
+  /** In this mode, the body's damping value is added to any value set in areas or the default value. */
+  static readonly DAMP_MODE_COMBINE: int;
+  /** In this mode, the body's damping value replaces any value set in areas or the default value. */
+  static readonly DAMP_MODE_REPLACE: int;
+  // enum JointType
+  /** No joint is applied to the PhysicsBone3D. */
+  static readonly JOINT_TYPE_NONE: int;
+  /** A pin joint is applied to the PhysicsBone3D. */
+  static readonly JOINT_TYPE_PIN: int;
+  /** A cone joint is applied to the PhysicsBone3D. */
+  static readonly JOINT_TYPE_CONE: int;
+  /** A hinge joint is applied to the PhysicsBone3D. */
+  static readonly JOINT_TYPE_HINGE: int;
+  /** A slider joint is applied to the PhysicsBone3D. */
+  static readonly JOINT_TYPE_SLIDER: int;
+  /** A 6 degrees of freedom joint is applied to the PhysicsBone3D. */
+  static readonly JOINT_TYPE_6DOF: int;
+}

package/typings/classes/PhysicalBoneSimulator3D.d.ts

@@ -0,0 +1,29 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Node that can be the parent of {@link PhysicalBone3D} and can apply the simulation results to {@link Skeleton3D}.
+ */
+declare class PhysicalBoneSimulator3D extends SkeletonModifier3D {
+  /**
+   * Returns a boolean that indicates whether the {@link PhysicalBoneSimulator3D} is running and simulating.
+   */
+  is_simulating_physics(): boolean;
+  /**
+   * Adds a collision exception to the physical bone.
+   * Works just like the {@link RigidBody3D} node.
+   */
+  physical_bones_add_collision_exception(exception: RID): void;
+  /**
+   * Removes a collision exception to the physical bone.
+   * Works just like the {@link RigidBody3D} node.
+   */
+  physical_bones_remove_collision_exception(exception: RID): void;
+  /**
+   * Tells the {@link PhysicalBone3D} nodes in the Skeleton to start simulating and reacting to the physics world.
+   * Optionally, a list of bone names can be passed-in, allowing only the passed-in bones to be simulated.
+   */
+  physical_bones_start_simulation(bones?: Array<string>): void;
+  /** Tells the {@link PhysicalBone3D} nodes in the Skeleton to stop simulating. */
+  physical_bones_stop_simulation(): void;
+}

package/typings/classes/PhysicalSkyMaterial.d.ts

@@ -0,0 +1,66 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A material that defines a sky for a {@link Sky} resource by a set of physical properties. */
+declare class PhysicalSkyMaterial extends Material {
+  /** The sky's overall brightness multiplier. Higher values result in a brighter sky. */
+  energy_multiplier: float;
+  /** Modulates the {@link Color} on the bottom half of the sky to represent the ground. */
+  ground_color: Color;
+  /**
+   * Controls the strength of Mie scattering (https://en.wikipedia.org/wiki/Mie_scattering) for the sky. Mie scattering results from light colliding with larger particles (like water). On earth, Mie scattering results in a whitish color around the sun and horizon.
+   */
+  mie_coefficient: float;
+  /**
+   * Controls the {@link Color} of the Mie scattering (https://en.wikipedia.org/wiki/Mie_scattering) effect. While not physically accurate, this allows for the creation of alien-looking planets.
+   */
+  mie_color: Color;
+  /**
+   * Controls the direction of the Mie scattering (https://en.wikipedia.org/wiki/Mie_scattering). A value of `1` means that when light hits a particle it's passing through straight forward. A value of `-1` means that all light is scatter backwards.
+   */
+  mie_eccentricity: float;
+  /**
+   * {@link Texture2D} for the night sky. This is added to the sky, so if it is bright enough, it may be visible during the day.
+   */
+  night_sky: Texture2D | null;
+  /**
+   * Controls the strength of the Rayleigh scattering (https://en.wikipedia.org/wiki/Rayleigh_scattering). Rayleigh scattering results from light colliding with small particles. It is responsible for the blue color of the sky.
+   */
+  rayleigh_coefficient: float;
+  /**
+   * Controls the {@link Color} of the Rayleigh scattering (https://en.wikipedia.org/wiki/Rayleigh_scattering). While not physically accurate, this allows for the creation of alien-looking planets. For example, setting this to a red {@link Color} results in a Mars-looking atmosphere with a corresponding blue sunset.
+   */
+  rayleigh_color: Color;
+  /** Sets the size of the sun disk. Default value is based on Sol's perceived size from Earth. */
+  sun_disk_scale: float;
+  /**
+   * Sets the thickness of the atmosphere. High turbidity creates a foggy-looking atmosphere, while a low turbidity results in a clearer atmosphere.
+   */
+  turbidity: float;
+  /**
+   * If `true`, enables debanding. Debanding adds a small amount of noise which helps reduce banding that appears from the smooth changes in color in the sky.
+   */
+  use_debanding: boolean;
+  set_energy_multiplier(value: float): void;
+  get_energy_multiplier(): float;
+  set_ground_color(value: Color): void;
+  get_ground_color(): Color;
+  set_mie_coefficient(value: float): void;
+  get_mie_coefficient(): float;
+  set_mie_color(value: Color): void;
+  get_mie_color(): Color;
+  set_mie_eccentricity(value: float): void;
+  get_mie_eccentricity(): float;
+  set_night_sky(value: Texture2D | null): void;
+  get_night_sky(): Texture2D | null;
+  set_rayleigh_coefficient(value: float): void;
+  get_rayleigh_coefficient(): float;
+  set_rayleigh_color(value: Color): void;
+  get_rayleigh_color(): Color;
+  set_sun_disk_scale(value: float): void;
+  get_sun_disk_scale(): float;
+  set_turbidity(value: float): void;
+  get_turbidity(): float;
+  set_use_debanding(value: boolean): void;
+  get_use_debanding(): boolean;
+}

package/typings/classes/PhysicsBody2D.d.ts

@@ -0,0 +1,34 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for 2D game objects affected by physics. */
+declare class PhysicsBody2D extends CollisionObject2D {
+  input_pickable: boolean;
+
+  /** Adds a body to the list of bodies that this body can't collide with. */
+  add_collision_exception_with(body: Node): void;
+  /** Returns an array of nodes that were added as collision exceptions for this body. */
+  get_collision_exceptions(): Array<PhysicsBody2D>;
+  /**
+   * Returns the gravity vector computed from all sources that can affect the body, including all gravity overrides from {@link Area2D} nodes and the global world gravity.
+   */
+  get_gravity(): Vector2;
+  /**
+   * Moves the body along the vector `motion`. In order to be frame rate independent in {@link Node._physics_process} or {@link Node._process}, `motion` should be computed using `delta`.
+   * Returns a {@link KinematicCollision2D}, which contains information about the collision when stopped, or when touching another body along the motion.
+   * If `test_only` is `true`, the body does not move but the would-be collision information is given.
+   * `safe_margin` is the extra margin used for collision recovery (see {@link CharacterBody2D.safe_margin} for more details).
+   * If `recovery_as_collision` is `true`, any depenetration from the recovery phase is also reported as a collision; this is used e.g. by {@link CharacterBody2D} for improving floor detection during floor snapping.
+   */
+  move_and_collide(motion: Vector2 | Vector2i, test_only?: boolean, safe_margin?: float, recovery_as_collision?: boolean): KinematicCollision2D | null;
+  /** Removes a body from the list of bodies that this body can't collide with. */
+  remove_collision_exception_with(body: Node): void;
+  /**
+   * Checks for collisions without moving the body. In order to be frame rate independent in {@link Node._physics_process} or {@link Node._process}, `motion` should be computed using `delta`.
+   * Virtually sets the node's position, scale and rotation to that of the given {@link Transform2D}, then tries to move the body along the vector `motion`. Returns `true` if a collision would stop the body from moving along the whole path.
+   * `collision` is an optional object of type {@link KinematicCollision2D}, which contains additional information about the collision when stopped, or when touching another body along the motion.
+   * `safe_margin` is the extra margin used for collision recovery (see {@link CharacterBody2D.safe_margin} for more details).
+   * If `recovery_as_collision` is `true`, any depenetration from the recovery phase is also reported as a collision; this is useful for checking whether the body would *touch* any other bodies.
+   */
+  test_move(from_: Transform2D, motion: Vector2 | Vector2i, collision?: KinematicCollision2D, safe_margin?: float, recovery_as_collision?: boolean): boolean;
+}