typescript-to-gdscript 0.1.0

package/typings/classes/CPUParticles3D.d.ts

@@ -0,0 +1,421 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A CPU-based 3D particle emitter. */
+declare class CPUParticles3D extends GeometryInstance3D {
+  /** Number of particles emitted in one emission cycle. */
+  amount: int;
+  /** Each particle's rotation will be animated along this {@link Curve}. Should be a unit {@link Curve}. */
+  angle_curve: Curve | null;
+  /** Maximum angle. */
+  angle_max: float;
+  /** Minimum angle. */
+  angle_min: float;
+  /**
+   * Each particle's angular velocity (rotation speed) will vary along this {@link Curve} over its lifetime. Should be a unit {@link Curve}.
+   */
+  angular_velocity_curve: Curve | null;
+  /** Maximum initial angular velocity (rotation speed) applied to each particle in *degrees* per second. */
+  angular_velocity_max: float;
+  /** Minimum initial angular velocity (rotation speed) applied to each particle in *degrees* per second. */
+  angular_velocity_min: float;
+  /**
+   * Each particle's animation offset will vary along this {@link Curve}. Should be a unit {@link Curve}.
+   */
+  anim_offset_curve: Curve | null;
+  /** Maximum animation offset. */
+  anim_offset_max: float;
+  /** Minimum animation offset. */
+  anim_offset_min: float;
+  /** Each particle's animation speed will vary along this {@link Curve}. Should be a unit {@link Curve}. */
+  anim_speed_curve: Curve | null;
+  /** Maximum particle animation speed. */
+  anim_speed_max: float;
+  /** Minimum particle animation speed. */
+  anim_speed_min: float;
+  /**
+   * Each particle's initial color.
+   * **Note:** {@link color} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertex_color_use_as_albedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link color} will have no visible effect.
+   */
+  color: Color;
+  /**
+   * Each particle's initial color will vary along this {@link Gradient} (multiplied with {@link color}).
+   * **Note:** {@link color_initial_ramp} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertex_color_use_as_albedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link color_initial_ramp} will have no visible effect.
+   */
+  color_initial_ramp: Gradient | null;
+  /**
+   * Each particle's color will vary along this {@link Gradient} over its lifetime (multiplied with {@link color}).
+   * **Note:** {@link color_ramp} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertex_color_use_as_albedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link color_ramp} will have no visible effect.
+   */
+  color_ramp: Gradient | null;
+  /** Damping will vary along this {@link Curve}. Should be a unit {@link Curve}. */
+  damping_curve: Curve | null;
+  /** Maximum damping. */
+  damping_max: float;
+  /** Minimum damping. */
+  damping_min: float;
+  /** Unit vector specifying the particles' emission direction. */
+  direction: Vector3;
+  /** Particle draw order. */
+  draw_order: int;
+  /** The rectangle's extents if {@link emission_shape} is set to {@link EMISSION_SHAPE_BOX}. */
+  emission_box_extents: Vector3;
+  /**
+   * Sets the {@link Color}s to modulate particles by when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
+   * **Note:** {@link emission_colors} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertex_color_use_as_albedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link emission_colors} will have no visible effect.
+   */
+  emission_colors: PackedColorArray;
+  /**
+   * Sets the direction the particles will be emitted in when using {@link EMISSION_SHAPE_DIRECTED_POINTS}.
+   */
+  emission_normals: PackedVector3Array;
+  /**
+   * Sets the initial positions to spawn particles when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
+   */
+  emission_points: PackedVector3Array;
+  /** The axis of the ring when using the emitter {@link EMISSION_SHAPE_RING}. */
+  emission_ring_axis: Vector3;
+  /**
+   * The angle of the cone when using the emitter {@link EMISSION_SHAPE_RING}. The default angle of 90 degrees results in a ring, while an angle of 0 degrees results in a cone. Intermediate values will result in a ring where one end is larger than the other.
+   * **Note:** Depending on {@link emission_ring_height}, the angle may be clamped if the ring's end is reached to form a perfect cone.
+   */
+  emission_ring_cone_angle: float;
+  /** The height of the ring when using the emitter {@link EMISSION_SHAPE_RING}. */
+  emission_ring_height: float;
+  /** The inner radius of the ring when using the emitter {@link EMISSION_SHAPE_RING}. */
+  emission_ring_inner_radius: float;
+  /** The radius of the ring when using the emitter {@link EMISSION_SHAPE_RING}. */
+  emission_ring_radius: float;
+  /** Particles will be emitted inside this region. */
+  emission_shape: int;
+  /** The sphere's radius if {@link EmissionShape} is set to {@link EMISSION_SHAPE_SPHERE}. */
+  emission_sphere_radius: float;
+  /**
+   * If `true`, particles are being emitted. {@link emitting} can be used to start and stop particles from emitting. However, if {@link one_shot} is `true` setting {@link emitting} to `true` will not restart the emission cycle until after all active particles finish processing. You can use the {@link finished} signal to be notified once all active particles finish processing.
+   */
+  emitting: boolean;
+  /**
+   * How rapidly particles in an emission cycle are emitted. If greater than `0`, there will be a gap in emissions before the next cycle begins.
+   */
+  explosiveness: float;
+  /**
+   * The particle system's frame rate is fixed to a value. For example, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the particle system itself.
+   */
+  fixed_fps: int;
+  /** Amount of {@link spread} in Y/Z plane. A value of `1` restricts particles to X/Z plane. */
+  flatness: float;
+  /** If `true`, results in fractional delta calculation which has a smoother particles display effect. */
+  fract_delta: boolean;
+  /** Gravity applied to every particle. */
+  gravity: Vector3;
+  /** Each particle's hue will vary along this {@link Curve}. Should be a unit {@link Curve}. */
+  hue_variation_curve: Curve | null;
+  /** Maximum hue variation. */
+  hue_variation_max: float;
+  /** Minimum hue variation. */
+  hue_variation_min: float;
+  /** Maximum value of the initial velocity. */
+  initial_velocity_max: float;
+  /** Minimum value of the initial velocity. */
+  initial_velocity_min: float;
+  /** Amount of time each particle will exist. */
+  lifetime: float;
+  /** Particle lifetime randomness ratio. */
+  lifetime_randomness: float;
+  /**
+   * Each particle's linear acceleration will vary along this {@link Curve}. Should be a unit {@link Curve}.
+   */
+  linear_accel_curve: Curve | null;
+  /** Maximum linear acceleration. */
+  linear_accel_max: float;
+  /** Minimum linear acceleration. */
+  linear_accel_min: float;
+  /**
+   * If `true`, particles use the parent node's coordinate space (known as local coordinates). This will cause particles to move and rotate along the {@link CPUParticles3D} node (and its parents) when it is moved or rotated. If `false`, particles use global coordinates; they will not move or rotate along the {@link CPUParticles3D} node (and its parents) when it is moved or rotated.
+   */
+  local_coords: boolean;
+  /** The {@link Mesh} used for each particle. If `null`, particles will be spheres. */
+  mesh: Mesh | null;
+  /**
+   * If `true`, only one emission cycle occurs. If set `true` during a cycle, emission will stop at the cycle's end.
+   */
+  one_shot: boolean;
+  /**
+   * Each particle's orbital velocity will vary along this {@link Curve}. Should be a unit {@link Curve}.
+   */
+  orbit_velocity_curve: Curve | null;
+  /** Maximum orbit velocity. */
+  orbit_velocity_max: float;
+  /** Minimum orbit velocity. */
+  orbit_velocity_min: float;
+  /** Align Y axis of particle with the direction of its velocity. */
+  particle_flag_align_y: boolean;
+  /** If `true`, particles will not move on the Z axis. */
+  particle_flag_disable_z: boolean;
+  /** If `true`, particles rotate around Y axis by {@link angle_min}. */
+  particle_flag_rotate_y: boolean;
+  /** Particle system starts as if it had already run for this many seconds. */
+  preprocess: float;
+  /**
+   * Each particle's radial acceleration will vary along this {@link Curve}. Should be a unit {@link Curve}.
+   */
+  radial_accel_curve: Curve | null;
+  /** Maximum radial acceleration. */
+  radial_accel_max: float;
+  /** Minimum radial acceleration. */
+  radial_accel_min: float;
+  /** Emission lifetime randomness ratio. */
+  randomness: float;
+  /** Each particle's scale will vary along this {@link Curve}. Should be a unit {@link Curve}. */
+  scale_amount_curve: Curve | null;
+  /** Maximum scale. */
+  scale_amount_max: float;
+  /** Minimum scale. */
+  scale_amount_min: float;
+  /** Curve for the scale over life, along the x axis. */
+  scale_curve_x: Curve | null;
+  /** Curve for the scale over life, along the y axis. */
+  scale_curve_y: Curve | null;
+  /** Curve for the scale over life, along the z axis. */
+  scale_curve_z: Curve | null;
+  /**
+   * Sets the random seed used by the particle system. Only effective if {@link use_fixed_seed} is `true`.
+   */
+  seed: int;
+  /** Particle system's running speed scaling ratio. A value of `0` can be used to pause the particles. */
+  speed_scale: float;
+  /** If set to `true`, three different scale curves can be specified, one per scale axis. */
+  split_scale: boolean;
+  /**
+   * Each particle's initial direction range from `+spread` to `-spread` degrees. Applied to X/Z plane and Y/Z planes.
+   */
+  spread: float;
+  /**
+   * Each particle's tangential acceleration will vary along this {@link Curve}. Should be a unit {@link Curve}.
+   */
+  tangential_accel_curve: Curve | null;
+  /** Maximum tangent acceleration. */
+  tangential_accel_max: float;
+  /** Minimum tangent acceleration. */
+  tangential_accel_min: float;
+  /**
+   * If `true`, particles will use the same seed for every simulation using the seed defined in {@link seed}. This is useful for situations where the visual outcome should be consistent across replays, for example when using Movie Maker mode.
+   */
+  use_fixed_seed: boolean;
+  /**
+   * The {@link AABB} that determines the node's region which needs to be visible on screen for the particle system to be active.
+   * Grow the box if particles suddenly appear/disappear when the node enters/exits the screen. The {@link AABB} can be grown via code or with the **Particles → Generate AABB** editor tool.
+   */
+  visibility_aabb: AABB;
+  set_amount(value: int): void;
+  get_amount(): int;
+  set_color(value: Color): void;
+  get_color(): Color;
+  set_color_initial_ramp(value: Gradient | null): void;
+  get_color_initial_ramp(): Gradient | null;
+  set_color_ramp(value: Gradient | null): void;
+  get_color_ramp(): Gradient | null;
+  set_direction(value: Vector3 | Vector3i): void;
+  get_direction(): Vector3;
+  set_draw_order(value: int): void;
+  get_draw_order(): int;
+  set_emission_box_extents(value: Vector3 | Vector3i): void;
+  get_emission_box_extents(): Vector3;
+  set_emission_colors(value: PackedColorArray | Array<unknown>): void;
+  get_emission_colors(): PackedColorArray;
+  set_emission_normals(value: PackedVector3Array | Array<unknown>): void;
+  get_emission_normals(): PackedVector3Array;
+  set_emission_points(value: PackedVector3Array | Array<unknown>): void;
+  get_emission_points(): PackedVector3Array;
+  set_emission_ring_axis(value: Vector3 | Vector3i): void;
+  get_emission_ring_axis(): Vector3;
+  set_emission_ring_cone_angle(value: float): void;
+  get_emission_ring_cone_angle(): float;
+  set_emission_ring_height(value: float): void;
+  get_emission_ring_height(): float;
+  set_emission_ring_inner_radius(value: float): void;
+  get_emission_ring_inner_radius(): float;
+  set_emission_ring_radius(value: float): void;
+  get_emission_ring_radius(): float;
+  set_emission_shape(value: int): void;
+  get_emission_shape(): int;
+  set_emission_sphere_radius(value: float): void;
+  get_emission_sphere_radius(): float;
+  set_emitting(value: boolean): void;
+  is_emitting(): boolean;
+  set_explosiveness_ratio(value: float): void;
+  get_explosiveness_ratio(): float;
+  set_fixed_fps(value: int): void;
+  get_fixed_fps(): int;
+  set_flatness(value: float): void;
+  get_flatness(): float;
+  set_fractional_delta(value: boolean): void;
+  get_fractional_delta(): boolean;
+  set_gravity(value: Vector3 | Vector3i): void;
+  get_gravity(): Vector3;
+  set_lifetime(value: float): void;
+  get_lifetime(): float;
+  set_lifetime_randomness(value: float): void;
+  get_lifetime_randomness(): float;
+  set_use_local_coordinates(value: boolean): void;
+  get_use_local_coordinates(): boolean;
+  set_mesh(value: Mesh | null): void;
+  get_mesh(): Mesh | null;
+  set_one_shot(value: boolean): void;
+  get_one_shot(): boolean;
+  set_pre_process_time(value: float): void;
+  get_pre_process_time(): float;
+  set_randomness_ratio(value: float): void;
+  get_randomness_ratio(): float;
+  set_scale_curve_x(value: Curve | null): void;
+  get_scale_curve_x(): Curve | null;
+  set_scale_curve_y(value: Curve | null): void;
+  get_scale_curve_y(): Curve | null;
+  set_scale_curve_z(value: Curve | null): void;
+  get_scale_curve_z(): Curve | null;
+  set_seed(value: int): void;
+  get_seed(): int;
+  set_speed_scale(value: float): void;
+  get_speed_scale(): float;
+  set_split_scale(value: boolean): void;
+  get_split_scale(): boolean;
+  set_spread(value: float): void;
+  get_spread(): float;
+  set_use_fixed_seed(value: boolean): void;
+  get_use_fixed_seed(): boolean;
+  set_visibility_aabb(value: AABB): void;
+  get_visibility_aabb(): AABB;
+
+  /**
+   * Returns the axis-aligned bounding box that contains all the particles that are active in the current frame.
+   */
+  capture_aabb(): AABB;
+  /**
+   * Sets this node's properties to match a given {@link GPUParticles3D} node with an assigned {@link ParticleProcessMaterial}.
+   */
+  convert_from_particles(particles: Node): void;
+  /** Returns the {@link Curve} of the parameter specified by {@link Parameter}. */
+  get_param_curve(param: int): Curve | null;
+  /** Returns the maximum value range for the given parameter. */
+  get_param_max(param: int): float;
+  /** Returns the minimum value range for the given parameter. */
+  get_param_min(param: int): float;
+  /** Returns the enabled state of the given particle flag. */
+  get_particle_flag(particle_flag: int): boolean;
+  /**
+   * Requests the particles to process for extra process time during a single frame.
+   * Useful for particle playback, if used in combination with {@link use_fixed_seed} or by calling {@link restart} with parameter `keep_seed` set to `true`.
+   */
+  request_particles_process(process_time: float): void;
+  /**
+   * Restarts the particle emitter.
+   * If `keep_seed` is `true`, the current random seed will be preserved. Useful for seeking and playback.
+   */
+  restart(keep_seed?: boolean): void;
+  /**
+   * Sets the {@link Curve} of the parameter specified by {@link Parameter}. Should be a unit {@link Curve}.
+   */
+  set_param_curve(param: int, curve: Curve): void;
+  /** Sets the maximum value for the given parameter. */
+  set_param_max(param: int, value: float): void;
+  /** Sets the minimum value for the given parameter. */
+  set_param_min(param: int, value: float): void;
+  /** Enables or disables the given particle flag. */
+  set_particle_flag(particle_flag: int, enable: boolean): void;
+
+  /**
+   * Emitted when all active particles have finished processing. When {@link one_shot} is disabled, particles will process continuously, so this is never emitted.
+   */
+  finished: Signal<[]>;
+
+  // enum DrawOrder
+  /** Particles are drawn in the order emitted. */
+  static readonly DRAW_ORDER_INDEX: int;
+  /**
+   * Particles are drawn in order of remaining lifetime. In other words, the particle with the highest lifetime is drawn at the front.
+   */
+  static readonly DRAW_ORDER_LIFETIME: int;
+  /** Particles are drawn in order of depth. */
+  static readonly DRAW_ORDER_VIEW_DEPTH: int;
+  // enum Parameter
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set initial velocity properties.
+   */
+  static readonly PARAM_INITIAL_LINEAR_VELOCITY: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set angular velocity properties.
+   */
+  static readonly PARAM_ANGULAR_VELOCITY: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set orbital velocity properties.
+   */
+  static readonly PARAM_ORBIT_VELOCITY: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set linear acceleration properties.
+   */
+  static readonly PARAM_LINEAR_ACCEL: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set radial acceleration properties.
+   */
+  static readonly PARAM_RADIAL_ACCEL: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set tangential acceleration properties.
+   */
+  static readonly PARAM_TANGENTIAL_ACCEL: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set damping properties.
+   */
+  static readonly PARAM_DAMPING: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set angle properties.
+   */
+  static readonly PARAM_ANGLE: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set scale properties.
+   */
+  static readonly PARAM_SCALE: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set hue variation properties.
+   */
+  static readonly PARAM_HUE_VARIATION: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set animation speed properties.
+   */
+  static readonly PARAM_ANIM_SPEED: int;
+  /**
+   * Use with {@link set_param_min}, {@link set_param_max}, and {@link set_param_curve} to set animation offset properties.
+   */
+  static readonly PARAM_ANIM_OFFSET: int;
+  /** Represents the size of the {@link Parameter} enum. */
+  static readonly PARAM_MAX: int;
+  // enum ParticleFlags
+  /** Use with {@link set_particle_flag} to set {@link particle_flag_align_y}. */
+  static readonly PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY: int;
+  /** Use with {@link set_particle_flag} to set {@link particle_flag_rotate_y}. */
+  static readonly PARTICLE_FLAG_ROTATE_Y: int;
+  /** Use with {@link set_particle_flag} to set {@link particle_flag_disable_z}. */
+  static readonly PARTICLE_FLAG_DISABLE_Z: int;
+  /** Represents the size of the {@link ParticleFlags} enum. */
+  static readonly PARTICLE_FLAG_MAX: int;
+  // enum EmissionShape
+  /** All particles will be emitted from a single point. */
+  static readonly EMISSION_SHAPE_POINT: int;
+  /** Particles will be emitted in the volume of a sphere. */
+  static readonly EMISSION_SHAPE_SPHERE: int;
+  /** Particles will be emitted on the surface of a sphere. */
+  static readonly EMISSION_SHAPE_SPHERE_SURFACE: int;
+  /** Particles will be emitted in the volume of a box. */
+  static readonly EMISSION_SHAPE_BOX: int;
+  /**
+   * Particles will be emitted at a position chosen randomly among {@link emission_points}. Particle color will be modulated by {@link emission_colors}.
+   */
+  static readonly EMISSION_SHAPE_POINTS: int;
+  /**
+   * Particles will be emitted at a position chosen randomly among {@link emission_points}. Particle velocity and rotation will be set based on {@link emission_normals}. Particle color will be modulated by {@link emission_colors}.
+   */
+  static readonly EMISSION_SHAPE_DIRECTED_POINTS: int;
+  /** Particles will be emitted in a ring or cylinder. */
+  static readonly EMISSION_SHAPE_RING: int;
+  /** Represents the size of the {@link EmissionShape} enum. */
+  static readonly EMISSION_SHAPE_MAX: int;
+}

