typescript-to-gdscript 0.1.0

package/typings/classes/SkeletonProfile.d.ts

@@ -0,0 +1,119 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for a profile of a virtual skeleton used as a target for retargeting. */
+declare class SkeletonProfile extends Resource {
+  /**
+   * The amount of bones in retargeting section's {@link BoneMap} editor. For example, {@link SkeletonProfileHumanoid} has 56 bones.
+   * The size of elements in {@link BoneMap} updates when changing this property in it's assigned {@link SkeletonProfile}.
+   */
+  bone_size: int;
+  /**
+   * The amount of groups of bones in retargeting section's {@link BoneMap} editor. For example, {@link SkeletonProfileHumanoid} has 4 groups.
+   * This property exists to separate the bone list into several sections in the editor.
+   */
+  group_size: int;
+  /**
+   * A bone name that will be used as the root bone in {@link AnimationTree}. This should be the bone of the parent of hips that exists at the world origin.
+   */
+  root_bone: string;
+  /**
+   * A bone name which will use model's height as the coefficient for normalization. For example, {@link SkeletonProfileHumanoid} defines it as `Hips`.
+   */
+  scale_base_bone: string;
+  set_bone_size(value: int): void;
+  get_bone_size(): int;
+  set_group_size(value: int): void;
+  get_group_size(): int;
+  set_root_bone(value: string): void;
+  get_root_bone(): string;
+  set_scale_base_bone(value: string): void;
+  get_scale_base_bone(): string;
+
+  /** Returns the bone index that matches `bone_name` as its name. */
+  find_bone(bone_name: string): int;
+  /**
+   * Returns the name of the bone at `bone_idx` that will be the key name in the {@link BoneMap}.
+   * In the retargeting process, the returned bone name is the bone name of the target skeleton.
+   */
+  get_bone_name(bone_idx: int): string;
+  /**
+   * Returns the name of the bone which is the parent to the bone at `bone_idx`. The result is empty if the bone has no parent.
+   */
+  get_bone_parent(bone_idx: int): string;
+  /** Returns the name of the bone which is the tail of the bone at `bone_idx`. */
+  get_bone_tail(bone_idx: int): string;
+  /** Returns the group of the bone at `bone_idx`. */
+  get_group(bone_idx: int): string;
+  /**
+   * Returns the name of the group at `group_idx` that will be the drawing group in the {@link BoneMap} editor.
+   */
+  get_group_name(group_idx: int): string;
+  /**
+   * Returns the offset of the bone at `bone_idx` that will be the button position in the {@link BoneMap} editor.
+   * This is the offset with origin at the top left corner of the square.
+   */
+  get_handle_offset(bone_idx: int): Vector2;
+  /** Returns the reference pose transform for bone `bone_idx`. */
+  get_reference_pose(bone_idx: int): Transform3D;
+  /** Returns the tail direction of the bone at `bone_idx`. */
+  get_tail_direction(bone_idx: int): int;
+  /**
+   * Returns the texture of the group at `group_idx` that will be the drawing group background image in the {@link BoneMap} editor.
+   */
+  get_texture(group_idx: int): Texture2D | null;
+  /**
+   * Returns whether the bone at `bone_idx` is required for retargeting.
+   * This value is used by the bone map editor. If this method returns `true`, and no bone is assigned, the handle color will be red on the bone map editor.
+   */
+  is_required(bone_idx: int): boolean;
+  /**
+   * Sets the name of the bone at `bone_idx` that will be the key name in the {@link BoneMap}.
+   * In the retargeting process, the setting bone name is the bone name of the target skeleton.
+   */
+  set_bone_name(bone_idx: int, bone_name: string): void;
+  /**
+   * Sets the bone with name `bone_parent` as the parent of the bone at `bone_idx`. If an empty string is passed, then the bone has no parent.
+   */
+  set_bone_parent(bone_idx: int, bone_parent: string): void;
+  /** Sets the bone with name `bone_tail` as the tail of the bone at `bone_idx`. */
+  set_bone_tail(bone_idx: int, bone_tail: string): void;
+  /** Sets the group of the bone at `bone_idx`. */
+  set_group(bone_idx: int, group: string): void;
+  /**
+   * Sets the name of the group at `group_idx` that will be the drawing group in the {@link BoneMap} editor.
+   */
+  set_group_name(group_idx: int, group_name: string): void;
+  /**
+   * Sets the offset of the bone at `bone_idx` that will be the button position in the {@link BoneMap} editor.
+   * This is the offset with origin at the top left corner of the square.
+   */
+  set_handle_offset(bone_idx: int, handle_offset: Vector2 | Vector2i): void;
+  /** Sets the reference pose transform for bone `bone_idx`. */
+  set_reference_pose(bone_idx: int, bone_name: Transform3D | Projection): void;
+  /** Sets the required status for bone `bone_idx` to `required`. */
+  set_required(bone_idx: int, required: boolean): void;
+  /**
+   * Sets the tail direction of the bone at `bone_idx`.
+   * **Note:** This only specifies the method of calculation. The actual coordinates required should be stored in an external skeleton, so the calculation itself needs to be done externally.
+   */
+  set_tail_direction(bone_idx: int, tail_direction: int): void;
+  /**
+   * Sets the texture of the group at `group_idx` that will be the drawing group background image in the {@link BoneMap} editor.
+   */
+  set_texture(group_idx: int, texture: Texture2D): void;
+
+  /**
+   * This signal is emitted when change the value in profile. This is used to update key name in the {@link BoneMap} and to redraw the {@link BoneMap} editor.
+   * **Note:** This signal is not connected directly to editor to simplify the reference, instead it is passed on to editor through the {@link BoneMap}.
+   */
+  profile_updated: Signal<[]>;
+
+  // enum TailDirection
+  /** Direction to the average coordinates of bone children. */
+  static readonly TAIL_DIRECTION_AVERAGE_CHILDREN: int;
+  /** Direction to the coordinates of specified bone child. */
+  static readonly TAIL_DIRECTION_SPECIFIC_CHILD: int;
+  /** Direction is not calculated. */
+  static readonly TAIL_DIRECTION_END: int;
+}

