typescript-to-gdscript 0.1.0

package/typings/classes/Vector4.d.ts

@@ -0,0 +1,216 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 4D vector using floating-point coordinates. */
+declare interface Vector4 {
+  /** The vector's W component. Also accessible by using the index position `[3]`. */
+  w: float;
+  /** The vector's X component. Also accessible by using the index position `[0]`. */
+  x: float;
+  /** The vector's Y component. Also accessible by using the index position `[1]`. */
+  y: float;
+  /** The vector's Z component. Also accessible by using the index position `[2]`. */
+  z: float;
+
+  /** Returns a new vector with all components in absolute values (i.e. positive). */
+  abs(): Vector4;
+  /** Returns a new vector with all components rounded up (towards positive infinity). */
+  ceil(): Vector4;
+  /**
+   * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link @GlobalScope.clamp} on each component.
+   */
+  clamp(min: Vector4 | Vector4i, max: Vector4 | Vector4i): Vector4;
+  /**
+   * Returns a new vector with all components clamped between `min` and `max`, by running {@link @GlobalScope.clamp} on each component.
+   */
+  clampf(min: float, max: float): Vector4;
+  /**
+   * Performs a cubic interpolation between this vector and `b` using `pre_a` and `post_b` as handles, and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
+   */
+  cubic_interpolate(b: Vector4 | Vector4i, pre_a: Vector4 | Vector4i, post_b: Vector4 | Vector4i, weight: float): Vector4;
+  /**
+   * Performs a cubic interpolation between this vector and `b` using `pre_a` and `post_b` as handles, and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
+   * It can perform smoother interpolation than {@link cubic_interpolate} by the time values.
+   */
+  cubic_interpolate_in_time(b: Vector4 | Vector4i, pre_a: Vector4 | Vector4i, post_b: Vector4 | Vector4i, weight: float, b_t: float, pre_a_t: float, post_b_t: float): Vector4;
+  /**
+   * Returns the normalized vector pointing from this vector to `to`. This is equivalent to using `(b - a).normalized()`.
+   */
+  direction_to(to: Vector4 | Vector4i): Vector4;
+  /**
+   * Returns the squared distance between this vector and `to`.
+   * This method runs faster than {@link distance_to}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+   */
+  distance_squared_to(to: Vector4 | Vector4i): float;
+  /** Returns the distance between this vector and `to`. */
+  distance_to(to: Vector4 | Vector4i): float;
+  /** Returns the dot product of this vector and `with`. */
+  dot(with_: Vector4 | Vector4i): float;
+  /** Returns a new vector with all components rounded down (towards negative infinity). */
+  floor(): Vector4;
+  /**
+   * Returns the inverse of the vector. This is the same as `Vector4(1.0 / v.x, 1.0 / v.y, 1.0 / v.z, 1.0 / v.w)`.
+   */
+  inverse(): Vector4;
+  /**
+   * Returns `true` if this vector and `to` are approximately equal, by running {@link @GlobalScope.is_equal_approx} on each component.
+   */
+  is_equal_approx(to: Vector4 | Vector4i): boolean;
+  /**
+   * Returns `true` if this vector is finite, by calling {@link @GlobalScope.is_finite} on each component.
+   */
+  is_finite(): boolean;
+  /** Returns `true` if the vector is normalized, i.e. its length is approximately equal to 1. */
+  is_normalized(): boolean;
+  /**
+   * Returns `true` if this vector's values are approximately zero, by running {@link @GlobalScope.is_zero_approx} on each component.
+   * This method is faster than using {@link is_equal_approx} with one value as a zero vector.
+   */
+  is_zero_approx(): boolean;
+  /** Returns the length (magnitude) of this vector. */
+  length(): float;
+  /**
+   * Returns the squared length (squared magnitude) of this vector.
+   * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+   */
+  length_squared(): float;
+  /**
+   * Returns the result of the linear interpolation between this vector and `to` by amount `weight`. `weight` is on the range of `0.0` to `1.0`, representing the amount of interpolation.
+   */
+  lerp(to: Vector4 | Vector4i, weight: float): Vector4;
+  /**
+   * Returns the component-wise maximum of this and `with`, equivalent to `Vector4(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z), maxf(w, with.w))`.
+   */
+  max(with_: Vector4 | Vector4i): Vector4;
+  /**
+   * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
+   */
+  max_axis_index(): int;
+  /**
+   * Returns the component-wise maximum of this and `with`, equivalent to `Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w, with))`.
+   */
+  maxf(with_: float): Vector4;
+  /**
+   * Returns the component-wise minimum of this and `with`, equivalent to `Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z), minf(w, with.w))`.
+   */
+  min(with_: Vector4 | Vector4i): Vector4;
+  /**
+   * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_W}.
+   */
+  min_axis_index(): int;
+  /**
+   * Returns the component-wise minimum of this and `with`, equivalent to `Vector4(minf(x, with), minf(y, with), minf(z, with), minf(w, with))`.
+   */
+  minf(with_: float): Vector4;
+  /**
+   * Returns the result of scaling the vector to unit length. Equivalent to `v / v.length()`. Returns `(0, 0, 0, 0)` if `v.length() == 0`. See also {@link is_normalized}.
+   * **Note:** This function may return incorrect values if the input vector length is near zero.
+   */
+  normalized(): Vector4;
+  /**
+   * Returns a vector composed of the {@link @GlobalScope.fposmod} of this vector's components and `mod`.
+   */
+  posmod(mod: float): Vector4;
+  /**
+   * Returns a vector composed of the {@link @GlobalScope.fposmod} of this vector's components and `modv`'s components.
+   */
+  posmodv(modv: Vector4 | Vector4i): Vector4;
+  /**
+   * Returns a new vector with all components rounded to the nearest integer, with halfway cases rounded away from zero.
+   */
+  round(): Vector4;
+  /**
+   * Returns a new vector with each component set to `1.0` if it's positive, `-1.0` if it's negative, and `0.0` if it's zero. The result is identical to calling {@link @GlobalScope.sign} on each component.
+   */
+  sign(): Vector4;
+  /**
+   * Returns a new vector with each component snapped to the nearest multiple of the corresponding component in `step`. This can also be used to round the components to an arbitrary number of decimals.
+   */
+  snapped(step: Vector4 | Vector4i): Vector4;
+  /**
+   * Returns a new vector with each component snapped to the nearest multiple of `step`. This can also be used to round the components to an arbitrary number of decimals.
+   */
+  snappedf(step: float): Vector4;
+
+  // Operator overloads
+  [__ops_ne]: { right: Vector4; ret: boolean };
+  [__ops_mul]: { right: Projection; ret: Vector4 } | { right: Vector4; ret: Vector4 } | { right: float; ret: Vector4 } | { right: int; ret: Vector4 };
+  [__ops_add]: { right: Vector4; ret: Vector4 };
+  [__ops_sub]: { right: Vector4; ret: Vector4 };
+  [__ops_div]: { right: Vector4; ret: Vector4 } | { right: float; ret: Vector4 } | { right: int; ret: Vector4 };
+  [__ops_lt]: { right: Vector4; ret: boolean };
+  [__ops_lte]: { right: Vector4; ret: boolean };
+  [__ops_eq]: { right: Vector4; ret: boolean };
+  [__ops_gt]: { right: Vector4; ret: boolean };
+  [__ops_gte]: { right: Vector4; ret: boolean };
+  [__ops_plus]: { ret: Vector4 };
+  [__ops_minus]: { ret: Vector4 };
+
+  [__variant_converts]: Vector4 | Vector4i;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  clear: never;
+  duplicate: never;
+  duplicate_deep: never;
+  erase: never;
+  find_key: never;
+  get: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has: never;
+  has_all: never;
+  hash: never;
+  is_empty: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  set: never;
+  size: never;
+  sort: never;
+  values: never;
+}
+
+declare interface Vector4Constructor {
+  readonly prototype: Vector4;
+  /** Constructs a default-initialized {@link Vector4} with all components set to `0`. */
+  (): Vector4;
+  /** Constructs a {@link Vector4} as a copy of the given {@link Vector4}. */
+  (from_: Vector4): Vector4;
+  /** Constructs a new {@link Vector4} from the given {@link Vector4i}. */
+  (from_: Vector4i): Vector4;
+  /** Returns a {@link Vector4} with the given components. */
+  (x: float, y: float, z: float, w: float): Vector4;
+
+  // enum Axis
+  /** Enumerated value for the X axis. Returned by {@link max_axis_index} and {@link min_axis_index}. */
+  readonly AXIS_X: int;
+  /** Enumerated value for the Y axis. Returned by {@link max_axis_index} and {@link min_axis_index}. */
+  readonly AXIS_Y: int;
+  /** Enumerated value for the Z axis. Returned by {@link max_axis_index} and {@link min_axis_index}. */
+  readonly AXIS_Z: int;
+  /** Enumerated value for the W axis. Returned by {@link max_axis_index} and {@link min_axis_index}. */
+  readonly AXIS_W: int;
+
+  /** Zero vector, a vector with all components set to `0`. */
+  readonly ZERO: Vector4;
+  /** One vector, a vector with all components set to `1`. */
+  readonly ONE: Vector4;
+  /** Infinity vector, a vector with all components set to {@link @GDScript.INF}. */
+  readonly INF: Vector4;
+}
+declare const Vector4: Vector4Constructor;

