typescript-to-gdscript 0.1.0

package/typings/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="globals/globals.d.ts" />
+/// <reference path="globals/gd-helpers.d.ts" />
+/// <reference path="classes/index.d.ts" />

package/typings-overrides/_globals.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Override: Global functions — adds generic type parameters to polymorphic functions.
+ */
+declare function abs<
+  T extends
+    | int
+    | float
+    | Vector2
+    | Vector2i
+    | Vector3
+    | Vector3i
+    | Vector4
+    | Vector4i,
+>(x: T): T;
+
+declare function ceil<
+  T extends
+    | int
+    | float
+    | Vector2
+    | Vector2i
+    | Vector3
+    | Vector3i
+    | Vector4
+    | Vector4i,
+>(x: T): T;
+
+declare function clamp<T extends int | float>(value: T, min: T, max: T): T;
+
+declare function floor<
+  T extends
+    | int
+    | float
+    | Vector2
+    | Vector2i
+    | Vector3
+    | Vector3i
+    | Vector4
+    | Vector4i,
+>(x: T): T;
+
+declare function lerp<
+  T extends
+    | int
+    | float
+    | Vector2
+    | Vector3
+    | Vector4
+    | Color
+    | Quaternion
+    | Basis
+    | Transform2D
+    | Transform3D,
+>(from_: T, to: T, weight: float): T;
+
+declare function load<P extends keyof GodotResources>(
+  path: P,
+): GodotResources[P];
+declare function load<T extends Resource = Resource>(path: string): T;
+
+declare function max<T extends int | float>(...args: T[]): T;
+
+declare function min<T extends int | float>(...args: T[]): T;
+
+declare function preload<P extends keyof GodotResources>(
+  path: P,
+): GodotResources[P];
+declare function preload<T extends Resource = Resource>(path: string): T;
+
+declare function range(end: int): Array<int>;
+declare function range(begin: int, end: int): Array<int>;
+declare function range(begin: int, end: int, step: int): Array<int>;
+
+declare function round<
+  T extends
+    | int
+    | float
+    | Vector2
+    | Vector2i
+    | Vector3
+    | Vector3i
+    | Vector4
+    | Vector4i,
+>(x: T): T;
+
+declare function sign<
+  T extends
+    | int
+    | float
+    | Vector2
+    | Vector2i
+    | Vector3
+    | Vector3i
+    | Vector4
+    | Vector4i,
+>(x: T): T;
+
+declare function snapped<
+  T extends
+    | int
+    | float
+    | Vector2
+    | Vector2i
+    | Vector3
+    | Vector3i
+    | Vector4
+    | Vector4i,
+>(x: T, step: T): T;
+
+declare function weakref(obj: GodotObject): WeakRef;
+
+declare function wrap<T extends int | float>(value: T, min: T, max: T): T;
+
+declare function assert(condition: boolean, message?: string): void;

package/typings-overrides/array.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Override: Array<T> — adds generic type parameter to GDScript Array.
+ *
+ * The generator produces `interface Array { ... }` with `unknown` for element types.
+ * This override replaces it with `interface Array<T>` so that typed arrays work:
+ *   var nums: Array<int> = [];
+ *   nums.append(42);       // OK
+ *   nums.append("hello");  // Error: string is not int
+ */
+interface Array<T = unknown> {
+  all(method: (value: T) => boolean): boolean;
+  any(method: (value: T) => boolean): boolean;
+  append(value: T): void;
+  append_array(array: Array<T>): void;
+  assign(array: Array<T>): void;
+  back(): T;
+  bsearch(value: T, before?: boolean): int;
+  bsearch_custom(
+    value: T,
+    func: (a: T, b: T) => boolean,
+    before?: boolean,
+  ): int;
+  count(value: T): int;
+  duplicate(deep?: boolean): Array<T>;
+  duplicate_deep(deep_subresources_mode?: int): Array<T>;
+  erase(value: T): void;
+  fill(value: T): void;
+  filter(method: (value: T) => boolean): Array<T>;
+  find(what: T, from_?: int): int;
+  find_custom(method: (value: T) => boolean, from_?: int): int;
+  front(): T;
+  get(index: int): T;
+  has(value: T): boolean;
+  insert(position: int, value: T): int;
+  is_same_typed(array: Array<T>): boolean;
+  map<U>(method: (value: T) => U): Array<U>;
+  max(): T;
+  min(): T;
+  pick_random(): T;
+  pop_at(position: int): T;
+  pop_back(): T;
+  pop_front(): T;
+  push_back(value: T): void;
+  push_front(value: T): void;
+  reduce<U>(method: (accum: U, value: T) => U, accum: U): U;
+  reduce(method: (accum: T, value: T) => T, accum?: T): T;
+  rfind(what: T, from_?: int): int;
+  rfind_custom(method: (value: T) => boolean, from_?: int): int;
+  set(index: int, value: T): void;
+  slice(begin: int, end?: int, step?: int, deep?: boolean): Array<T>;
+  sort_custom(func: (a: T, b: T) => boolean): void;
+  [index: number]: T;
+  [Symbol.iterator](): IterableIterator<T>;
+}