package/typings/classes/SkeletonProfileHumanoid.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A humanoid {@link SkeletonProfile} preset. */
+declare class SkeletonProfileHumanoid extends SkeletonProfile {
+  bone_size: int;
+  group_size: int;
+  root_bone: string;
+  scale_base_bone: string;
+}

package/typings/classes/Skin.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+declare class Skin extends Resource {
+  add_bind(bone: int, pose: Transform3D | Projection): void;
+  add_named_bind(name: string | NodePath, pose: Transform3D | Projection): void;
+  clear_binds(): void;
+  get_bind_bone(bind_index: int): int;
+  get_bind_count(): int;
+  get_bind_name(bind_index: int): string;
+  get_bind_pose(bind_index: int): Transform3D;
+  set_bind_bone(bind_index: int, bone: int): void;
+  set_bind_count(bind_count: int): void;
+  set_bind_name(bind_index: int, name: string): void;
+  set_bind_pose(bind_index: int, pose: Transform3D | Projection): void;
+}

package/typings/classes/SkinReference.d.ts

@@ -0,0 +1,15 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A reference-counted holder object for a skeleton RID used in the {@link RenderingServer}. */
+declare class SkinReference extends RefCounted {
+  /**
+   * Returns the {@link RID} owned by this SkinReference, as returned by {@link RenderingServer.skeleton_create}.
+   */
+  get_skeleton(): RID;
+  /**
+   * Returns the {@link Skin} connected to this SkinReference. In the case of {@link MeshInstance3D} with no {@link MeshInstance3D.skin} assigned, this will reference an internal default {@link Skin} owned by that {@link MeshInstance3D}.
+   * Note that a single {@link Skin} may have more than one {@link SkinReference} in the case that it is shared by meshes across multiple {@link Skeleton3D} nodes.
+   */
+  get_skin(): Skin | null;
+}

package/typings/classes/Sky.d.ts

