typescript-to-gdscript 0.1.0

package/typings/classes/ScriptExtension.d.ts

@@ -0,0 +1,48 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+declare class ScriptExtension extends Script {
+  _can_instantiate(): boolean;
+  _editor_can_reload_from_file(): boolean;
+  _get_base_script(): Script | null;
+  _get_class_icon_path(): string;
+  _get_constants(): Dictionary;
+  _get_doc_class_name(): string;
+  _get_documentation(): Array<Dictionary>;
+  _get_global_name(): string;
+  _get_instance_base_type(): string;
+  _get_language(): ScriptLanguage | null;
+  _get_member_line(member: string): int;
+  _get_members(): Array<string>;
+  _get_method_info(method: string): Dictionary;
+  _get_property_default_value(property: string): unknown;
+  _get_rpc_config(): unknown;
+  /**
+   * Return the expected argument count for the given `method`, or `null` if it can't be determined (which will then fall back to the default behavior).
+   */
+  _get_script_method_argument_count(method: string): unknown;
+  _get_script_method_list(): Array<Dictionary>;
+  _get_script_property_list(): Array<Dictionary>;
+  _get_script_signal_list(): Array<Dictionary>;
+  _get_source_code(): string;
+  _has_method(method: string): boolean;
+  _has_property_default_value(property: string): boolean;
+  _has_script_signal(signal: string): boolean;
+  _has_source_code(): boolean;
+  _has_static_method(method: string): boolean;
+  _inherits_script(script: Script): boolean;
+  _instance_create(for_object: GodotObject): void;
+  _instance_has(object: GodotObject): boolean;
+  /**
+   * Returns `true` if the script is an abstract script. Abstract scripts cannot be instantiated directly, instead other scripts should inherit them. Abstract scripts will be either unselectable or hidden in the Create New Node dialog (unselectable if there are non-abstract classes inheriting it, otherwise hidden).
+   */
+  _is_abstract(): boolean;
+  _is_placeholder_fallback_enabled(): boolean;
+  _is_tool(): boolean;
+  _is_valid(): boolean;
+  _placeholder_erased(placeholder: void): void;
+  _placeholder_instance_create(for_object: GodotObject): void;
+  _reload(keep_state: boolean): int;
+  _set_source_code(code: string | NodePath): void;
+  _update_exports(): void;
+}

package/typings/classes/ScriptLanguage.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+declare class ScriptLanguage extends GodotObject {
+
+  // enum ScriptNameCasing
+  static readonly SCRIPT_NAME_CASING_AUTO: int;
+  static readonly SCRIPT_NAME_CASING_PASCAL_CASE: int;
+  static readonly SCRIPT_NAME_CASING_SNAKE_CASE: int;
+  static readonly SCRIPT_NAME_CASING_KEBAB_CASE: int;
+  static readonly SCRIPT_NAME_CASING_CAMEL_CASE: int;
+}

package/typings/classes/ScriptLanguageExtension.d.ts