package/typings-overrides/callable-function.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 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.
+ */
+interface CallableFunction extends Function {
+  // bind: 0 args — returns same callable
+  bind<F>(this: F): F;
+  // bind: 1 arg from end
+  bind<Init extends any[], L, R>(
+    this: (...args: [...Init, L]) => R,
+    arg: L,
+  ): (...args: Init) => R;
+  // bind: 2 args from end
+  bind<Init extends any[], L1, L2, R>(
+    this: (...args: [...Init, L1, L2]) => R,
+    arg1: L1,
+    arg2: L2,
+  ): (...args: Init) => R;
+  // bind: 3 args from end
+  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: 4 args from end
+  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: 5 args from end
+  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: 6+ args — fallback to untyped Callable
+  bind(...args: any[]): Callable;
+
+  // bindv: 0 args — returns same callable
+  bindv<F>(this: F, args: []): F;
+  // bindv: 1 arg from end
+  bindv<Init extends any[], L, R>(
+    this: (...args: [...Init, L]) => R,
+    args: [L],
+  ): (...args: Init) => R;
+  // bindv: 2 args from end
+  bindv<Init extends any[], L1, L2, R>(
+    this: (...args: [...Init, L1, L2]) => R,
+    args: [L1, L2],
+  ): (...args: Init) => R;
+  // bindv: 3 args from end
+  bindv<Init extends any[], L1, L2, L3, R>(
+    this: (...args: [...Init, L1, L2, L3]) => R,
+    args: [L1, L2, L3],
+  ): (...args: Init) => R;
+  // bindv: 4 args from end
+  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: 5 args from end
+  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: 6+ args — fallback to untyped Callable
+  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;
+}

package/typings-overrides/class-db.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Override: ClassDB — typed instantiate and class_call_static.
+ */
+declare class ClassDB {
+  static instantiate<T extends GodotObject = GodotObject>(class_: string): T;
+  static class_call_static<R = unknown>(
+    class_: string,
+    method: string,
+    ...args: any[]
+  ): R;
+  static class_get_property<V = unknown>(
+    object: GodotObject,
+    property: string,
+  ): V;
+  static class_get_property_default_value<V = unknown>(
+    class_: string,
+    property: string,
+  ): V;
+}

package/typings-overrides/dictionary.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Override: Dictionary<K, V> — typed key/value dictionary.
+ *
+ * Extends the non-generic Object interface (which provides Dictionary methods
+ * for {} literals) with generic overloads for typed dictionaries:
+ *   var scores: Dictionary<string, int> = Dictionary();
+ *   scores.set("player", 100);    // OK — key is string, value is int
+ *   scores.get("player");         // returns int
+ *   scores.keys();                // returns Array<string>
+ */
+interface Dictionary<K = unknown, V = unknown> extends Object {
+  assign(dictionary: Dictionary<K, V>): void;
+  duplicate(deep?: boolean): Dictionary<K, V>;
+  duplicate_deep(deep_subresources_mode?: int): Dictionary<K, V>;
+  erase(key: K): boolean;
+  find_key(value: V): K | null;
+  get(key: K, default_?: V): V;
+  get_or_add(key: K, default_?: V): V;
+  has(key: K): boolean;
+  has_all(keys: Array<K>): boolean;
+  keys(): Array<K>;
+  merge(dictionary: Dictionary<K, V>, overwrite?: boolean): void;
+  merged(dictionary: Dictionary<K, V>, overwrite?: boolean): Dictionary<K, V>;
+  set(key: K, value: V): boolean;
+  values(): Array<V>;
+}