@@ -0,0 +1,61 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Defines a 3D environment's background by using a {@link Material}. */
+declare class Sky extends Resource {
+  /**
+   * The method for generating the radiance map from the sky. The radiance map is a cubemap with increasingly blurry versions of the sky corresponding to different levels of roughness. Radiance maps can be expensive to calculate.
+   */
+  process_mode: int;
+  /**
+   * The {@link Sky}'s radiance map size. The higher the radiance map size, the more detailed the lighting from the {@link Sky} will be.
+   * **Note:** Some hardware will have trouble with higher radiance sizes, especially {@link RADIANCE_SIZE_512} and above. Only use such high values on high-end hardware.
+   */
+  radiance_size: int;
+  /**
+   * {@link Material} used to draw the background. Can be {@link PanoramaSkyMaterial}, {@link ProceduralSkyMaterial}, {@link PhysicalSkyMaterial}, or even a {@link ShaderMaterial} if you want to use your own custom shader.
+   */
+  sky_material: Material | null;
+  set_process_mode(value: int): void;
+  get_process_mode(): int;
+  set_radiance_size(value: int): void;
+  get_radiance_size(): int;
+  set_material(value: Material | null): void;
+  get_material(): Material | null;
+
+  // enum RadianceSize
+  /** Radiance texture size is 32×32 pixels. */
+  static readonly RADIANCE_SIZE_32: int;
+  /** Radiance texture size is 64×64 pixels. */
+  static readonly RADIANCE_SIZE_64: int;
+  /** Radiance texture size is 128×128 pixels. */
+  static readonly RADIANCE_SIZE_128: int;
+  /** Radiance texture size is 256×256 pixels. */
+  static readonly RADIANCE_SIZE_256: int;
+  /** Radiance texture size is 512×512 pixels. */
+  static readonly RADIANCE_SIZE_512: int;
+  /** Radiance texture size is 1024×1024 pixels. */
+  static readonly RADIANCE_SIZE_1024: int;
+  /** Radiance texture size is 2048×2048 pixels. */
+  static readonly RADIANCE_SIZE_2048: int;
+  /** Represents the size of the {@link RadianceSize} enum. */
+  static readonly RADIANCE_SIZE_MAX: int;
+  // enum ProcessMode
+  /**
+   * Automatically selects the appropriate process mode based on your sky shader. If your shader uses `TIME` or `POSITION`, this will use {@link PROCESS_MODE_REALTIME}. If your shader uses any of the `LIGHT_*` variables or any custom uniforms, this uses {@link PROCESS_MODE_INCREMENTAL}. Otherwise, this defaults to {@link PROCESS_MODE_QUALITY}.
+   */
+  static readonly PROCESS_MODE_AUTOMATIC: int;
+  /**
+   * Uses high quality importance sampling to process the radiance map. In general, this results in much higher quality than {@link PROCESS_MODE_REALTIME} but takes much longer to generate. This should not be used if you plan on changing the sky at runtime. If you are finding that the reflection is not blurry enough and is showing sparkles or fireflies, try increasing {@link ProjectSettings.rendering/reflections/sky_reflections/ggx_samples}.
+   */
+  static readonly PROCESS_MODE_QUALITY: int;
+  /**
+   * Uses the same high quality importance sampling to process the radiance map as {@link PROCESS_MODE_QUALITY}, but updates over several frames. The number of frames is determined by {@link ProjectSettings.rendering/reflections/sky_reflections/roughness_layers}. Use this when you need highest quality radiance maps, but have a sky that updates slowly.
+   */
+  static readonly PROCESS_MODE_INCREMENTAL: int;
+  /**
+   * Uses the fast filtering algorithm to process the radiance map. In general this results in lower quality, but substantially faster run times. If you need better quality, but still need to update the sky every frame, consider turning on {@link ProjectSettings.rendering/reflections/sky_reflections/fast_filter_high_quality}.
+   * **Note:** The fast filtering algorithm is limited to 256×256 cubemaps, so {@link radiance_size} must be set to {@link RADIANCE_SIZE_256}. Otherwise, a warning is printed and the overridden radiance size is ignored.
+   */
+  static readonly PROCESS_MODE_REALTIME: int;
+}

package/typings/classes/Slider.d.ts