@@ -0,0 +1,110 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+declare class ScriptLanguageExtension extends ScriptLanguage {
+  _add_global_constant(name: string, value: unknown): void;
+  _add_named_global_constant(name: string, value: unknown): void;
+  _auto_indent_code(code: string | NodePath, from_line: int, to_line: int): string;
+  _can_inherit_from_file(): boolean;
+  _can_make_function(): boolean;
+  _complete_code(code: string | NodePath, path: string | NodePath, owner: GodotObject): Dictionary;
+  _create_script(): GodotObject;
+  _debug_get_current_stack_info(): Array<Dictionary>;
+  _debug_get_error(): string;
+  _debug_get_globals(max_subitems: int, max_depth: int): Dictionary;
+  _debug_get_stack_level_count(): int;
+  _debug_get_stack_level_function(level: int): string;
+  _debug_get_stack_level_instance(level: int): void;
+  _debug_get_stack_level_line(level: int): int;
+  _debug_get_stack_level_locals(level: int, max_subitems: int, max_depth: int): Dictionary;
+  _debug_get_stack_level_members(level: int, max_subitems: int, max_depth: int): Dictionary;
+  /** Returns the source associated with a given debug stack position. */
+  _debug_get_stack_level_source(level: int): string;
+  _debug_parse_stack_level_expression(level: int, expression: string | NodePath, max_subitems: int, max_depth: int): string;
+  /** Returns the line where the function is defined in the code, or `-1` if the function is not present. */
+  _find_function(function_: string | NodePath, code: string | NodePath): int;
+  _finish(): void;
+  _frame(): void;
+  _get_built_in_templates(object: string): Array<Dictionary>;
+  _get_comment_delimiters(): PackedStringArray;
+  _get_doc_comment_delimiters(): PackedStringArray;
+  _get_extension(): string;
+  _get_global_class_name(path: string | NodePath): Dictionary;
+  _get_name(): string;
+  _get_public_annotations(): Array<Dictionary>;
+  _get_public_constants(): Dictionary;
+  _get_public_functions(): Array<Dictionary>;
+  _get_recognized_extensions(): PackedStringArray;
+  _get_reserved_words(): PackedStringArray;
+  _get_string_delimiters(): PackedStringArray;
+  _get_type(): string;
+  _handles_global_class_type(type_: string | NodePath): boolean;
+  _has_named_classes(): boolean;
+  _init(): void;
+  _is_control_flow_keyword(keyword: string | NodePath): boolean;
+  _is_using_templates(): boolean;
+  _lookup_code(code: string | NodePath, symbol: string | NodePath, path: string | NodePath, owner: GodotObject): Dictionary;
+  _make_function(class_name: string | NodePath, function_name: string | NodePath, function_args: PackedStringArray | Array<unknown>): string;
+  _make_template(template: string | NodePath, class_name: string | NodePath, base_class_name: string | NodePath): Script;
+  _open_in_external_editor(script: Script, line: int, column: int): int;
+  _overrides_external_editor(): boolean;
+  _preferred_file_name_casing(): int;
+  _profiling_get_accumulated_data(info_array: unknown, info_max: int): int;
+  _profiling_get_frame_data(info_array: unknown, info_max: int): int;
+  _profiling_set_save_native_calls(enable: boolean): void;
+  _profiling_start(): void;
+  _profiling_stop(): void;
+  _reload_all_scripts(): void;
+  _reload_scripts(scripts: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array, soft_reload: boolean): void;
+  _reload_tool_script(script: Script, soft_reload: boolean): void;
+  _remove_named_global_constant(name: string): void;
+  _supports_builtin_mode(): boolean;
+  _supports_documentation(): boolean;
+  _thread_enter(): void;
+  _thread_exit(): void;
+  _validate(script: string | NodePath, path: string | NodePath, validate_functions: boolean, validate_errors: boolean, validate_warnings: boolean, validate_safe_lines: boolean): Dictionary;
+  _validate_path(path: string | NodePath): string;
+
+  // enum LookupResultType
+  static readonly LOOKUP_RESULT_SCRIPT_LOCATION: int;
+  static readonly LOOKUP_RESULT_CLASS: int;
+  static readonly LOOKUP_RESULT_CLASS_CONSTANT: int;
+  static readonly LOOKUP_RESULT_CLASS_PROPERTY: int;
+  static readonly LOOKUP_RESULT_CLASS_METHOD: int;
+  static readonly LOOKUP_RESULT_CLASS_SIGNAL: int;
+  static readonly LOOKUP_RESULT_CLASS_ENUM: int;
+  static readonly LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE: int;
+  static readonly LOOKUP_RESULT_CLASS_ANNOTATION: int;
+  static readonly LOOKUP_RESULT_LOCAL_CONSTANT: int;
+  static readonly LOOKUP_RESULT_LOCAL_VARIABLE: int;
+  static readonly LOOKUP_RESULT_MAX: int;
+  // enum CodeCompletionLocation
+  /**
+   * The option is local to the location of the code completion query - e.g. a local variable. Subsequent value of location represent options from the outer class, the exact value represent how far they are (in terms of inner classes).
+   */
+  static readonly LOCATION_LOCAL: int;
+  /**
+   * The option is from the containing class or a parent class, relative to the location of the code completion query. Perform a bitwise OR with the class depth (e.g. `0` for the local class, `1` for the parent, `2` for the grandparent, etc.) to store the depth of an option in the class or a parent class.
+   */
+  static readonly LOCATION_PARENT_MASK: int;
+  /**
+   * The option is from user code which is not local and not in a derived class (e.g. Autoload Singletons).
+   */
+  static readonly LOCATION_OTHER_USER_CODE: int;
+  /**
+   * The option is from other engine code, not covered by the other enum constants - e.g. built-in classes.
+   */
+  static readonly LOCATION_OTHER: int;
+  // enum CodeCompletionKind
+  static readonly CODE_COMPLETION_KIND_CLASS: int;
+  static readonly CODE_COMPLETION_KIND_FUNCTION: int;
+  static readonly CODE_COMPLETION_KIND_SIGNAL: int;
+  static readonly CODE_COMPLETION_KIND_VARIABLE: int;
+  static readonly CODE_COMPLETION_KIND_MEMBER: int;
+  static readonly CODE_COMPLETION_KIND_ENUM: int;
+  static readonly CODE_COMPLETION_KIND_CONSTANT: int;
+  static readonly CODE_COMPLETION_KIND_NODE_PATH: int;
+  static readonly CODE_COMPLETION_KIND_FILE_PATH: int;
+  static readonly CODE_COMPLETION_KIND_PLAIN_TEXT: int;
+  static readonly CODE_COMPLETION_KIND_MAX: int;
+}