package/typings/classes/Vector4i.d.ts

@@ -0,0 +1,164 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 4D vector using integer coordinates. */
+declare interface Vector4i {
+  /** The vector's W component. Also accessible by using the index position `[3]`. */
+  w: int;
+  /** The vector's X component. Also accessible by using the index position `[0]`. */
+  x: int;
+  /** The vector's Y component. Also accessible by using the index position `[1]`. */
+  y: int;
+  /** The vector's Z component. Also accessible by using the index position `[2]`. */
+  z: int;
+
+  /** Returns a new vector with all components in absolute values (i.e. positive). */
+  abs(): Vector4i;
+  /**
+   * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link @GlobalScope.clamp} on each component.
+   */
+  clamp(min: Vector4i | Vector4, max: Vector4i | Vector4): Vector4i;
+  /**
+   * Returns a new vector with all components clamped between `min` and `max`, by running {@link @GlobalScope.clamp} on each component.
+   */
+  clampi(min: int, max: int): Vector4i;
+  /**
+   * Returns the squared distance between this vector and `to`.
+   * This method runs faster than {@link distance_to}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+   */
+  distance_squared_to(to: Vector4i | Vector4): int;
+  /** Returns the distance between this vector and `to`. */
+  distance_to(to: Vector4i | Vector4): float;
+  /** Returns the length (magnitude) of this vector. */
+  length(): float;
+  /**
+   * Returns the squared length (squared magnitude) of this vector.
+   * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+   */
+  length_squared(): int;
+  /**
+   * Returns the component-wise maximum of this and `with`, equivalent to `Vector4i(maxi(x, with.x), maxi(y, with.y), maxi(z, with.z), maxi(w, with.w))`.
+   */
+  max(with_: Vector4i | Vector4): Vector4i;
+  /**
+   * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
+   */
+  max_axis_index(): int;
+  /**
+   * Returns the component-wise maximum of this and `with`, equivalent to `Vector4i(maxi(x, with), maxi(y, with), maxi(z, with), maxi(w, with))`.
+   */
+  maxi(with_: int): Vector4i;
+  /**
+   * Returns the component-wise minimum of this and `with`, equivalent to `Vector4i(mini(x, with.x), mini(y, with.y), mini(z, with.z), mini(w, with.w))`.
+   */
+  min(with_: Vector4i | Vector4): Vector4i;
+  /**
+   * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_W}.
+   */
+  min_axis_index(): int;
+  /**
+   * Returns the component-wise minimum of this and `with`, equivalent to `Vector4i(mini(x, with), mini(y, with), mini(z, with), mini(w, with))`.
+   */
+  mini(with_: int): Vector4i;
+  /**
+   * Returns a new vector with each component set to `1` if it's positive, `-1` if it's negative, and `0` if it's zero. The result is identical to calling {@link @GlobalScope.sign} on each component.
+   */
+  sign(): Vector4i;
+  /**
+   * Returns a new vector with each component snapped to the closest multiple of the corresponding component in `step`.
+   */
+  snapped(step: Vector4i | Vector4): Vector4i;
+  /** Returns a new vector with each component snapped to the closest multiple of `step`. */
+  snappedi(step: int): Vector4i;
+
+  // Operator overloads
+  [__ops_ne]: { right: Vector4i; ret: boolean };
+  [__ops_rem]: { right: Vector4i; ret: Vector4i } | { right: int; ret: Vector4i };
+  [__ops_mul]: { right: Vector4i; ret: Vector4i } | { right: float; ret: Vector4 } | { right: int; ret: Vector4i };
+  [__ops_add]: { right: Vector4i; ret: Vector4i };
+  [__ops_sub]: { right: Vector4i; ret: Vector4i };
+  [__ops_div]: { right: Vector4i; ret: Vector4i } | { right: float; ret: Vector4 } | { right: int; ret: Vector4i };
+  [__ops_lt]: { right: Vector4i; ret: boolean };
+  [__ops_lte]: { right: Vector4i; ret: boolean };
+  [__ops_eq]: { right: Vector4i; ret: boolean };
+  [__ops_gt]: { right: Vector4i; ret: boolean };
+  [__ops_gte]: { right: Vector4i; ret: boolean };
+  [__ops_plus]: { ret: Vector4i };
+  [__ops_minus]: { ret: Vector4i };
+
+  [__variant_converts]: Vector4i | Vector4;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  clear: never;
+  duplicate: never;
+  duplicate_deep: never;
+  erase: never;
+  find_key: never;
+  get: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has: never;
+  has_all: never;
+  hash: never;
+  is_empty: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  set: never;
+  size: never;
+  sort: never;
+  values: never;
+}
+
+declare interface Vector4iConstructor {
+  readonly prototype: Vector4i;
+  /** Constructs a default-initialized {@link Vector4i} with all components set to `0`. */
+  (): Vector4i;
+  /** Constructs a {@link Vector4i} as a copy of the given {@link Vector4i}. */
+  (from_: Vector4i): Vector4i;
+  /**
+   * Constructs a new {@link Vector4i} from the given {@link Vector4} by truncating components' fractional parts (rounding towards zero). For a different behavior consider passing the result of {@link Vector4.ceil}, {@link Vector4.floor} or {@link Vector4.round} to this constructor instead.
+   */
+  (from_: Vector4): Vector4i;
+  /** Returns a {@link Vector4i} with the given components. */
+  (x: int, y: int, z: int, w: int): Vector4i;
+
+  // enum Axis
+  /** Enumerated value for the X axis. Returned by {@link max_axis_index} and {@link min_axis_index}. */
+  readonly AXIS_X: int;
+  /** Enumerated value for the Y axis. Returned by {@link max_axis_index} and {@link min_axis_index}. */
+  readonly AXIS_Y: int;
+  /** Enumerated value for the Z axis. Returned by {@link max_axis_index} and {@link min_axis_index}. */
+  readonly AXIS_Z: int;
+  /** Enumerated value for the W axis. Returned by {@link max_axis_index} and {@link min_axis_index}. */
+  readonly AXIS_W: int;
+
+  /** Zero vector, a vector with all components set to `0`. */
+  readonly ZERO: Vector4i;
+  /** One vector, a vector with all components set to `1`. */
+  readonly ONE: Vector4i;
+  /**
+   * Min vector, a vector with all components equal to `INT32_MIN`. Can be used as a negative integer equivalent of {@link Vector4.INF}.
+   */
+  readonly MIN: Vector4i;
+  /**
+   * Max vector, a vector with all components equal to `INT32_MAX`. Can be used as an integer equivalent of {@link Vector4.INF}.
+   */
+  readonly MAX: Vector4i;
+}
+declare const Vector4i: Vector4iConstructor;