package/typings-overrides/function.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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`.
+ */
+interface Function {
+  bind(...args: any[]): Callable;
+  bindv(args: Array<any>): Callable;
+  call(...args: any[]): unknown;
+  call_deferred(...args: any[]): void;
+  callv(args: Array<any>): unknown;
+  get_argument_count(): int;
+  get_bound_arguments(): Array<unknown>;
+  get_bound_arguments_count(): int;
+  get_method(): string;
+  get_object(): GodotObject;
+  get_object_id(): int;
+  get_unbound_arguments_count(): int;
+  hash(): int;
+  is_custom(): boolean;
+  is_null(): boolean;
+  is_standard(): boolean;
+  is_valid(): boolean;
+  rpc(...args: any[]): void;
+  rpc_id(peer_id: int, ...args: any[]): void;
+  unbind(argcount: int): Callable;
+}

package/typings-overrides/godot-object.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Override: GodotObject — typed get_meta, call, emit_signal.
+ */
+declare class GodotObject {
+  get_meta<T = unknown>(name: string, default_?: T): T;
+  call<N extends string, A extends any[], R>(
+    this: Record<N, (...args: A) => R>,
+    method: N,
+    ...args: A
+  ): R;
+  call(method: string, ...args: any[]): unknown;
+  call_deferred<N extends string, A extends any[], R>(
+    this: Record<N, (...args: A) => R>,
+    method: N,
+    ...args: A
+  ): R;
+  call_deferred(method: string, ...args: any[]): unknown;
+  callv<N extends string, A extends any[], R>(
+    this: Record<N, (...args: A) => R>,
+    method: N,
+    args: A,
+  ): R;
+  callv(method: string, args: any[]): unknown;
+  emit_signal<const N extends string, A extends any[]>(
+    this: Record<N, Signal<A>>,
+    signal: N,
+    ...args: A
+  ): Error.OK | Error.ERR_UNAVAILABLE;
+  emit_signal(signal: string, ...args: any[]): Error.OK | Error.ERR_UNAVAILABLE;
+  get<P extends keyof this>(property: P): this[P];
+  get(property: string): unknown;
+}

package/typings-overrides/node.d.ts

@@ -0,0 +1,9 @@
+declare class Node extends GodotObject {
+  add_to_group(group: GodotGroupNames, persistent?: boolean): void;
+  add_to_group(group: string, persistent?: boolean): void;
+  is_in_group(group: GodotGroupNames): boolean;
+  is_in_group(group: string): boolean;
+  remove_from_group(group: GodotGroupNames): void;
+  remove_from_group(group: string): void;
+  get_parent<N extends Node = Node>(): N;
+}

package/typings-overrides/non-nullable.json

@@ -0,0 +1,117 @@
+{
+  "AcceptDialog": [
+    "add_button",
+    "add_cancel_button",
+    "get_label",
+    "get_ok_button"
+  ],
+  "AudioServer": ["generate_bus_layout"],
+  "AwaitTweener": ["set_timeout"],
+  "BitMap": ["convert_to_image"],
+  "BoxContainer": ["add_spacer"],
+  "CallbackTweener": ["set_delay"],
+  "ColorPickerButton": ["get_picker", "get_popup"],
+  "ConfirmationDialog": ["get_cancel_button"],
+  "Crypto": ["generate_rsa", "generate_self_signed_certificate"],
+  "Cubemap": ["create_placeholder"],
+  "CubemapArray": ["create_placeholder"],
+  "EditorExportPlatform": ["create_preset"],
+  "EditorFileSystem": ["get_filesystem"],
+  "EditorInterface": [
+    "get_base_control",
+    "get_command_palette",
+    "get_editor_main_screen",
+    "get_editor_paths",
+    "get_editor_settings",
+    "get_editor_theme",
+    "get_editor_toaster",
+    "get_editor_undo_redo",
+    "get_editor_viewport_2d",
+    "get_editor_viewport_3d",
+    "get_file_system_dock",
+    "get_inspector",
+    "get_resource_filesystem",
+    "get_resource_previewer",
+    "get_script_editor",
+    "get_selection"
+  ],
+  "EditorPlugin": [
+    "add_control_to_bottom_panel",
+    "get_editor_interface",
+    "get_export_as_menu",
+    "get_script_create_dialog",
+    "get_undo_redo"
+  ],
+  "EditorScript": ["get_editor_interface"],
+  "FileDialog": ["get_line_edit", "get_vbox"],
+  "GraphEdit": ["get_menu_hbox"],
+  "GraphFrame": ["get_titlebar_hbox"],
+  "GraphNode": ["get_titlebar_hbox"],
+  "Image": ["create", "create_empty", "create_from_data"],
+  "ImageTexture": ["create_from_image"],
+  "InputEvent": ["xformed_by"],
+  "ItemList": ["get_h_scroll_bar", "get_v_scroll_bar"],
+  "LineEdit": ["get_menu"],
+  "Material": ["create_placeholder"],
+  "MenuButton": ["get_popup"],
+  "Mesh": ["create_convex_shape", "create_placeholder", "create_trimesh_shape"],
+  "MethodTweener": ["set_delay", "set_ease", "set_trans"],
+  "Node": ["get_tree", "get_viewport", "get_window"],
+  "OptionButton": ["get_popup"],
+  "PackedScene": ["get_state"],
+  "PhysicsRayQueryParameters2D": ["create"],
+  "PhysicsRayQueryParameters3D": ["create"],
+  "PropertyTweener": [
+    "as_relative",
+    "from",
+    "from_current",
+    "set_delay",
+    "set_ease",
+    "set_trans"
+  ],
+  "RichTextLabel": ["get_menu", "get_v_scroll_bar"],
+  "SceneTree": ["create_timer", "create_tween", "get_multiplayer", "root"],
+  "ScriptEditorBase": ["get_base_editor"],
+  "ScriptLanguageExtension": ["_create_script", "_make_template"],
+  "ScrollContainer": ["get_h_scroll_bar", "get_v_scroll_bar"],
+  "Shape3D": ["get_debug_mesh"],
+  "Skeleton3D": ["create_skin_from_rest_transforms", "register_skin"],
+  "SpinBox": ["get_line_edit"],
+  "SplitContainer": ["get_drag_area_control"],
+  "SpriteBase3D": ["generate_triangle_mesh"],
+  "StreamPeerBuffer": ["duplicate"],
+  "SubtweenTweener": ["set_delay"],
+  "SurfaceTool": ["commit"],
+  "TLSOptions": ["client", "client_unsafe", "server"],
+  "TabContainer": ["get_tab_bar"],
+  "TextEdit": ["get_h_scroll_bar", "get_menu", "get_v_scroll_bar"],
+  "TextLine": ["duplicate"],
+  "TextParagraph": ["duplicate"],
+  "TextServerManager": ["get_primary_interface"],
+  "Texture2D": ["create_placeholder"],
+  "Texture2DArray": ["create_placeholder"],
+  "Texture3D": ["create_placeholder"],
+  "ThemeDB": ["get_default_theme"],
+  "TileMap": ["get_pattern"],
+  "TileMapLayer": ["get_pattern"],
+  "TranslationServer": ["get_or_add_domain"],
+  "TreeItem": ["create_child"],
+  "Tween": [
+    "bind_node",
+    "chain",
+    "parallel",
+    "set_ease",
+    "set_ignore_time_scale",
+    "set_loops",
+    "set_parallel",
+    "set_pause_mode",
+    "set_process_mode",
+    "set_speed_scale",
+    "set_trans",
+    "tween_await",
+    "tween_interval",
+    "tween_subtween"
+  ],
+  "VideoStream": ["_instantiate_playback"],
+  "Viewport": ["find_world_2d", "find_world_3d", "get_texture"]
+}

package/typings-overrides/packed-scene.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Override: PackedScene — generic type parameter for root node type.
+ * @typeParam T - The type of the root node/script. Inferred from `GodotResources` when using `load()`/`preload()`.
+ */
+declare class PackedScene<T extends Node = Node> extends Resource {
+  instantiate(edit_state?: int): T;
+}

package/typings-overrides/project-settings.d.ts

@@ -0,0 +1,73 @@
+declare interface ProjectSettings {
+  check_changed_settings_in_group(setting_prefix: string): boolean;
+
+  clear<const T extends keyof ProjectSettings & `${string}/${string}`>(
+    name: T,
+  ): void;
+  clear(name: string): void;
+  get_order<const T extends keyof ProjectSettings & `${string}/${string}`>(
+    name: T,
+  ): int;
+  get_order(name: string): int;
+  get_setting<const T extends keyof ProjectSettings & `${string}/${string}`, D>(
+    name: T,
+    default_value?: ProjectSettings[T],
+  ): ProjectSettings[T];
+  get_setting(name: string, default_value?: unknown): unknown;
+  get_setting_with_override<
+    const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+    name: T,
+  ): ProjectSettings[T];
+  get_setting_with_override(name: string): unknown;
+  get_setting_with_override_and_custom_features<
+    const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+    name: T,
+    features: PackedStringArray,
+  ): ProjectSettings[T];
+  get_setting_with_override_and_custom_features(
+    name: string,
+    features: PackedStringArray,
+  ): unknown;
+  has_setting<const T extends keyof ProjectSettings & `${string}/${string}`>(
+    name: T,
+  ): boolean;
+  has_setting(name: string): boolean;
+  set_as_basic<const T extends keyof ProjectSettings & `${string}/${string}`>(
+    name: T,
+    basic: boolean,
+  ): void;
+  set_as_basic(name: string, basic: boolean): void;
+  set_as_internal<
+    const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+    name: T,
+    internal: boolean,
+  ): void;
+  set_as_internal(name: string, internal: boolean): void;
+  set_initial_value<
+    const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+    name: T,
+    value: unknown,
+  ): void;
+  set_initial_value(name: string, value: unknown): void;
+  set_order<const T extends keyof ProjectSettings & `${string}/${string}`>(
+    name: T,
+    position: int,
+  ): void;
+  set_order(name: string, position: int): void;
+  set_restart_if_changed<
+    const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+    name: T,
+    restart: boolean,
+  ): void;
+  set_restart_if_changed(name: string, restart: boolean): void;
+  set_setting<const T extends keyof ProjectSettings & `${string}/${string}`>(
+    name: T,
+    value: unknown,
+  ): void;
+  set_setting(name: string, value: unknown): void;
+}

package/typings-overrides/property-tweener.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Override: PropertyTweener — typed custom interpolator callback.
+ */
+declare class PropertyTweener {
+  set_custom_interpolator(
+    interpolator_method: (value: float) => float,
+  ): PropertyTweener;
+}

package/typings-overrides/resource.d.ts

@@ -0,0 +1,3 @@
+declare class Resource {
+  duplicate(deep?: boolean): this;
+}

package/typings-overrides/scene-tree.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Override: SceneTree — typed group methods and change_scene_to_file.
+ */
+declare class SceneTree {
+  // Group query methods with typed group names and return types
+  get_nodes_in_group<G extends string>(group: G): Array<GodotGroupNodes<G>>;
+  get_first_node_in_group<G extends string>(group: G): GodotGroupNodes<G>;
+  has_group(name: GodotGroupNames): boolean;
+  has_group(name: string): boolean;
+  get_node_count_in_group(group: GodotGroupNames): int;
+  get_node_count_in_group(group: string): int;
+
+  // Group action methods with typed group names
+  call_group(group: GodotGroupNames, method: string, ...args: any[]): void;
+  call_group(group: string, method: string, ...args: any[]): void;
+  call_group_flags(
+    flags: int,
+    group: GodotGroupNames,
+    method: string,
+    ...args: any[]
+  ): void;
+  call_group_flags(
+    flags: int,
+    group: string,
+    method: string,
+    ...args: any[]
+  ): void;
+  notify_group(group: GodotGroupNames, notification: int): void;
+  notify_group(group: string, notification: int): void;
+  notify_group_flags(
+    call_flags: int,
+    group: GodotGroupNames,
+    notification: int,
+  ): void;
+  notify_group_flags(call_flags: int, group: string, notification: int): void;
+  set_group(group: GodotGroupNames, property: string, value: unknown): void;
+  set_group(group: string, property: string, value: unknown): void;
+  set_group_flags(
+    call_flags: int,
+    group: GodotGroupNames,
+    property: string,
+    value: unknown,
+  ): void;
+  set_group_flags(
+    call_flags: int,
+    group: string,
+    property: string,
+    value: unknown,
+  ): void;
+
+  // Scene navigation
+  change_scene_to_file(path: GodotScenePaths): int;
+  change_scene_to_file(path: string): int;
+}

package/typings-overrides/signal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Override: GodotSignal — typed connect, disconnect, emit for bare Signal variables.
+ * For Signal<[...]> properties on classes, gd-helpers.d.ts already provides typed versions.
+ */
+declare class Signal<T extends any[] = any[]> {
+  emit(...args: T): void;
+  connect(callable: (...args: T) => void): void;
+  disconnect(callable: (...args: T) => void): void;
+  is_connected(callable: (...args: T) => void): boolean;
+}

package/typings-overrides/tween.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Override: Tween — typed callbacks and tween_method generic.
+ */
+declare class Tween {
+  tween_callback(callback: () => void): CallbackTweener;
+  tween_method<T>(
+    method: (value: T) => void,
+    from_: T,
+    to: T,
+    duration: float,
+  ): MethodTweener;
+  tween_property<T>(
+    object: GodotObject,
+    property: string,
+    final_val: T,
+    duration: float,
+  ): PropertyTweener;
+}