package/typings/classes/ScrollBar.d.ts

@@ -0,0 +1,19 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for scrollbars. */
+declare class ScrollBar extends Range {
+  /**
+   * Overrides the step used when clicking increment and decrement buttons or when using arrow keys when the {@link ScrollBar} is focused.
+   */
+  custom_step: float;
+  focus_mode: int;
+  step: float;
+  set_custom_step(value: float): void;
+  get_custom_step(): float;
+  set_step(value: float): void;
+  get_step(): float;
+
+  /** Emitted when the scrollbar is being scrolled. */
+  scrolling: Signal<[]>;
+}

package/typings/classes/ScrollContainer.d.ts

@@ -0,0 +1,120 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container used to provide scrollbars to a child control when needed. */
+declare class ScrollContainer extends Container {
+  /**
+   * <member name="draw_focus_border" type="bool" setter="set_draw_focus_border" getter="get_draw_focus_border" default="false">
+   * If `true`,  is drawn when the ScrollContainer or one of its descendant nodes is focused.
+   */
+  clip_contents: boolean;
+  /**
+   * If `true`, the ScrollContainer will automatically scroll to focused children (including indirect children) to make sure they are fully visible.
+   */
+  follow_focus: boolean;
+  /** Controls whether horizontal scrollbar can be used and when it should be visible. */
+  horizontal_scroll_mode: int;
+  /** Deadzone for touch scrolling. Lower deadzone makes the scrolling more sensitive. */
+  scroll_deadzone: int;
+  /**
+   * The way which scroll hints (indicators that show that the content can still be scrolled in a certain direction) will be shown.
+   * **Note:** Hints won't be shown if the content can be scrolled both vertically and horizontally.
+   */
+  scroll_hint_mode: int;
+  /**
+   * The current horizontal scroll value.
+   * **Note:** If you are setting this value in the {@link Node._ready} function or earlier, it needs to be wrapped with {@link Object.set_deferred}, since scroll bar's {@link Range.max_value} is not initialized yet.
+   */
+  scroll_horizontal: int;
+  /**
+   * Overrides the {@link ScrollBar.custom_step} used when clicking the internal scroll bar's horizontal increment and decrement buttons or when using arrow keys when the {@link ScrollBar} is focused.
+   */
+  scroll_horizontal_custom_step: float;
+  /**
+   * The current vertical scroll value.
+   * **Note:** Setting it early needs to be deferred, just like in {@link scroll_horizontal}.
+   */
+  scroll_vertical: int;
+  /**
+   * Overrides the {@link ScrollBar.custom_step} used when clicking the internal scroll bar's vertical increment and decrement buttons or when using arrow keys when the {@link ScrollBar} is focused.
+   */
+  scroll_vertical_custom_step: float;
+  /**
+   * If `true`, the scroll hint texture will be tiled instead of stretched. See {@link scroll_hint_mode}.
+   */
+  tile_scroll_hint: boolean;
+  /** Controls whether vertical scrollbar can be used and when it should be visible. */
+  vertical_scroll_mode: int;
+  set_follow_focus(value: boolean): void;
+  is_following_focus(): boolean;
+  set_horizontal_scroll_mode(value: int): void;
+  get_horizontal_scroll_mode(): int;
+  set_deadzone(value: int): void;
+  get_deadzone(): int;
+  set_scroll_hint_mode(value: int): void;
+  get_scroll_hint_mode(): int;
+  set_h_scroll(value: int): void;
+  get_h_scroll(): int;
+  set_horizontal_custom_step(value: float): void;
+  get_horizontal_custom_step(): float;
+  set_v_scroll(value: int): void;
+  get_v_scroll(): int;
+  set_vertical_custom_step(value: float): void;
+  get_vertical_custom_step(): float;
+  set_tile_scroll_hint(value: boolean): void;
+  is_scroll_hint_tiled(): boolean;
+  set_vertical_scroll_mode(value: int): void;
+  get_vertical_scroll_mode(): int;
+
+  /**
+   * Ensures the given `control` is visible (must be a direct or indirect child of the ScrollContainer). Used by {@link follow_focus}.
+   * **Note:** This will not work on a node that was just added during the same frame. If you want to scroll to a newly added child, you must wait until the next frame using {@link SceneTree.process_frame}:
+   */
+  ensure_control_visible(control: Control): void;
+  /**
+   * Returns the horizontal scrollbar {@link HScrollBar} of this {@link ScrollContainer}.
+   * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to disable or hide a scrollbar, you can use {@link horizontal_scroll_mode}.
+   */
+  get_h_scroll_bar(): HScrollBar;
+  /**
+   * Returns the vertical scrollbar {@link VScrollBar} of this {@link ScrollContainer}.
+   * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to disable or hide a scrollbar, you can use {@link vertical_scroll_mode}.
+   */
+  get_v_scroll_bar(): VScrollBar;
+
+  /**
+   * Emitted when scrolling stops when dragging the scrollable area *with a touch event*. This signal is *not* emitted when scrolling by dragging the scrollbar, scrolling with the mouse wheel or scrolling with keyboard/gamepad events.
+   * **Note:** This signal is only emitted on Android or iOS, or on desktop/web platforms when {@link ProjectSettings.input_devices/pointing/emulate_touch_from_mouse} is enabled.
+   */
+  scroll_ended: Signal<[]>;
+  /**
+   * Emitted when scrolling starts when dragging the scrollable area w*ith a touch event*. This signal is *not* emitted when scrolling by dragging the scrollbar, scrolling with the mouse wheel or scrolling with keyboard/gamepad events.
+   * **Note:** This signal is only emitted on Android or iOS, or on desktop/web platforms when {@link ProjectSettings.input_devices/pointing/emulate_touch_from_mouse} is enabled.
+   */
+  scroll_started: Signal<[]>;
+
+  // enum ScrollMode
+  /** Scrolling disabled, scrollbar will be invisible. */
+  static readonly SCROLL_MODE_DISABLED: int;
+  /**
+   * Scrolling enabled, scrollbar will be visible only if necessary, i.e. container's content is bigger than the container.
+   */
+  static readonly SCROLL_MODE_AUTO: int;
+  /** Scrolling enabled, scrollbar will be always visible. */
+  static readonly SCROLL_MODE_SHOW_ALWAYS: int;
+  /** Scrolling enabled, scrollbar will be hidden. */
+  static readonly SCROLL_MODE_SHOW_NEVER: int;
+  /**
+   * Combines {@link SCROLL_MODE_AUTO} and {@link SCROLL_MODE_SHOW_ALWAYS}. The scrollbar is only visible if necessary, but the content size is adjusted as if it was always visible. It's useful for ensuring that content size stays the same regardless if the scrollbar is visible.
+   */
+  static readonly SCROLL_MODE_RESERVE: int;
+  // enum ScrollHintMode
+  /** Scroll hints will never be shown. */
+  static readonly SCROLL_HINT_MODE_DISABLED: int;
+  /** Scroll hints will be shown at the top and bottom (if vertical), or left and right (if horizontal). */
+  static readonly SCROLL_HINT_MODE_ALL: int;
+  /** Scroll hints will be shown at the top (if vertical), or the left (if horizontal). */
+  static readonly SCROLL_HINT_MODE_TOP_AND_LEFT: int;
+  /** Scroll hints will be shown at the bottom (if horizontal), or the right (if horizontal). */
+  static readonly SCROLL_HINT_MODE_BOTTOM_AND_RIGHT: int;
+}