package/typings/classes/Callable.d.ts

@@ -0,0 +1,203 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Override: Function — untyped base for bare Callable/Function variables.
+ *
+ * Typed overloads (with `this` parameter) live on CallableFunction,
+ * which TS automatically uses for concrete function types (lambdas, etc.).
+ * This base interface works for `var c = new Callable()` and `var fn: Function`.
+ */
+declare interface Function {
+  /**
+   * Returns a copy of this {@link Callable} with one or more arguments bound. When called, the bound arguments are passed *after* the arguments supplied by {@link call}. See also {@link unbind}.
+   * **Note:** When this method is chained with other similar methods, the order in which the argument list is modified is read from right to left.
+   */
+  bind(...args: any[]): Callable;
+  /**
+   * Returns a copy of this {@link Callable} with one or more arguments bound, reading them from an array. When called, the bound arguments are passed *after* the arguments supplied by {@link call}. See also {@link unbind}.
+   * **Note:** When this method is chained with other similar methods, the order in which the argument list is modified is read from right to left.
+   */
+  bindv(args: Array<any>): Callable;
+  /**
+   * Calls the method represented by this {@link Callable}. Arguments can be passed and should match the method's signature.
+   */
+  call(...args: any[]): unknown;
+  /**
+   * Calls the method represented by this {@link Callable} in deferred mode, i.e. at the end of the current frame. Arguments can be passed and should match the method's signature.
+   * **Note:** Deferred calls are processed at idle time. Idle time happens mainly at the end of process and physics frames. In it, deferred calls will be run until there are none left, which means you can defer calls from other deferred calls and they'll still be run in the current idle time cycle. This means you should not call a method deferred from itself (or from a method called by it), as this causes infinite recursion the same way as if you had called the method directly.
+   * See also {@link Object.call_deferred}.
+   */
+  call_deferred(...args: any[]): void;
+  /**
+   * Calls the method represented by this {@link Callable}. Unlike {@link call}, this method expects all arguments to be contained inside the `arguments` {@link Array}.
+   */
+  callv(args: Array<any>): unknown;
+  /**
+   * Returns the total number of arguments this {@link Callable} should take, including optional arguments. This means that any arguments bound with {@link bind} are *subtracted* from the result, and any arguments unbound with {@link unbind} are *added* to the result.
+   */
+  get_argument_count(): int;
+  /**
+   * Returns the array of arguments bound via successive {@link bind} or {@link unbind} calls. These arguments will be added *after* the arguments passed to the call, from which {@link get_unbound_arguments_count} arguments on the right have been previously excluded.
+   */
+  get_bound_arguments(): Array<unknown>;
+  /**
+   * Returns the total amount of arguments bound via successive {@link bind} or {@link unbind} calls. This is the same as the size of the array returned by {@link get_bound_arguments}. See {@link get_bound_arguments} for details.
+   * **Note:** The {@link get_bound_arguments_count} and {@link get_unbound_arguments_count} methods can both return positive values.
+   */
+  get_bound_arguments_count(): int;
+  /**
+   * Returns the name of the method represented by this {@link Callable}. If the callable is a GDScript lambda function, returns the function's name or `"<anonymous lambda>"`.
+   */
+  get_method(): string;
+  /** Returns the object on which this {@link Callable} is called. */
+  get_object(): GodotObject;
+  /** Returns the ID of this {@link Callable}'s object (see {@link Object.get_instance_id}). */
+  get_object_id(): int;
+  /**
+   * Returns the total amount of arguments unbound via successive {@link bind} or {@link unbind} calls. See {@link get_bound_arguments} for details.
+   * **Note:** The {@link get_bound_arguments_count} and {@link get_unbound_arguments_count} methods can both return positive values.
+   */
+  get_unbound_arguments_count(): int;
+  /**
+   * Returns the 32-bit hash value of this {@link Callable}'s object.
+   * **Note:** {@link Callable}s with equal content will always produce identical hash values. However, the reverse is not true. Returning identical hash values does *not* imply the callables are equal, because different callables can have identical hash values due to hash collisions. The engine uses a 32-bit hash algorithm for {@link hash}.
+   */
+  hash(): int;
+  /**
+   * Returns `true` if this {@link Callable} is a custom callable. Custom callables are used:
+   * - for binding/unbinding arguments (see {@link bind} and {@link unbind});
+   * - for representing methods of built-in {@link Variant} types (see {@link create});
+   * - for representing global, lambda, and RPC functions in GDScript;
+   * - for other purposes in the core, GDExtension, and C#.
+   */
+  is_custom(): boolean;
+  /**
+   * Returns `true` if this {@link Callable} has no target to call the method on. Equivalent to `callable == Callable()`.
+   * **Note:** This is *not* the same as `not is_valid()` and using `not is_null()` will *not* guarantee that this callable can be called. Use {@link is_valid} instead.
+   */
+  is_null(): boolean;
+  /**
+   * Returns `true` if this {@link Callable} is a standard callable. This method is the opposite of {@link is_custom}. Returns `false` if this callable is a lambda function.
+   */
+  is_standard(): boolean;
+  /**
+   * Returns `true` if the callable's object exists and has a valid method name assigned, or is a custom callable.
+   */
+  is_valid(): boolean;
+  /**
+   * Perform an RPC (Remote Procedure Call) on all connected peers. This is used for multiplayer and is normally not available, unless the function being called has been marked as *RPC* (using  or {@link Node.rpc_config}). Calling this method on unsupported functions will result in an error. See {@link Node.rpc}.
+   */
+  rpc(...args: any[]): void;
+  /**
+   * Perform an RPC (Remote Procedure Call) on a specific peer ID (see multiplayer documentation for reference). This is used for multiplayer and is normally not available unless the function being called has been marked as *RPC* (using  or {@link Node.rpc_config}). Calling this method on unsupported functions will result in an error. See {@link Node.rpc_id}.
+   */
+  rpc_id(peer_id: int, ...args: any[]): void;
+  /**
+   * Returns a copy of this {@link Callable} with a number of arguments unbound. In other words, when the new callable is called the last few arguments supplied by the user are ignored, according to `argcount`. The remaining arguments are passed to the callable. This allows to use the original callable in a context that attempts to pass more arguments than this callable can handle, e.g. a signal with a fixed number of arguments. See also {@link bind}.
+   * **Note:** When this method is chained with other similar methods, the order in which the argument list is modified is read from right to left.
+   */
+  unbind(argcount: int): Callable;
+
+  // Operator overloads
+  [__ops_ne]: { right: Callable; ret: boolean };
+  [__ops_eq]: { right: Callable; ret: boolean };
+
+  [__variant_converts]: Callable;
+}
+
+type Callable = Function;
+declare interface CallableConstructor {
+  readonly prototype: Callable;
+  /** Constructs an empty {@link Callable}, with no object nor method bound. */
+  (): Callable;
+  /** Constructs a {@link Callable} as a copy of the given {@link Callable}. */
+  (from_: Callable): Callable;
+  /**
+   * Creates a new {@link Callable} for the method named `method` in the specified `object`.
+   * **Note:** For methods of built-in {@link Variant} types, use {@link create} instead.
+   */
+  (object: GodotObject, method: string): Callable;
+  /**
+   * Creates a new {@link Callable} for the method named `method` in the specified `variant`. To represent a method of a built-in {@link Variant} type, a custom callable is used (see {@link is_custom}). If `variant` is {@link Object}, then a standard callable will be created instead.
+   * **Note:** This method is always necessary for the {@link Dictionary} type, as property syntax is used to access its entries. You may also use this method when `variant`'s type is not known in advance (for polymorphism).
+   */
+  create(variant: unknown, method: string): Callable;
+}
+declare const Callable: CallableConstructor;
+/**
+ * Override: CallableFunction — typed overloads for concrete function types.
+ *
+ * TS uses CallableFunction for lambda/arrow types and concrete function references.
+ * These overloads provide type-safe call/bind with `this` parameter inference.
+ *
+ * GDScript bind() appends arguments to the END of the parameter list,
+ * so bind(lastArg) on (a, b, c) => R returns (a, b) => R.
+ */
+declare interface CallableFunction extends Function {
+  bind<F>(this: F): F;
+  bind<Init extends any[], L, R>(
+  this: (...args: [...Init, L]) => R,
+  arg: L,
+  ): (...args: Init) => R;
+  bind<Init extends any[], L1, L2, R>(
+  this: (...args: [...Init, L1, L2]) => R,
+  arg1: L1,
+  arg2: L2,
+  ): (...args: Init) => R;
+  bind<Init extends any[], L1, L2, L3, R>(
+  this: (...args: [...Init, L1, L2, L3]) => R,
+  arg1: L1,
+  arg2: L2,
+  arg3: L3,
+  ): (...args: Init) => R;
+  bind<Init extends any[], L1, L2, L3, L4, R>(
+  this: (...args: [...Init, L1, L2, L3, L4]) => R,
+  arg1: L1,
+  arg2: L2,
+  arg3: L3,
+  arg4: L4,
+  ): (...args: Init) => R;
+  bind<Init extends any[], L1, L2, L3, L4, L5, R>(
+  this: (...args: [...Init, L1, L2, L3, L4, L5]) => R,
+  arg1: L1,
+  arg2: L2,
+  arg3: L3,
+  arg4: L4,
+  arg5: L5,
+  ): (...args: Init) => R;
+  bind(...args: any[]): Callable;
+  bindv<F>(this: F, args: []): F;
+  bindv<Init extends any[], L, R>(
+  this: (...args: [...Init, L]) => R,
+  args: [L],
+  ): (...args: Init) => R;
+  bindv<Init extends any[], L1, L2, R>(
+  this: (...args: [...Init, L1, L2]) => R,
+  args: [L1, L2],
+  ): (...args: Init) => R;
+  bindv<Init extends any[], L1, L2, L3, R>(
+  this: (...args: [...Init, L1, L2, L3]) => R,
+  args: [L1, L2, L3],
+  ): (...args: Init) => R;
+  bindv<Init extends any[], L1, L2, L3, L4, R>(
+  this: (...args: [...Init, L1, L2, L3, L4]) => R,
+  args: [L1, L2, L3, L4],
+  ): (...args: Init) => R;
+  bindv<Init extends any[], L1, L2, L3, L4, L5, R>(
+  this: (...args: [...Init, L1, L2, L3, L4, L5]) => R,
+  args: [L1, L2, L3, L4, L5],
+  ): (...args: Init) => R;
+  bindv(args: Array<any>): Callable;
+  call<A extends any[], R>(this: (...args: A) => R, ...args: A): R;
+  call_deferred<A extends any[], R>(this: (...args: A) => R, ...args: A): void;
+  callv<A extends any[], R>(this: (...args: A) => R, args: A): R;
+  rpc<A extends any[]>(this: (...args: A) => any, ...args: A): void;
+  rpc_id<A extends any[]>(
+  this: (...args: A) => any,
+  peer_id: int,
+  ...args: A
+  ): void;
+  unbind<F>(this: F, argcount: int): F;
+}
+declare interface NewableFunction extends Function {}

package/typings/classes/CallbackTweener.d.ts

@@ -0,0 +1,11 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Calls the specified method after optional delay. */
+declare class CallbackTweener extends Tweener {
+  /**
+   * Makes the callback call delayed by given time in seconds.
+   * **Example:** Call {@link Node.queue_free} after 2 seconds:
+   */
+  set_delay(delay: float): CallbackTweener;
+}