package/typings/classes/VehicleBody3D.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D physics body that simulates the behavior of a car. */
+declare class VehicleBody3D extends RigidBody3D {
+  /**
+   * Slows down the vehicle by applying a braking force. The vehicle is only slowed down if the wheels are in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the {@link RigidBody3D.mass} of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking.
+   */
+  brake: float;
+  /**
+   * Accelerates the vehicle by applying an engine force. The vehicle is only sped up if the wheels that have {@link VehicleWheel3D.use_as_traction} set to `true` and are in contact with a surface. The {@link RigidBody3D.mass} of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration.
+   * **Note:** The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears.
+   * A negative value will result in the vehicle reversing.
+   */
+  engine_force: float;
+  /**
+   * <member name="steering" type="float" setter="set_steering" getter="get_steering" default="0.0">
+   * The steering angle for the vehicle. Setting this to a non-zero value will result in the vehicle turning when it's moving. Wheels that have {@link VehicleWheel3D.use_as_steering} set to `true` will automatically be rotated.
+   * **Note:** This property is edited in the inspector in degrees. In code the property is set in radians.
+   */
+  mass: float;
+  set_brake(value: float): void;
+  get_brake(): float;
+  set_engine_force(value: float): void;
+  get_engine_force(): float;
+}

package/typings/classes/VehicleWheel3D.d.ts