package/typings/classes/SegmentShape2D.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D line segment shape used for physics collision. */
+declare class SegmentShape2D extends Shape2D {
+  /** The segment's first point position. */
+  a: Vector2;
+  /** The segment's second point position. */
+  b: Vector2;
+  set_a(value: Vector2 | Vector2i): void;
+  get_a(): Vector2;
+  set_b(value: Vector2 | Vector2i): void;
+  get_b(): Vector2;
+}

package/typings/classes/Semaphore.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A synchronization mechanism used to control access to a shared resource by {@link Thread}s. */
+declare class Semaphore extends RefCounted {
+  /** Lowers the {@link Semaphore}, allowing one thread in, or more if `count` is specified. */
+  post(count?: int): void;
+  /**
+   * Like {@link wait}, but won't block, so if the value is zero, fails immediately and returns `false`. If non-zero, it returns `true` to report success.
+   */
+  try_wait(): boolean;
+  /** Waits for the {@link Semaphore}, if its value is zero, blocks until non-zero. */
+  wait(): void;
+}

package/typings/classes/SeparationRayShape2D.d.ts

@@ -0,0 +1,17 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D ray shape used for physics collision that tries to separate itself from any collider. */
+declare class SeparationRayShape2D extends Shape2D {
+  /** The ray's length. */
+  length: float;
+  /**
+   * If `false` (default), the shape always separates and returns a normal along its own direction.
+   * If `true`, the shape can return the correct normal and separate in any direction, allowing sliding motion on slopes.
+   */
+  slide_on_slope: boolean;
+  set_length(value: float): void;
+  get_length(): float;
+  set_slide_on_slope(value: boolean): void;
+  get_slide_on_slope(): boolean;
+}