@@ -0,0 +1,49 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for sliders. */
+declare class Slider extends Range {
+  /** If `true`, the slider can be interacted with. If `false`, the value can be changed only by code. */
+  editable: boolean;
+  /**
+   * <member name="scrollable" type="bool" setter="set_scrollable" getter="is_scrollable" default="true">
+   * If `true`, the value can be changed using the mouse wheel.
+   */
+  focus_mode: int;
+  /**
+   * <member name="tick_count" type="int" setter="set_ticks" getter="get_ticks" default="0">
+   * Number of ticks displayed on the slider, including border ticks. Ticks are uniformly-distributed value markers.
+   */
+  step: float;
+  /** If `true`, the slider will display ticks for minimum and maximum values. */
+  ticks_on_borders: boolean;
+  /** Sets the position of the ticks. See {@link TickPosition} for details. */
+  ticks_position: int;
+  set_editable(value: boolean): void;
+  is_editable(): boolean;
+  set_step(value: float): void;
+  get_step(): float;
+  set_ticks_on_borders(value: boolean): void;
+  get_ticks_on_borders(): boolean;
+  set_ticks_position(value: int): void;
+  get_ticks_position(): int;
+
+  /**
+   * Emitted when the grabber stops being dragged. If `value_changed` is `true`, {@link Range.value} is different from the value when the dragging was started.
+   */
+  drag_ended: Signal<[boolean]>;
+  /**
+   * Emitted when the grabber starts being dragged. This is emitted before the corresponding {@link Range.value_changed} signal.
+   */
+  drag_started: Signal<[]>;
+
+  // enum TickPosition
+  /** Places the ticks at the bottom of the {@link HSlider}, or right of the {@link VSlider}. */
+  static readonly TICK_POSITION_BOTTOM_RIGHT: int;
+  /** Places the ticks at the top of the {@link HSlider}, or left of the {@link VSlider}. */
+  static readonly TICK_POSITION_TOP_LEFT: int;
+  /** Places the ticks at the both sides of the slider. */
+  static readonly TICK_POSITION_BOTH: int;
+  /** Places the ticks at the center of the slider. */
+  static readonly TICK_POSITION_CENTER: int;
+}

package/typings/classes/SliderJoint3D.d.ts