@@ -0,0 +1,112 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D physics body for a {@link VehicleBody3D} that simulates the behavior of a wheel. */
+declare class VehicleWheel3D extends Node3D {
+  /**
+   * Slows down the wheel by applying a braking force. The wheel is only slowed down if it is in contact with a surface. The force you need to apply to adequately slow down your vehicle depends on the {@link RigidBody3D.mass} of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 30 range for hard braking.
+   */
+  brake: float;
+  /**
+   * The damping applied to the suspension spring when being compressed, meaning when the wheel is moving up relative to the vehicle. It is measured in Newton-seconds per millimeter (N⋅s/mm), or megagrams per second (Mg/s). This value should be between 0.0 (no damping) and 1.0, but may be more. A value of 0.0 means the car will keep bouncing as the spring keeps its energy. A good value for this is around 0.3 for a normal car, 0.5 for a race car.
+   */
+  damping_compression: float;
+  /**
+   * The damping applied to the suspension spring when rebounding or extending, meaning when the wheel is moving down relative to the vehicle. It is measured in Newton-seconds per millimeter (N⋅s/mm), or megagrams per second (Mg/s). This value should be between 0.0 (no damping) and 1.0, but may be more. This value should always be slightly higher than the {@link damping_compression} property. For a {@link damping_compression} value of 0.3, try a relaxation value of 0.5.
+   */
+  damping_relaxation: float;
+  /**
+   * Accelerates the wheel by applying an engine force. The wheel is only sped up if it is in contact with a surface. The {@link RigidBody3D.mass} of the vehicle has an effect on the acceleration of the vehicle. For a vehicle with a mass set to 1000, try a value in the 25 - 50 range for acceleration.
+   * **Note:** The simulation does not take the effect of gears into account, you will need to add logic for this if you wish to simulate gears.
+   * A negative value will result in the wheel reversing.
+   */
+  engine_force: float;
+  /**
+   * <member name="steering" type="float" setter="set_steering" getter="get_steering" default="0.0">
+   * The steering angle for the wheel, in radians. Setting this to a non-zero value will result in the vehicle turning when it's moving.
+   */
+  physics_interpolation_mode: int;
+  /**
+   * The maximum force the spring can resist. This value should be higher than a quarter of the {@link RigidBody3D.mass} of the {@link VehicleBody3D} or the spring will not carry the weight of the vehicle. Good results are often obtained by a value that is about 3× to 4× this number.
+   */
+  suspension_max_force: float;
+  /**
+   * The stiffness of the suspension, measured in Newtons per millimeter (N/mm), or megagrams per second squared (Mg/s²). Use a value lower than 50 for an off-road car, a value between 50 and 100 for a race car and try something around 200 for something like a Formula 1 car.
+   */
+  suspension_stiffness: float;
+  /**
+   * This is the distance the suspension can travel. As Godot units are equivalent to meters, keep this setting relatively low. Try a value between 0.1 and 0.3 depending on the type of car.
+   */
+  suspension_travel: float;
+  /**
+   * If `true`, this wheel will be turned when the car steers. This value is used in conjunction with {@link VehicleBody3D.steering} and ignored if you are using the per-wheel {@link steering} value instead.
+   */
+  use_as_steering: boolean;
+  /**
+   * If `true`, this wheel transfers engine force to the ground to propel the vehicle forward. This value is used in conjunction with {@link VehicleBody3D.engine_force} and ignored if you are using the per-wheel {@link engine_force} value instead.
+   */
+  use_as_traction: boolean;
+  /**
+   * This determines how much grip this wheel has. It is combined with the friction setting of the surface the wheel is in contact with. 0.0 means no grip, 1.0 is normal grip. For a drift car setup, try setting the grip of the rear wheels slightly lower than the front wheels, or use a lower value to simulate tire wear.
+   * It's best to set this to 1.0 when starting out.
+   */
+  wheel_friction_slip: float;
+  /** The radius of the wheel in meters. */
+  wheel_radius: float;
+  /**
+   * This is the distance in meters the wheel is lowered from its origin point. Don't set this to 0.0 and move the wheel into position, instead move the origin point of your wheel (the gizmo in Godot) to the position the wheel will take when bottoming out, then use the rest length to move the wheel down to the position it should be in when the car is in rest.
+   */
+  wheel_rest_length: float;
+  /**
+   * This value affects the roll of your vehicle. If set to 1.0 for all wheels, your vehicle will resist body roll, while a value of 0.0 will be prone to rolling over.
+   */
+  wheel_roll_influence: float;
+  set_brake(value: float): void;
+  get_brake(): float;
+  set_damping_compression(value: float): void;
+  get_damping_compression(): float;
+  set_damping_relaxation(value: float): void;
+  get_damping_relaxation(): float;
+  set_engine_force(value: float): void;
+  get_engine_force(): float;
+  set_suspension_max_force(value: float): void;
+  get_suspension_max_force(): float;
+  set_suspension_stiffness(value: float): void;
+  get_suspension_stiffness(): float;
+  set_suspension_travel(value: float): void;
+  get_suspension_travel(): float;
+  set_use_as_steering(value: boolean): void;
+  is_used_as_steering(): boolean;
+  set_use_as_traction(value: boolean): void;
+  is_used_as_traction(): boolean;
+  set_friction_slip(value: float): void;
+  get_friction_slip(): float;
+  set_radius(value: float): void;
+  get_radius(): float;
+  set_suspension_rest_length(value: float): void;
+  get_suspension_rest_length(): float;
+  set_roll_influence(value: float): void;
+  get_roll_influence(): float;
+
+  /**
+   * Returns the contacting body node if valid in the tree, as {@link Node3D}. At the moment, {@link GridMap} is not supported so the node will be always of type {@link PhysicsBody3D}.
+   * Returns `null` if the wheel is not in contact with a surface, or the contact body is not a {@link PhysicsBody3D}.
+   */
+  get_contact_body(): Node3D | null;
+  /**
+   * Returns the normal of the suspension's collision in world space if the wheel is in contact. If the wheel isn't in contact with anything, returns a vector pointing directly along the suspension axis toward the vehicle in world space.
+   */
+  get_contact_normal(): Vector3;
+  /**
+   * Returns the point of the suspension's collision in world space if the wheel is in contact. If the wheel isn't in contact with anything, returns the maximum point of the wheel's ray cast in world space, which is defined by `wheel_rest_length + wheel_radius`.
+   */
+  get_contact_point(): Vector3;
+  /** Returns the rotational speed of the wheel in revolutions per minute. */
+  get_rpm(): float;
+  /**
+   * Returns a value between 0.0 and 1.0 that indicates whether this wheel is skidding. 0.0 is skidding (the wheel has lost grip, e.g. icy terrain), 1.0 means not skidding (the wheel has full grip, e.g. dry asphalt road).
+   */
+  get_skidinfo(): float;
+  /** Returns `true` if this wheel is in contact with a surface. */
+  is_in_contact(): boolean;
+}