package/typings/classes/SeparationRayShape3D.d.ts

@@ -0,0 +1,17 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D ray shape used for physics collision that tries to separate itself from any collider. */
+declare class SeparationRayShape3D extends Shape3D {
+  /** The ray's length. */
+  length: float;
+  /**
+   * If `false` (default), the shape always separates and returns a normal along its own direction.
+   * If `true`, the shape can return the correct normal and separate in any direction, allowing sliding motion on slopes.
+   */
+  slide_on_slope: boolean;
+  set_length(value: float): void;
+  get_length(): float;
+  set_slide_on_slope(value: boolean): void;
+  get_slide_on_slope(): boolean;
+}

package/typings/classes/Separator.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for separators. */
+declare class Separator extends Control {
+}

package/typings/classes/Shader.d.ts

@@ -0,0 +1,48 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A shader implemented in the Godot shading language. */
+declare class Shader extends Resource {
+  /** Returns the shader's code as the user has written it, not the full generated code used internally. */
+  code: string;
+  set_code(value: string | NodePath): void;
+  get_code(): string;
+
+  /**
+   * Returns the texture that is set as default for the specified parameter.
+   * **Note:** `name` must match the name of the uniform in the code exactly.
+   * **Note:** If the sampler array is used use `index` to access the specified texture.
+   */
+  get_default_texture_parameter(name: string, index?: int): Texture | null;
+  /** Returns the shader mode for the shader. */
+  get_mode(): int;
+  /**
+   * Returns the list of shader uniforms that can be assigned to a {@link ShaderMaterial}, for use with {@link ShaderMaterial.set_shader_parameter} and {@link ShaderMaterial.get_shader_parameter}. The parameters returned are contained in dictionaries in a similar format to the ones returned by {@link Object.get_property_list}.
+   * If argument `get_groups` is `true`, parameter grouping hints are also included in the list.
+   */
+  get_shader_uniform_list(get_groups?: boolean): Array<unknown>;
+  /**
+   * Only available when running in the editor. Opens a popup that visualizes the generated shader code, including all variants and internal shader code. See also {@link Material.inspect_native_shader_code}.
+   */
+  inspect_native_shader_code(): void;
+  /**
+   * Sets the default texture to be used with a texture uniform. The default is used if a texture is not set in the {@link ShaderMaterial}.
+   * **Note:** `name` must match the name of the uniform in the code exactly.
+   * **Note:** If the sampler array is used use `index` to access the specified texture.
+   */
+  set_default_texture_parameter(name: string, texture: Texture, index?: int): void;
+
+  // enum Mode
+  /** Mode used to draw all 3D objects. */
+  static readonly MODE_SPATIAL: int;
+  /** Mode used to draw all 2D objects. */
+  static readonly MODE_CANVAS_ITEM: int;
+  /** Mode used to calculate particle information on a per-particle basis. Not used for drawing. */
+  static readonly MODE_PARTICLES: int;
+  /** Mode used for drawing skies. Only works with shaders attached to {@link Sky} objects. */
+  static readonly MODE_SKY: int;
+  /** Mode used for setting the color and density of volumetric fog effect. */
+  static readonly MODE_FOG: int;
+  /** Mode used for drawing to DrawableTexture resources via blit calls. */
+  static readonly MODE_TEXTURE_BLIT: int;
+}