@@ -0,0 +1,166 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A physics joint that restricts the movement of a 3D physics body along an axis relative to another physics body.
+ */
+declare class SliderJoint3D extends Joint3D {
+  /**
+   * The amount of damping of the rotation when the limit is surpassed.
+   * A lower damping value allows a rotation initiated by body A to travel to body B slower.
+   */
+  'angular_limit/damping': float;
+  /** The lower limit of rotation in the slider. */
+  'angular_limit/lower_angle': float;
+  /**
+   * The amount of restitution of the rotation when the limit is surpassed.
+   * Does not affect damping.
+   */
+  'angular_limit/restitution': float;
+  /**
+   * A factor applied to the all rotation once the limit is surpassed.
+   * Makes all rotation slower when between 0 and 1.
+   */
+  'angular_limit/softness': float;
+  /** The upper limit of rotation in the slider. */
+  'angular_limit/upper_angle': float;
+  /** The amount of damping of the rotation in the limits. */
+  'angular_motion/damping': float;
+  /** The amount of restitution of the rotation in the limits. */
+  'angular_motion/restitution': float;
+  /** A factor applied to the all rotation in the limits. */
+  'angular_motion/softness': float;
+  /** The amount of damping of the rotation across axes orthogonal to the slider. */
+  'angular_ortho/damping': float;
+  /** The amount of restitution of the rotation across axes orthogonal to the slider. */
+  'angular_ortho/restitution': float;
+  /** A factor applied to the all rotation across axes orthogonal to the slider. */
+  'angular_ortho/softness': float;
+  /**
+   * The amount of damping that happens once the limit defined by {@link linear_limit/lower_distance} and {@link linear_limit/upper_distance} is surpassed.
+   */
+  'linear_limit/damping': float;
+  /** The minimum difference between the pivot points on their X axis before damping happens. */
+  'linear_limit/lower_distance': float;
+  /**
+   * The amount of restitution once the limits are surpassed. The lower, the more velocity-energy gets lost.
+   */
+  'linear_limit/restitution': float;
+  /**
+   * A factor applied to the movement across the slider axis once the limits get surpassed. The lower, the slower the movement.
+   */
+  'linear_limit/softness': float;
+  /** The maximum difference between the pivot points on their X axis before damping happens. */
+  'linear_limit/upper_distance': float;
+  /** The amount of damping inside the slider limits. */
+  'linear_motion/damping': float;
+  /** The amount of restitution inside the slider limits. */
+  'linear_motion/restitution': float;
+  /**
+   * A factor applied to the movement across the slider axis as long as the slider is in the limits. The lower, the slower the movement.
+   */
+  'linear_motion/softness': float;
+  /** The amount of damping when movement is across axes orthogonal to the slider. */
+  'linear_ortho/damping': float;
+  /** The amount of restitution when movement is across axes orthogonal to the slider. */
+  'linear_ortho/restitution': float;
+  /** A factor applied to the movement across axes orthogonal to the slider. */
+  'linear_ortho/softness': float;
+
+  /** Returns the value of the given parameter. */
+  get_param(param: int): float;
+  /** Assigns `value` to the given parameter. */
+  set_param(param: int, value: float): void;
+
+  // enum Param
+  /**
+   * Constant for accessing {@link linear_limit/upper_distance}. The maximum difference between the pivot points on their X axis before damping happens.
+   */
+  static readonly PARAM_LINEAR_LIMIT_UPPER: int;
+  /**
+   * Constant for accessing {@link linear_limit/lower_distance}. The minimum difference between the pivot points on their X axis before damping happens.
+   */
+  static readonly PARAM_LINEAR_LIMIT_LOWER: int;
+  /**
+   * Constant for accessing {@link linear_limit/softness}. A factor applied to the movement across the slider axis once the limits get surpassed. The lower, the slower the movement.
+   */
+  static readonly PARAM_LINEAR_LIMIT_SOFTNESS: int;
+  /**
+   * Constant for accessing {@link linear_limit/restitution}. The amount of restitution once the limits are surpassed. The lower, the more velocity-energy gets lost.
+   */
+  static readonly PARAM_LINEAR_LIMIT_RESTITUTION: int;
+  /**
+   * Constant for accessing {@link linear_limit/damping}. The amount of damping once the slider limits are surpassed.
+   */
+  static readonly PARAM_LINEAR_LIMIT_DAMPING: int;
+  /**
+   * Constant for accessing {@link linear_motion/softness}. A factor applied to the movement across the slider axis as long as the slider is in the limits. The lower, the slower the movement.
+   */
+  static readonly PARAM_LINEAR_MOTION_SOFTNESS: int;
+  /**
+   * Constant for accessing {@link linear_motion/restitution}. The amount of restitution inside the slider limits.
+   */
+  static readonly PARAM_LINEAR_MOTION_RESTITUTION: int;
+  /**
+   * Constant for accessing {@link linear_motion/damping}. The amount of damping inside the slider limits.
+   */
+  static readonly PARAM_LINEAR_MOTION_DAMPING: int;
+  /**
+   * Constant for accessing {@link linear_ortho/softness}. A factor applied to the movement across axes orthogonal to the slider.
+   */
+  static readonly PARAM_LINEAR_ORTHOGONAL_SOFTNESS: int;
+  /**
+   * Constant for accessing {@link linear_motion/restitution}. The amount of restitution when movement is across axes orthogonal to the slider.
+   */
+  static readonly PARAM_LINEAR_ORTHOGONAL_RESTITUTION: int;
+  /**
+   * Constant for accessing {@link linear_motion/damping}. The amount of damping when movement is across axes orthogonal to the slider.
+   */
+  static readonly PARAM_LINEAR_ORTHOGONAL_DAMPING: int;
+  /**
+   * Constant for accessing {@link angular_limit/upper_angle}. The upper limit of rotation in the slider.
+   */
+  static readonly PARAM_ANGULAR_LIMIT_UPPER: int;
+  /**
+   * Constant for accessing {@link angular_limit/lower_angle}. The lower limit of rotation in the slider.
+   */
+  static readonly PARAM_ANGULAR_LIMIT_LOWER: int;
+  /**
+   * Constant for accessing {@link angular_limit/softness}. A factor applied to the all rotation once the limit is surpassed.
+   */
+  static readonly PARAM_ANGULAR_LIMIT_SOFTNESS: int;
+  /**
+   * Constant for accessing {@link angular_limit/restitution}. The amount of restitution of the rotation when the limit is surpassed.
+   */
+  static readonly PARAM_ANGULAR_LIMIT_RESTITUTION: int;
+  /**
+   * Constant for accessing {@link angular_limit/damping}. The amount of damping of the rotation when the limit is surpassed.
+   */
+  static readonly PARAM_ANGULAR_LIMIT_DAMPING: int;
+  /**
+   * Constant for accessing {@link angular_motion/softness}. A factor applied to the all rotation in the limits.
+   */
+  static readonly PARAM_ANGULAR_MOTION_SOFTNESS: int;
+  /**
+   * Constant for accessing {@link angular_motion/restitution}. The amount of restitution of the rotation in the limits.
+   */
+  static readonly PARAM_ANGULAR_MOTION_RESTITUTION: int;
+  /**
+   * Constant for accessing {@link angular_motion/damping}. The amount of damping of the rotation in the limits.
+   */
+  static readonly PARAM_ANGULAR_MOTION_DAMPING: int;
+  /**
+   * Constant for accessing {@link angular_ortho/softness}. A factor applied to the all rotation across axes orthogonal to the slider.
+   */
+  static readonly PARAM_ANGULAR_ORTHOGONAL_SOFTNESS: int;
+  /**
+   * Constant for accessing {@link angular_ortho/restitution}. The amount of restitution of the rotation across axes orthogonal to the slider.
+   */
+  static readonly PARAM_ANGULAR_ORTHOGONAL_RESTITUTION: int;
+  /**
+   * Constant for accessing {@link angular_ortho/damping}. The amount of damping of the rotation across axes orthogonal to the slider.
+   */
+  static readonly PARAM_ANGULAR_ORTHOGONAL_DAMPING: int;
+  /** Represents the size of the {@link Param} enum. */
+  static readonly PARAM_MAX: int;
+}