package/typings/classes/VideoStream.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base resource for video streams. */
+declare class VideoStream extends Resource {
+  /**
+   * The video file path or URI that this {@link VideoStream} resource handles.
+   * For {@link VideoStreamTheora}, this filename should be an Ogg Theora video file with the `.ogv` extension.
+   */
+  file: string;
+  set_file(value: string | NodePath): void;
+  get_file(): string;
+
+  /**
+   * Called when the video starts playing, to initialize and return a subclass of {@link VideoStreamPlayback}.
+   */
+  _instantiate_playback(): VideoStreamPlayback;
+}

package/typings/classes/VideoStreamPlayback.d.ts

@@ -0,0 +1,52 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Internal class used by {@link VideoStream} to manage playback state when played from a {@link VideoStreamPlayer}.
+ */
+declare class VideoStreamPlayback extends Resource {
+  /** Returns the number of audio channels. */
+  _get_channels(): int;
+  /** Returns the video duration in seconds, if known, or 0 if unknown. */
+  _get_length(): float;
+  /** Returns the audio sample rate used for mixing. */
+  _get_mix_rate(): int;
+  /**
+   * Return the current playback timestamp. Called in response to the {@link VideoStreamPlayer.stream_position} getter.
+   */
+  _get_playback_position(): float;
+  /** Allocates a {@link Texture2D} in which decoded video frames will be drawn. */
+  _get_texture(): Texture2D | null;
+  /** Returns the paused status, as set by {@link _set_paused}. */
+  _is_paused(): boolean;
+  /** Returns the playback state, as determined by calls to {@link _play} and {@link _stop}. */
+  _is_playing(): boolean;
+  /**
+   * Called in response to {@link VideoStreamPlayer.autoplay} or {@link VideoStreamPlayer.play}. Note that manual playback may also invoke {@link _stop} multiple times before this method is called. {@link _is_playing} should return `true` once playing.
+   */
+  _play(): void;
+  /**
+   * Seeks to `time` seconds. Called in response to the {@link VideoStreamPlayer.stream_position} setter.
+   */
+  _seek(time: float): void;
+  /**
+   * Select the audio track `idx`. Called when playback starts, and in response to the {@link VideoStreamPlayer.audio_track} setter.
+   */
+  _set_audio_track(idx: int): void;
+  /**
+   * Set the paused status of video playback. {@link _is_paused} must return `paused`. Called in response to the {@link VideoStreamPlayer.paused} setter.
+   */
+  _set_paused(paused: boolean): void;
+  /**
+   * Stops playback. May be called multiple times before {@link _play}, or in response to {@link VideoStreamPlayer.stop}. {@link _is_playing} should return `false` once stopped.
+   */
+  _stop(): void;
+  /**
+   * Ticks video playback for `delta` seconds. Called every frame as long as both {@link _is_paused} and {@link _is_playing} return `true`.
+   */
+  _update(delta: float): void;
+  /**
+   * Render `num_frames` audio frames (of {@link _get_channels} floats each) from `buffer`, starting from index `offset` in the array. Returns the number of audio frames rendered, or -1 on error.
+   */
+  mix_audio(num_frames: int, buffer?: PackedFloat32Array | Array<unknown>, offset?: int): int;
+}