package/typings/classes/ShaderGlobalsOverride.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node used to override global shader parameters' values in a scene. */
+declare class ShaderGlobalsOverride extends Node {
+}

package/typings/classes/ShaderInclude.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A snippet of shader code to be included in a {@link Shader} with `#include`. */
+declare class ShaderInclude extends Resource {
+  /**
+   * Returns the code of the shader include file. The returned text is what the user has written, not the full generated code used internally.
+   */
+  code: string;
+  set_code(value: string | NodePath): void;
+  get_code(): string;
+}

package/typings/classes/ShaderIncludeDB.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Internal database of built in shader include files. */
+declare class ShaderIncludeDB extends GodotObject {
+  /**
+   * Returns the code for the built-in shader fragment. You can also access this in your shader code through `#include "filename"`.
+   */
+  static get_built_in_include_file(filename: string | NodePath): string;
+  /** Returns `true` if an include file with this name exists. */
+  static has_built_in_include_file(filename: string | NodePath): boolean;
+  /** Returns a list of built-in include files that are currently registered. */
+  static list_built_in_include_files(): PackedStringArray;
+}

package/typings/classes/ShaderMaterial.d.ts

@@ -0,0 +1,19 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A material defined by a custom {@link Shader} program and the values of its shader parameters. */
+declare class ShaderMaterial extends Material {
+  /** The {@link Shader} program used to render this material. */
+  shader: Shader | null;
+  set_shader(value: Shader | null): void;
+  get_shader(): Shader | null;
+
+  /** Returns the current value set for this material of a uniform in the shader. */
+  get_shader_parameter(param: string): unknown;
+  /**
+   * Changes the value set for this material of a uniform in the shader.
+   * **Note:** `param` is case-sensitive and must match the name of the uniform in the code exactly (not the capitalized name in the inspector).
+   * **Note:** Changes to the shader uniform will be effective on all instances using this {@link ShaderMaterial}. To prevent this, use per-instance uniforms with {@link CanvasItem.set_instance_shader_parameter}, {@link GeometryInstance3D.set_instance_shader_parameter} or duplicate the {@link ShaderMaterial} resource using {@link Resource.duplicate}. Per-instance uniforms allow for better shader reuse and are therefore faster, so they should be preferred over duplicating the {@link ShaderMaterial} when possible.
+   */
+  set_shader_parameter(param: string, value: unknown): void;
+}

package/typings/classes/Shape2D.d.ts