package/typings/classes/SocketServer.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An abstract class for servers based on sockets. */
+declare class SocketServer extends RefCounted {
+  /** Returns `true` if a connection is available for taking. */
+  is_connection_available(): boolean;
+  /** Returns `true` if the server is currently listening for connections. */
+  is_listening(): boolean;
+  /** Stops listening. */
+  stop(): void;
+  /** If a connection is available, returns a StreamPeerSocket with the connection. */
+  take_socket_connection(): StreamPeerSocket | null;
+}

package/typings/classes/SoftBody3D.d.ts

@@ -0,0 +1,136 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A deformable 3D physics mesh. */
+declare class SoftBody3D extends MeshInstance3D {
+  /**
+   * The physics layers this SoftBody3D **is in**. Collision objects can exist in one or more of 32 different layers. See also {@link collision_mask}.
+   * **Note:** Object A can detect a contact with object B only if object B is in any of the layers that object A scans. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_layer: int;
+  /**
+   * The physics layers this SoftBody3D **scans**. Collision objects can scan one or more of 32 different layers. See also {@link collision_layer}.
+   * **Note:** Object A can detect a contact with object B only if object B is in any of the layers that object A scans. 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 body's damping coefficient. Higher values will slow down the body more noticeably when forces are applied.
+   */
+  damping_coefficient: float;
+  /**
+   * Defines the behavior in physics when {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}.
+   */
+  disable_mode: int;
+  /**
+   * The body's drag coefficient. Higher values increase this body's air resistance.
+   * **Note:** This value is currently unused by Godot's default physics implementation.
+   */
+  drag_coefficient: float;
+  /**
+   * Higher values will result in a stiffer body, while lower values will increase the body's ability to bend. The value can be between `0.0` and `1.0` (inclusive).
+   */
+  linear_stiffness: float;
+  /** {@link NodePath} to a {@link CollisionObject3D} this SoftBody3D should avoid clipping. */
+  parent_collision_ignore: NodePath;
+  /**
+   * The pressure coefficient of this soft body. Simulate pressure build-up from inside this body. Higher values increase the strength of this effect.
+   */
+  pressure_coefficient: float;
+  /** If `true`, the {@link SoftBody3D} will respond to {@link RayCast3D}s. */
+  ray_pickable: boolean;
+  /**
+   * Scales the rest lengths of {@link SoftBody3D}'s edge constraints. Positive values shrink the mesh, while negative values expand it. For example, a value of `0.1` shortens the edges of the mesh by 10%, while `-0.1` expands the edges by 10%.
+   * **Note:** {@link shrinking_factor} is best used on surface meshes with pinned points.
+   */
+  shrinking_factor: float;
+  /**
+   * Increasing this value will improve the resulting simulation, but can affect performance. Use with care.
+   */
+  simulation_precision: int;
+  /** The SoftBody3D's mass. */
+  total_mass: float;
+  set_collision_layer(value: int): void;
+  get_collision_layer(): int;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_damping_coefficient(value: float): void;
+  get_damping_coefficient(): float;
+  set_disable_mode(value: int): void;
+  get_disable_mode(): int;
+  set_drag_coefficient(value: float): void;
+  get_drag_coefficient(): float;
+  set_linear_stiffness(value: float): void;
+  get_linear_stiffness(): float;
+  set_parent_collision_ignore(value: NodePath | string): void;
+  get_parent_collision_ignore(): NodePath;
+  set_pressure_coefficient(value: float): void;
+  get_pressure_coefficient(): float;
+  set_ray_pickable(value: boolean): void;
+  is_ray_pickable(): boolean;
+  set_shrinking_factor(value: float): void;
+  get_shrinking_factor(): float;
+  set_simulation_precision(value: int): void;
+  get_simulation_precision(): int;
+  set_total_mass(value: float): void;
+  get_total_mass(): float;
+
+  /** Adds a body to the list of bodies that this body can't collide with. */
+  add_collision_exception_with(body: Node): void;
+  /**
+   * Distributes and applies a force to all points. A force is time dependent and meant to be applied every physics update.
+   */
+  apply_central_force(force: Vector3 | Vector3i): void;
+  /**
+   * Distributes and applies an impulse to all points.
+   * 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 "_force" functions otherwise).
+   */
+  apply_central_impulse(impulse: Vector3 | Vector3i): void;
+  /** Applies a force to a point. A force is time dependent and meant to be applied every physics update. */
+  apply_force(point_index: int, force: Vector3 | Vector3i): void;
+  /**
+   * Applies an impulse to a point.
+   * 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 "_force" functions otherwise).
+   */
+  apply_impulse(point_index: int, impulse: Vector3 | Vector3i): void;
+  /** Returns an array of nodes that were added as collision exceptions for this body. */
+  get_collision_exceptions(): Array<PhysicsBody3D>;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_layer} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_layer_value(layer_number: int): boolean;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_mask_value(layer_number: int): boolean;
+  /** Returns the internal {@link RID} used by the {@link PhysicsServer3D} for this body. */
+  get_physics_rid(): RID;
+  /** Returns local translation of a vertex in the surface array. */
+  get_point_transform(point_index: int): Vector3;
+  /** Returns `true` if vertex is set to pinned. */
+  is_point_pinned(point_index: int): boolean;
+  /** Removes a body from the list of bodies that this body can't collide with. */
+  remove_collision_exception_with(body: Node): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_layer}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_layer_value(layer_number: int, value: boolean): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_mask_value(layer_number: int, value: boolean): void;
+  /**
+   * Sets the pinned state of a surface vertex. When set to `true`, the optional `attachment_path` can define a {@link Node3D} the pinned vertex will be attached to.
+   */
+  set_point_pinned(point_index: int, pinned: boolean, attachment_path?: NodePath | string, insert_at?: int): void;
+
+  // enum DisableMode
+  /**
+   * When {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}, remove from the physics simulation to stop all physics interactions with this {@link SoftBody3D}.
+   * Automatically re-added to the physics simulation when the {@link Node} is processed again.
+   */
+  static readonly DISABLE_MODE_REMOVE: int;
+  /**
+   * When {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}, do not affect the physics simulation.
+   */
+  static readonly DISABLE_MODE_KEEP_ACTIVE: int;
+}