package/typings/classes/VideoStreamPlayer.d.ts

@@ -0,0 +1,82 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A control used for video playback. */
+declare class VideoStreamPlayer extends Control {
+  /** The embedded audio track to play. */
+  audio_track: int;
+  /** If `true`, playback starts when the scene loads. */
+  autoplay: boolean;
+  /** Amount of time in milliseconds to store in buffer while playing. */
+  buffering_msec: int;
+  /** Audio bus to use for sound playback. */
+  bus: string;
+  /**
+   * If `true`, the video scales to the control size. Otherwise, the control minimum size will be automatically adjusted to match the video stream's dimensions.
+   */
+  expand: boolean;
+  /** If `true`, the video restarts when it reaches its end. */
+  loop: boolean;
+  /** If `true`, the video is paused. */
+  paused: boolean;
+  /**
+   * The stream's current speed scale. `1.0` is the normal speed, while `2.0` is double speed and `0.5` is half speed. A speed scale of `0.0` pauses the video, similar to setting {@link paused} to `true`.
+   */
+  speed_scale: float;
+  /** The assigned video stream. See description for supported formats. */
+  stream: VideoStream | null;
+  /** The current position of the stream, in seconds. */
+  stream_position: float;
+  /** Audio volume as a linear value. */
+  volume: float;
+  /** Audio volume in dB. */
+  volume_db: float;
+  set_audio_track(value: int): void;
+  get_audio_track(): int;
+  set_autoplay(value: boolean): void;
+  has_autoplay(): boolean;
+  set_buffering_msec(value: int): void;
+  get_buffering_msec(): int;
+  set_bus(value: string): void;
+  get_bus(): string;
+  set_expand(value: boolean): void;
+  has_expand(): boolean;
+  set_loop(value: boolean): void;
+  has_loop(): boolean;
+  set_paused(value: boolean): void;
+  is_paused(): boolean;
+  set_speed_scale(value: float): void;
+  get_speed_scale(): float;
+  set_stream(value: VideoStream | null): void;
+  get_stream(): VideoStream | null;
+  set_stream_position(value: float): void;
+  get_stream_position(): float;
+  set_volume(value: float): void;
+  get_volume(): float;
+  set_volume_db(value: float): void;
+  get_volume_db(): float;
+
+  /** The length of the current stream, in seconds. */
+  get_stream_length(): float;
+  /** Returns the video stream's name, or `"<No Stream>"` if no video stream is assigned. */
+  get_stream_name(): string;
+  /** Returns the current frame as a {@link Texture2D}. */
+  get_video_texture(): Texture2D | null;
+  /**
+   * Returns `true` if the video is playing.
+   * **Note:** The video is still considered playing if paused during playback.
+   */
+  is_playing(): boolean;
+  /**
+   * Starts the video playback from the beginning. If the video is paused, this will not unpause the video.
+   */
+  play(): void;
+  /**
+   * Stops the video playback and sets the stream position to 0.
+   * **Note:** Although the stream position will be set to 0, the first frame of the video stream won't become the current frame.
+   */
+  stop(): void;
+
+  /** Emitted when playback is finished. */
+  finished: Signal<[]>;
+}