@@ -0,0 +1,44 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for 2D shapes used for physics collision. */
+declare class Shape2D extends Resource {
+  /**
+   * The shape's custom solver bias. Defines how much bodies react to enforce contact separation when this shape is involved.
+   * When set to `0`, the default value from {@link ProjectSettings.physics/2d/solver/default_contact_bias} is used.
+   */
+  custom_solver_bias: float;
+  set_custom_solver_bias(value: float): void;
+  get_custom_solver_bias(): float;
+
+  /**
+   * Returns `true` if this shape is colliding with another.
+   * This method needs the transformation matrix for this shape (`local_xform`), the shape to check collisions with (`with_shape`), and the transformation matrix of that shape (`shape_xform`).
+   */
+  collide(local_xform: Transform2D, with_shape: Shape2D, shape_xform: Transform2D): boolean;
+  /**
+   * Returns a list of contact point pairs where this shape touches another.
+   * If there are no collisions, the returned list is empty. Otherwise, the returned list contains contact points arranged in pairs, with entries alternating between points on the boundary of this shape and points on the boundary of `with_shape`.
+   * A collision pair A, B can be used to calculate the collision normal with `(B - A).normalized()`, and the collision depth with `(B - A).length()`. This information is typically used to separate shapes, particularly in collision solvers.
+   * This method needs the transformation matrix for this shape (`local_xform`), the shape to check collisions with (`with_shape`), and the transformation matrix of that shape (`shape_xform`).
+   */
+  collide_and_get_contacts(local_xform: Transform2D, with_shape: Shape2D, shape_xform: Transform2D): PackedVector2Array;
+  /**
+   * Returns whether this shape would collide with another, if a given movement was applied.
+   * This method needs the transformation matrix for this shape (`local_xform`), the movement to test on this shape (`local_motion`), the shape to check collisions with (`with_shape`), the transformation matrix of that shape (`shape_xform`), and the movement to test onto the other object (`shape_motion`).
+   */
+  collide_with_motion(local_xform: Transform2D, local_motion: Vector2 | Vector2i, with_shape: Shape2D, shape_xform: Transform2D, shape_motion: Vector2 | Vector2i): boolean;
+  /**
+   * Returns a list of contact point pairs where this shape would touch another, if a given movement was applied.
+   * If there would be no collisions, the returned list is empty. Otherwise, the returned list contains contact points arranged in pairs, with entries alternating between points on the boundary of this shape and points on the boundary of `with_shape`.
+   * A collision pair A, B can be used to calculate the collision normal with `(B - A).normalized()`, and the collision depth with `(B - A).length()`. This information is typically used to separate shapes, particularly in collision solvers.
+   * This method needs the transformation matrix for this shape (`local_xform`), the movement to test on this shape (`local_motion`), the shape to check collisions with (`with_shape`), the transformation matrix of that shape (`shape_xform`), and the movement to test onto the other object (`shape_motion`).
+   */
+  collide_with_motion_and_get_contacts(local_xform: Transform2D, local_motion: Vector2 | Vector2i, with_shape: Shape2D, shape_xform: Transform2D, shape_motion: Vector2 | Vector2i): PackedVector2Array;
+  /**
+   * Draws a solid shape onto a {@link CanvasItem} with the {@link RenderingServer} API filled with the specified `color`. The exact drawing method is specific for each shape and cannot be configured.
+   */
+  draw(canvas_item: RID, color: Color): void;
+  /** Returns a {@link Rect2} representing the shapes boundary. */
+  get_rect(): Rect2;
+}

package/typings/classes/Shape3D.d.ts

@@ -0,0 +1,24 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for 3D shapes used for physics collision. */
+declare class Shape3D extends Resource {
+  /**
+   * The shape's custom solver bias. Defines how much bodies react to enforce contact separation when this shape is involved.
+   * When set to `0`, the default value from {@link ProjectSettings.physics/3d/solver/default_contact_bias} is used.
+   * **Note:** {@link custom_solver_bias} is only effective when using GodotPhysics3D. It has no effect when using Jolt Physics.
+   */
+  custom_solver_bias: float;
+  /**
+   * The collision margin for the shape. This is not used in Godot Physics.
+   * Collision margins allow collision detection to be more efficient by adding an extra shell around shapes. Collision algorithms are more expensive when objects overlap by more than their margin, so a higher value for margins is better for performance, at the cost of accuracy around edges as it makes them less sharp.
+   */
+  margin: float;
+  set_custom_solver_bias(value: float): void;
+  get_custom_solver_bias(): float;
+  set_margin(value: float): void;
+  get_margin(): float;
+
+  /** Returns the {@link ArrayMesh} used to draw the debug collision for this {@link Shape3D}. */
+  get_debug_mesh(): ArrayMesh;
+}