package/typings/classes/SphereMesh.d.ts

@@ -0,0 +1,29 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Class representing a spherical {@link PrimitiveMesh}. */
+declare class SphereMesh extends PrimitiveMesh {
+  /** Full height of the sphere. */
+  height: float;
+  /**
+   * If `true`, a hemisphere is created rather than a full sphere.
+   * **Note:** To get a regular hemisphere, the height and radius of the sphere must be equal.
+   */
+  is_hemisphere: boolean;
+  /** Number of radial segments on the sphere. */
+  radial_segments: int;
+  /** Radius of sphere. */
+  radius: float;
+  /** Number of segments along the height of the sphere. */
+  rings: int;
+  set_height(value: float): void;
+  get_height(): float;
+  set_is_hemisphere(value: boolean): void;
+  get_is_hemisphere(): boolean;
+  set_radial_segments(value: int): void;
+  get_radial_segments(): int;
+  set_radius(value: float): void;
+  get_radius(): float;
+  set_rings(value: int): void;
+  get_rings(): int;
+}

package/typings/classes/SphereOccluder3D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Spherical shape for use with occlusion culling in {@link OccluderInstance3D}. */
+declare class SphereOccluder3D extends Occluder3D {
+  /** The sphere's radius in 3D units. */
+  radius: float;
+  set_radius(value: float): void;
+  get_radius(): float;
+}

package/typings/classes/SphereShape3D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D sphere shape used for physics collision. */
+declare class SphereShape3D extends Shape3D {
+  /** The sphere's radius. The shape's diameter is double the radius. */
+  radius: float;
+  set_radius(value: float): void;
+  get_radius(): float;
+}