typescript-to-gdscript 0.1.0

package/typings/classes/Resource.d.ts

@@ -0,0 +1,130 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for serializable objects. */
+declare class Resource extends RefCounted {
+  /**
+   * If `true`, the resource is duplicated for each instance of all scenes using it. At run-time, the resource can be modified in one scene without affecting other instances (see {@link PackedScene.instantiate}).
+   * **Note:** Changing this property at run-time has no effect on already created duplicate resources.
+   */
+  resource_local_to_scene: boolean;
+  /**
+   * An optional name for this resource. When defined, its value is displayed to represent the resource in the Inspector dock. For built-in scripts, the name is displayed as part of the tab name in the script editor.
+   * **Note:** Some resource formats do not support resource names. You can still set the name in the editor or via code, but it will be lost when the resource is reloaded. For example, only built-in scripts can have a resource name, while scripts stored in separate files cannot.
+   */
+  resource_name: string;
+  /**
+   * The unique path to this resource. If it has been saved to disk, the value will be its filepath. If the resource is exclusively contained within a scene, the value will be the {@link PackedScene}'s filepath, followed by a unique identifier.
+   * **Note:** Setting this property manually may fail if a resource with the same path has already been previously loaded. If necessary, use {@link take_over_path}.
+   */
+  resource_path: string;
+  /**
+   * A unique identifier relative to this resource's scene. If left empty, the ID is automatically generated when this resource is saved inside a {@link PackedScene}. If the resource is not inside a scene, this property is empty by default.
+   * **Note:** When the {@link PackedScene} is saved, if multiple resources in the same scene use the same ID, only the earliest resource in the scene hierarchy keeps the original ID. The other resources are assigned new IDs from {@link generate_scene_unique_id}.
+   * **Note:** Setting this property does not emit the {@link changed} signal.
+   * **Warning:** When setting, the ID must only consist of letters, numbers, and underscores. Otherwise, it will fail and default to a randomly generated ID.
+   */
+  resource_scene_unique_id: string;
+  set_local_to_scene(value: boolean): void;
+  is_local_to_scene(): boolean;
+  set_name(value: string | NodePath): void;
+  get_name(): string;
+  set_path(value: string | NodePath): void;
+  get_path(): string;
+  set_scene_unique_id(value: string | NodePath): void;
+  get_scene_unique_id(): string;
+
+  /** Override this method to return a custom {@link RID} when {@link get_rid} is called. */
+  _get_rid(): RID;
+  /**
+   * For resources that store state in non-exported properties, such as via {@link Object._validate_property} or {@link Object._get_property_list}, this method must be implemented to clear them.
+   */
+  _reset_state(): void;
+  /**
+   * Override this method to execute additional logic after {@link set_path_cache} is called on this object.
+   */
+  _set_path_cache(path: string | NodePath): void;
+  /**
+   * Override this method to customize the newly duplicated resource created from {@link PackedScene.instantiate}, if the original's {@link resource_local_to_scene} is set to `true`.
+   * **Example:** Set a random `damage` value to every local resource from an instantiated scene:
+   */
+  _setup_local_to_scene(): void;
+  /**
+   * Duplicates this resource, returning a new resource with its `export`ed or {@link PROPERTY_USAGE_STORAGE} properties copied from the original.
+   * If `deep` is `false`, a **shallow** copy is returned: nested {@link Array}, {@link Dictionary}, and {@link Resource} properties are not duplicated and are shared with the original resource.
+   * If `deep` is `true`, a **deep** copy is returned: all nested arrays, dictionaries, and packed arrays are also duplicated (recursively). Any {@link Resource} found inside will only be duplicated if it's local, like {@link DEEP_DUPLICATE_INTERNAL} used with {@link duplicate_deep}.
+   * The following exceptions apply:
+   * - Subresource properties with the {@link PROPERTY_USAGE_ALWAYS_DUPLICATE} flag are always duplicated (recursively or not, depending on `deep`).
+   * - Subresource properties with the {@link PROPERTY_USAGE_NEVER_DUPLICATE} flag are never duplicated.
+   * **Note:** For custom resources, this method will fail if {@link Object._init} has been defined with required parameters.
+   * **Note:** When duplicating with `deep` set to `true`, each resource found, including the one on which this method is called, will be only duplicated once and referenced as many times as needed in the duplicate. For instance, if you are duplicating resource A that happens to have resource B referenced twice, you'll get a new resource A' referencing a new resource B' twice.
+   */
+  duplicate(deep?: boolean): this;
+  /**
+   * Duplicates this resource, deeply, like {@link duplicate} when passing `true`, with extra control over how subresources are handled.
+   */
+  duplicate_deep(deep_subresources_mode: int): Resource | null;
+  /**
+   * Emits the {@link changed} signal. This method is called automatically for some built-in resources.
+   * **Note:** For custom resources, it's recommended to call this method whenever a meaningful change occurs, such as a modified property. This ensures that custom {@link Object}s depending on the resource are properly updated.
+   */
+  emit_changed(): void;
+  /**
+   * Generates a unique identifier for a resource to be contained inside a {@link PackedScene}, based on the current date, time, and a random value. The returned string is only composed of letters (`a` to `y`) and numbers (`0` to `8`). See also {@link resource_scene_unique_id}.
+   */
+  static generate_scene_unique_id(): string;
+  /**
+   * From the internal cache for scene-unique IDs, returns the ID of this resource for the scene at `path`. If there is no entry, an empty string is returned. Useful to keep scene-unique IDs the same when implementing a VCS-friendly custom resource format by extending {@link ResourceFormatLoader} and {@link ResourceFormatSaver}.
+   * **Note:** This method is only implemented when running in an editor context. At runtime, it returns an empty string.
+   */
+  get_id_for_path(path: string | NodePath): string;
+  /**
+   * If {@link resource_local_to_scene} is set to `true` and the resource has been loaded from a {@link PackedScene} instantiation, returns the root {@link Node} of the scene where this resource is used. Otherwise, returns `null`.
+   */
+  get_local_scene(): Node | null;
+  /**
+   * Returns the {@link RID} of this resource (or an empty RID). Many resources (such as {@link Texture2D}, {@link Mesh}, and so on) are high-level abstractions of resources stored in a specialized server ({@link DisplayServer}, {@link RenderingServer}, etc.), so this function will return the original {@link RID}.
+   */
+  get_rid(): RID;
+  /** Returns `true` if the resource is saved on disk as a part of another resource's file. */
+  is_built_in(): boolean;
+  /**
+   * Makes the resource clear its non-exported properties. See also {@link _reset_state}. Useful when implementing a custom resource format by extending {@link ResourceFormatLoader} and {@link ResourceFormatSaver}.
+   */
+  reset_state(): void;
+  /**
+   * In the internal cache for scene-unique IDs, sets the ID of this resource to `id` for the scene at `path`. If `id` is empty, the cache entry for `path` is cleared. Useful to keep scene-unique IDs the same when implementing a VCS-friendly custom resource format by extending {@link ResourceFormatLoader} and {@link ResourceFormatSaver}.
+   * **Note:** This method is only implemented when running in an editor context.
+   */
+  set_id_for_path(path: string | NodePath, id: string | NodePath): void;
+  /**
+   * Sets the resource's path to `path` without involving the resource cache. Useful for handling {@link ResourceFormatLoader.CacheMode} values when implementing a custom resource format by extending {@link ResourceFormatLoader} and {@link ResourceFormatSaver}.
+   */
+  set_path_cache(path: string | NodePath): void;
+  /**
+   * Calls {@link _setup_local_to_scene}. If {@link resource_local_to_scene} is set to `true`, this method is automatically called from {@link PackedScene.instantiate} by the newly duplicated resource within the scene instance.
+   */
+  setup_local_to_scene(): void;
+  /**
+   * Sets the {@link resource_path} to `path`, potentially overriding an existing cache entry for this path. Further attempts to load an overridden resource by path will instead return this resource.
+   */
+  take_over_path(path: string | NodePath): void;
+
+  /**
+   * Emitted when the resource changes, usually when one of its properties is modified. See also {@link emit_changed}.
+   * **Note:** This signal is not emitted automatically for properties of custom resources. If necessary, a setter needs to be created to emit the signal.
+   */
+  changed: Signal<[]>;
+
+  // enum DeepDuplicateMode
+  /**
+   * No subresources at all are duplicated. This is useful even in a deep duplication to have all the arrays and dictionaries duplicated but still pointing to the original resources.
+   */
+  static readonly DEEP_DUPLICATE_NONE: int;
+  /** Only subresources without a path or with a scene-local path will be duplicated. */
+  static readonly DEEP_DUPLICATE_INTERNAL: int;
+  /**
+   * Every subresource found will be duplicated, even if it has a non-local path. In other words, even potentially big resources stored separately will be duplicated.
+   */
+  static readonly DEEP_DUPLICATE_ALL: int;
+}

package/typings/classes/ResourceFormatLoader.d.ts

@@ -0,0 +1,73 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Loads a specific resource type from a file. */
+declare class ResourceFormatLoader extends RefCounted {
+  _exists(path: string | NodePath): boolean;
+  _get_classes_used(path: string | NodePath): PackedStringArray;
+  /**
+   * Should return the dependencies for the resource at the given `path`. Each dependency is a string composed of one to three sections separated by `::`, with trailing empty sections omitted:
+   * - The first section should contain the UID if the resource has one. Otherwise, it should contain the file path.
+   * - The second section should contain the class name of the dependency if `add_types` is `true`. Otherwise, it should be empty.
+   * - The third section should contain the fallback path if the resource has a UID. Otherwise, it should be empty.
+   * **Note:** Custom resource types defined by scripts aren't known by the {@link ClassDB}, so `"Resource"` can be used for the class name.
+   */
+  _get_dependencies(path: string | NodePath, add_types: boolean): PackedStringArray;
+  /** Gets the list of extensions for files this loader is able to read. */
+  _get_recognized_extensions(): PackedStringArray;
+  /**
+   * Returns the script class name associated with the {@link Resource} under the given `path`. If the resource has no script or the script isn't a named class, it should return `""`.
+   */
+  _get_resource_script_class(path: string | NodePath): string;
+  /**
+   * Gets the class name of the resource associated with the given path. If the loader cannot handle it, it should return `""`.
+   * **Note:** Custom resource types defined by scripts aren't known by the {@link ClassDB}, so you might just return `"Resource"` for them.
+   */
+  _get_resource_type(path: string | NodePath): string;
+  /**
+   * Should return the unique ID for the resource associated with the given path. If this method is not overridden, a `.uid` file is generated along with the resource file, containing the unique ID.
+   */
+  _get_resource_uid(path: string | NodePath): int;
+  /**
+   * Tells which resource class this loader can load.
+   * **Note:** Custom resource types defined by scripts aren't known by the {@link ClassDB}, so you might just handle `"Resource"` for them.
+   */
+  _handles_type(type_: string): boolean;
+  /**
+   * Loads a resource when the engine finds this loader to be compatible. If the loaded resource is the result of an import, `original_path` will target the source file. Returns a {@link Resource} object on success, or an {@link Error} constant in case of failure.
+   * The `cache_mode` property defines whether and how the cache should be used or updated when loading the resource. See {@link CacheMode} for details.
+   */
+  _load(path: string | NodePath, original_path: string | NodePath, use_sub_threads: boolean, cache_mode: int): unknown;
+  /**
+   * Tells whether or not this loader should load a resource from its resource path for a given type.
+   * If it is not implemented, the default behavior returns whether the path's extension is within the ones provided by {@link _get_recognized_extensions}, and if the type is within the ones provided by {@link _get_resource_type}.
+   */
+  _recognize_path(path: string | NodePath, type_: string): boolean;
+  /**
+   * If implemented, renames dependencies within the given resource and saves it. `renames` is a dictionary `{ String => String }` mapping old dependency paths to new paths.
+   * Returns {@link OK} on success, or an {@link Error} constant in case of failure.
+   */
+  _rename_dependencies(path: string | NodePath, renames: Dictionary): int;
+
+  // enum CacheMode
+  /**
+   * Neither the main resource (the one requested to be loaded) nor any of its subresources are retrieved from cache nor stored into it. Dependencies (external resources) are loaded with {@link CACHE_MODE_REUSE}.
+   */
+  static readonly CACHE_MODE_IGNORE: int;
+  /**
+   * The main resource (the one requested to be loaded), its subresources, and its dependencies (external resources) are retrieved from cache if present, instead of loaded. Those not cached are loaded and then stored into the cache. The same rules are propagated recursively down the tree of dependencies (external resources).
+   */
+  static readonly CACHE_MODE_REUSE: int;
+  /**
+   * Like {@link CACHE_MODE_REUSE}, but the cache is checked for the main resource (the one requested to be loaded) as well as for each of its subresources. Those already in the cache, as long as the loaded and cached types match, have their data refreshed from storage into the already existing instances. Otherwise, they are recreated as completely new objects.
+   */
+  static readonly CACHE_MODE_REPLACE: int;
+  /**
+   * Like {@link CACHE_MODE_IGNORE}, but propagated recursively down the tree of dependencies (external resources).
+   */
+  static readonly CACHE_MODE_IGNORE_DEEP: int;
+  /**
+   * Like {@link CACHE_MODE_REPLACE}, but propagated recursively down the tree of dependencies (external resources).
+   */
+  static readonly CACHE_MODE_REPLACE_DEEP: int;
+}

package/typings/classes/ResourceFormatSaver.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Saves a specific resource type to a file. */
+declare class ResourceFormatSaver extends RefCounted {
+  /**
+   * Returns the list of extensions available for saving the resource object, provided it is recognized (see {@link _recognize}).
+   */
+  _get_recognized_extensions(resource: Resource): PackedStringArray;
+  /** Returns whether the given resource object can be saved by this saver. */
+  _recognize(resource: Resource): boolean;
+  /**
+   * Returns `true` if this saver handles a given save path and `false` otherwise.
+   * If this method is not implemented, the default behavior returns whether the path's extension is within the ones provided by {@link _get_recognized_extensions}.
+   */
+  _recognize_path(resource: Resource, path: string | NodePath): boolean;
+  /**
+   * Saves the given resource object to a file at the target `path`. `flags` is a bitmask composed with {@link ResourceSaver.SaverFlags} constants.
+   * Returns {@link OK} on success, or an {@link Error} constant in case of failure.
+   */
+  _save(resource: Resource, path: string | NodePath, flags: int): int;
+  /**
+   * Sets a new UID for the resource at the given `path`. Returns {@link OK} on success, or an {@link Error} constant in case of failure.
+   */
+  _set_uid(path: string | NodePath, uid: int): int;
+}

package/typings/classes/ResourceImporter.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for resource importers. */
+declare class ResourceImporter extends RefCounted {
+  /**
+   * Called when the engine compilation profile editor wants to check what build options an imported resource needs. For example, {@link ResourceImporterDynamicFont} has a property called {@link ResourceImporterDynamicFont.multichannel_signed_distance_field}, that depends on the engine to be build with the "msdfgen" module. If that resource happened to be a custom one, it would be handled like this:
+   */
+  _get_build_dependencies(path: string | NodePath): PackedStringArray;
+
+  // enum ImportOrder
+  /** The default import order. */
+  static readonly IMPORT_ORDER_DEFAULT: int;
+  /**
+   * The import order for scenes, which ensures scenes are imported *after* all other core resources such as textures. Custom importers should generally have an import order lower than `100` to avoid issues when importing scenes that rely on custom resources.
+   */
+  static readonly IMPORT_ORDER_SCENE: int;
+}

package/typings/classes/ResourceImporterBMFont.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports a bitmap font in the BMFont (`.fnt`) format. */
+declare class ResourceImporterBMFont extends ResourceImporter {
+  /** If `true`, uses lossless compression for the resulting font. */
+  compress: boolean;
+  /**
+   * List of font fallbacks to use if a glyph isn't found in this bitmap font. Fonts at the beginning of the array are attempted first.
+   */
+  fallbacks: Array<unknown>;
+  /** Font scaling mode. */
+  scaling_mode: int;
+}

package/typings/classes/ResourceImporterBitMap.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports a {@link BitMap} resource (2D array of boolean values). */
+declare class ResourceImporterBitMap extends ResourceImporter {
+  /**
+   * The data source to use for generating the bitmap.
+   * **Black & White:** Pixels whose HSV value is greater than the {@link threshold} will be considered as "enabled" (bit is `true`). If the pixel is lower than or equal to the threshold, it will be considered as "disabled" (bit is `false`).
+   * **Alpha:** Pixels whose alpha value is greater than the {@link threshold} will be considered as "enabled" (bit is `true`). If the pixel is lower than or equal to the threshold, it will be considered as "disabled" (bit is `false`).
+   */
+  create_from: int;
+  /**
+   * The threshold to use to determine which bits should be considered enabled or disabled. See also {@link create_from}.
+   */
+  threshold: float;
+}

package/typings/classes/ResourceImporterCSVTranslation.d.ts

@@ -0,0 +1,23 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports comma-separated values as {@link Translation}s. */
+declare class ResourceImporterCSVTranslation extends ResourceImporter {
+  /**
+   * - **Disabled**: Creates a {@link Translation}.
+   * - **Auto**: Creates an {@link OptimizedTranslation} when possible. This makes the resulting file smaller at the cost of a small CPU overhead. Falls back to {@link Translation} for translations with context or plural forms.
+   */
+  compress: int;
+  /**
+   * The delimiter to use in the CSV file. The default value matches the common CSV convention. Tab-separated values are sometimes called TSV files.
+   */
+  delimiter: int;
+  /**
+   * If `true`, message keys in the CSV file are unescaped using {@link String.c_unescape} during the import process.
+   */
+  unescape_keys: boolean;
+  /**
+   * If `true`, message translations in the CSV file are unescaped using {@link String.c_unescape} during the import process.
+   */
+  unescape_translations: boolean;
+}

package/typings/classes/ResourceImporterDynamicFont.d.ts

@@ -0,0 +1,96 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports a TTF, TTC, OTF, OTC, WOFF or WOFF2 font file for font rendering that adapts to any size. */
+declare class ResourceImporterDynamicFont extends ResourceImporter {
+  /**
+   * If `true`, automatically use system fonts as a fallback if a glyph isn't found in this dynamic font. This makes supporting CJK characters or emoji more straightforward, as you don't need to include a CJK/emoji font in your project. See also {@link fallbacks}.
+   * **Note:** The appearance of system fonts varies across platforms. Loading system fonts is only supported on Windows, macOS, Linux, Android and iOS.
+   */
+  allow_system_fallback: boolean;
+  /**
+   * The font antialiasing method to use.
+   * **Disabled:** Most suited for pixel art fonts, although you do not *have* to change the antialiasing from the default **Grayscale** if the font file was well-created and the font is used at an integer multiple of its intended size. If pixel art fonts have a bad appearance at their intended size, try setting {@link subpixel_positioning} to **Disabled** instead.
+   * **Grayscale:** Use grayscale antialiasing. This is the approach used by the operating system on macOS, Android and iOS.
+   * **LCD Subpixel:** Use antialiasing with subpixel patterns to make fonts sharper on LCD displays. This is the approach used by the operating system on Windows and most Linux distributions. The downside is that this can introduce "fringing" on edges, especially on display technologies that don't use standard RGB subpixels (such as OLED displays). The LCD subpixel layout is globally controlled by {@link ProjectSettings.gui/theme/lcd_subpixel_layout}, which also allows falling back to grayscale antialiasing.
+   */
+  antialiasing: int;
+  /** If `true`, uses lossless compression for the resulting font. */
+  compress: boolean;
+  /**
+   * If set to `true`, embedded font bitmap loading is disabled (bitmap-only and color fonts ignore this property).
+   */
+  disable_embedded_bitmaps: boolean;
+  /**
+   * List of font fallbacks to use if a glyph isn't found in this dynamic font. Fonts at the beginning of the array are attempted first, but fallback fonts that don't support the glyph's language and script are attempted last (see {@link language_support} and {@link script_support}). See also {@link allow_system_fallback}.
+   */
+  fallbacks: Array<unknown>;
+  /**
+   * If `true`, forces generation of hinting data for the font using FreeType (https://freetype.org/)'s autohinter. This will make {@link hinting} effective with fonts that don't include hinting data.
+   */
+  force_autohinter: boolean;
+  /**
+   * If `true`, this font will have mipmaps generated. This prevents text from looking grainy when a {@link Control} is scaled down, or when a {@link Label3D} is viewed from a long distance (if {@link Label3D.texture_filter} is set to a mode that displays mipmaps).
+   * Enabling {@link generate_mipmaps} increases font generation time and memory usage. Only enable this setting if you actually need it.
+   */
+  generate_mipmaps: boolean;
+  /**
+   * The hinting mode to use. This controls how aggressively glyph edges should be snapped to pixels when rasterizing the font. Depending on personal preference, you may prefer using one hinting mode over the other. Hinting modes other than **None** are only effective if the font contains hinting data (see {@link force_autohinter}).
+   * **None:** Smoothest appearance, which can make the font look blurry at small sizes.
+   * **Light:** Sharp result by snapping glyph edges to pixels on the Y axis only.
+   * **Normal:** Sharpest by snapping glyph edges to pixels on both X and Y axes.
+   * **Light (Except Pixel Fonts):** **Disabled** for pixel style fonts (each glyph's contours contain only straight horizontal and vertical lines), **Light** for other fonts.
+   * **Normal (Except Pixel Fonts):** **Disabled** for pixel style fonts (each glyph's contours contain only straight horizontal and vertical lines), **Normal** for other fonts.
+   */
+  hinting: int;
+  /**
+   * If set to `true`, when aligning glyphs to the pixel boundaries rounding remainders are accumulated to ensure more uniform glyph distribution. This setting has no effect if subpixel positioning is enabled.
+   */
+  keep_rounding_remainders: boolean;
+  /**
+   * Override the list of languages supported by this font. If left empty, this is supplied by the font metadata. There is usually no need to change this. See also {@link script_support}.
+   */
+  language_support: Dictionary;
+  /**
+   * If set to `true`, color modulation is applied when drawing colored glyphs, otherwise it's applied to the monochrome glyphs only.
+   */
+  modulate_color_glyphs: boolean;
+  /**
+   * The width of the range around the shape between the minimum and maximum representable signed distance. If using font outlines, {@link msdf_pixel_range} must be set to at least *twice* the size of the largest font outline. The default {@link msdf_pixel_range} value of `8` allows outline sizes up to `4` to look correct.
+   */
+  msdf_pixel_range: int;
+  /**
+   * Source font size used to generate MSDF textures. Higher values allow for more precision, but are slower to render and require more memory. Only increase this value if you notice a visible lack of precision in glyph rendering. Only effective if {@link multichannel_signed_distance_field} is `true`.
+   */
+  msdf_size: int;
+  /**
+   * If set to `true`, the font will use multichannel signed distance field (MSDF) for crisp rendering at any size. Since this approach does not rely on rasterizing the font every time its size changes, this allows for resizing the font in real-time without any performance penalty. Text will also not look grainy for {@link Control}s that are scaled down (or for {@link Label3D}s viewed from a long distance).
+   * MSDF font rendering can be combined with {@link generate_mipmaps} to further improve font rendering quality when scaled down.
+   */
+  multichannel_signed_distance_field: boolean;
+  /**
+   * The OpenType features to enable, disable or set a value for this font. This can be used to enable optional features provided by the font, such as ligatures or alternative glyphs. The list of supported OpenType features varies on a per-font basis.
+   */
+  opentype_features: Dictionary;
+  /**
+   * If set to a positive value, overrides the oversampling factor of the viewport this font is used in. See {@link Viewport.oversampling}. This value doesn't override the [code skip-lint]oversampling[/code] parameter of [code skip-lint]draw_*[/code] methods.
+   */
+  oversampling: float;
+  /**
+   * The glyph ranges to prerender. This can avoid stuttering during gameplay when new characters need to be rendered, especially if {@link subpixel_positioning} is enabled. The downside of using preloading is that initial project load times will increase, as well as memory usage.
+   */
+  preload: Array<unknown>;
+  /**
+   * Override the list of language scripts supported by this font. If left empty, this is supplied by the font metadata. There is usually no need to change this. See also {@link language_support}.
+   */
+  script_support: Dictionary;
+  /**
+   * Subpixel positioning improves font rendering appearance, especially at smaller font sizes. The downside is that it takes more time to initially render the font, which can cause stuttering during gameplay, especially if used with large font sizes. This should be set to **Disabled** for fonts with a pixel art appearance.
+   * **Disabled:** No subpixel positioning. Lowest quality, fastest rendering.
+   * **Auto:** Use subpixel positioning at small font sizes (the chosen quality varies depending on font size). Large fonts will not use subpixel positioning. This is a good tradeoff between performance and quality.
+   * **One Half of a Pixel:** Always perform intermediate subpixel positioning regardless of font size. High quality, slow rendering.
+   * **One Quarter of a Pixel:** Always perform precise subpixel positioning regardless of font size. Highest quality, slowest rendering.
+   * **Auto (Except Pixel Fonts):** **Disabled** for pixel style fonts (each glyph's contours contain only straight horizontal and vertical lines), **Auto** for other fonts.
+   */
+  subpixel_positioning: int;
+}

package/typings/classes/ResourceImporterImage.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports an image for use in scripting, with no rendering capabilities. */
+declare class ResourceImporterImage extends ResourceImporter {
+}

package/typings/classes/ResourceImporterImageFont.d.ts

@@ -0,0 +1,46 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports a bitmap font where all glyphs have the same width and height. */
+declare class ResourceImporterImageFont extends ResourceImporter {
+  /**
+   * Font ascent (number of pixels above the baseline). If set to `0`, half of the character height is used.
+   */
+  ascent: int;
+  /**
+   * Margin applied around every imported glyph. If your font image contains guides (in the form of lines between glyphs) or if spacing between characters appears incorrect, try adjusting {@link character_margin}.
+   */
+  character_margin: Rect2i;
+  /**
+   * The character ranges to import from the font image. This is an array that maps each position on the image (in tile coordinates, not pixels). The font atlas is traversed from left to right and top to bottom. Characters can be specified with decimal numbers (126), hexadecimal numbers (`0x007e` or `U+007e`), or between single quotes (`'~'`). Ranges can be specified with a hyphen between characters.
+   * For example, `0-127` represents the full ASCII range. It can also be written as `0x0000-0x007f` (or `U+0000-U+007f`). As another example, `' '-'~'` is equivalent to `32-126` and represents the range of printable (visible) ASCII characters.
+   * For any range, the character advance and offset can be customized by appending three space-separated integer values (additional advance, x offset, y offset) to the end. For example `'a'-'b' 4 5 2` sets the advance to `char_width + 4` and offset to `Vector2(5, 2)` for both `a` and `b` characters.
+   * **Note:** The overall number of characters must not exceed the number of {@link columns} multiplied by {@link rows}. Otherwise, the font will fail to import.
+   */
+  character_ranges: PackedStringArray;
+  /** Number of columns in the font image. See also {@link rows}. */
+  columns: int;
+  /** If `true`, uses lossless compression for the resulting font. */
+  compress: boolean;
+  /**
+   * Font descent (number of pixels below the baseline). If set to `0`, half of the character height is used.
+   */
+  descent: int;
+  /**
+   * List of font fallbacks to use if a glyph isn't found in this bitmap font. Fonts at the beginning of the array are attempted first.
+   */
+  fallbacks: Array<unknown>;
+  /**
+   * Margin to cut on the sides of the entire image. This can be used to cut parts of the image that contain attribution information or similar.
+   */
+  image_margin: Rect2i;
+  /**
+   * Kerning pairs for the font. Kerning pair adjust the spacing between two characters.
+   * Each string consist of three space separated values: "from" string, "to" string and integer offset. Each combination form the two string for a kerning pair, e.g, `ab cd -3` will create kerning pairs `ac`, `ad`, `bc`, and `bd` with offset `-3`. `\uXXXX` escape sequences can be used to add Unicode characters.
+   */
+  kerning_pairs: PackedStringArray;
+  /** Number of rows in the font image. See also {@link columns}. */
+  rows: int;
+  /** Font scaling mode. */
+  scaling_mode: int;
+}

package/typings/classes/ResourceImporterLayeredTexture.d.ts

@@ -0,0 +1,65 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Imports a 3-dimensional texture ({@link Texture3D}), a {@link Texture2DArray}, a {@link Cubemap} or a {@link CubemapArray}.
+ */
+declare class ResourceImporterLayeredTexture extends ResourceImporter {
+  /**
+   * Controls how color channels should be used in the imported texture.
+   * **sRGB Friendly:**, prevents the R and RG color formats from being used, as they do not support nonlinear sRGB encoding.
+   * **Optimized:**, allows the RG color format to be used if the texture does not use the blue channel. This reduces memory usage if the texture's blue channel can be discarded (all pixels must have a blue value of `0`).
+   * **Normal Map (RG Channels):** This forces all layers from the texture to be imported with the RG color format, with only the red and green channels preserved. RGTC (Red-Green Texture Compression) compression is able to preserve its detail much better, while using the same amount of memory as a standard RGBA VRAM-compressed texture. This only has an effect on textures with the VRAM Compressed or Basis Universal compression modes. This mode is only available in layered textures ({@link Cubemap}, {@link CubemapArray}, {@link Texture2DArray} and {@link Texture3D}).
+   */
+  'compress/channel_pack': int;
+  /**
+   * Controls how VRAM compression should be performed for HDR images.
+   * **Disabled:** Never use VRAM compression for HDR textures, regardless of whether they're opaque or transparent. Instead, the texture is converted to RGBE9995 (9-bits per channel + 5-bit exponent = 32 bits per pixel) to reduce memory usage compared to a half-float or single-precision float image format.
+   * **Opaque Only:** Only uses VRAM compression for opaque HDR textures. This is due to a limitation of HDR formats, as there is no VRAM-compressed HDR format that supports transparency at the same time.
+   * **Always:** Force VRAM compression even for HDR textures with an alpha channel. To perform this, the alpha channel is discarded on import.
+   * **Note:** Only effective on Radiance HDR (`.hdr`) and OpenEXR (`.exr`) images.
+   */
+  'compress/hdr_compression': int;
+  /**
+   * If `true`, uses BPTC compression on desktop platforms and ASTC compression on mobile platforms. When using BPTC, BC7 is used for SDR textures and BC6H is used for HDR textures.
+   * If `false`, uses the faster but lower-quality S3TC compression on desktop platforms and ETC2 on mobile/web platforms. When using S3TC, DXT1 (BC1) is used for opaque textures and DXT5 (BC3) is used for transparent or normal map (RGTC) textures.
+   * BPTC and ASTC support VRAM compression for HDR textures, but S3TC and ETC2 do not (see {@link compress/hdr_compression}).
+   */
+  'compress/high_quality': boolean;
+  /**
+   * The quality to use when using the **Lossy** compression mode. Higher values result in better quality, at the cost of larger file sizes. Lossy quality does not affect memory usage of the imported texture, only its file size on disk.
+   */
+  'compress/lossy_quality': float;
+  /**
+   * The compression mode to use. Each compression mode provides a different tradeoff:
+   * **Lossless**: Original quality, high memory usage, high size on disk, fast import.
+   * **Lossy:** Reduced quality, high memory usage, low size on disk, fast import.
+   * **VRAM Compressed:** Reduced quality, low memory usage, low size on disk, slowest import. Only use for textures in 3D scenes, not for 2D elements.
+   * **VRAM Uncompressed:** Original quality, high memory usage, highest size on disk, fastest import.
+   * **Basis Universal:** Reduced quality, low memory usage, lowest size on disk, slow import. Only use for textures in 3D scenes, not for 2D elements.
+   * See Compress mode ($DOCS_URL/tutorials/assets_pipeline/importing_images.html#compress-mode) in the manual for more details.
+   */
+  'compress/mode': int;
+  /**
+   * If greater than or equal to `0.01`, enables Rate-Distortion Optimization (RDO) to reduce file size. Higher values result in smaller file sizes but lower quality.
+   * **Note:** Enabling RDO makes encoding times significantly longer, especially when the image is large.
+   * See also {@link ProjectSettings.rendering/textures/basis_universal/rdo_dict_size} and {@link ProjectSettings.rendering/textures/basis_universal/zstd_supercompression_level} if you want to reduce the file size further.
+   */
+  'compress/rdo_quality_loss': float;
+  /** The UASTC encoding level. Higher values result in better quality but make encoding times longer. */
+  'compress/uastc_level': int;
+  /**
+   * If `true`, smaller versions of the texture are generated on import. For example, a 64×64 texture will generate 6 mipmaps (32×32, 16×16, 8×8, 4×4, 2×2, 1×1). This has several benefits:
+   * - Textures will not become grainy in the distance (in 3D), or if scaled down due to {@link Camera2D} zoom or {@link CanvasItem} scale (in 2D).
+   * - Performance will improve if the texture is displayed in the distance, since sampling smaller versions of the original texture is faster and requires less memory bandwidth.
+   * The downside of mipmaps is that they increase memory usage by roughly 33% (for {@link Texture2DArray}, {@link Cubemap} and {@link CubemapArray}) or 14% (for {@link Texture3D}).
+   * It's recommended to enable mipmaps in 3D. However, in 2D, this should only be enabled if your project visibly benefits from having mipmaps enabled. If the camera never zooms out significantly, there won't be a benefit to enabling mipmaps but memory usage will increase.
+   */
+  'mipmaps/generate': boolean;
+  /** Unimplemented. This currently has no effect when changed. */
+  'mipmaps/limit': int;
+  /**
+   * Controls how the cubemap's texture is internally laid out. When using high-resolution cubemaps, **2×3** and **3×2** are less prone to exceeding hardware texture size limits compared to **1×6** and **6×1**.
+   */
+  'slices/arrangement': int;
+}

package/typings/classes/ResourceImporterOBJ.d.ts

@@ -0,0 +1,38 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports an OBJ 3D model as an independent {@link Mesh} or scene. */
+declare class ResourceImporterOBJ extends ResourceImporter {
+  /**
+   * If `true`, mesh compression will not be used. Consider enabling if you notice blocky artifacts in your mesh normals or UVs, or if you have meshes that are larger than a few thousand meters in each direction.
+   */
+  force_disable_mesh_compression: boolean;
+  /** If `true`, generates UV2 on import for {@link LightmapGI} baking. */
+  generate_lightmap_uv2: boolean;
+  /**
+   * Controls the size of each texel on the baked lightmap. A smaller value results in more precise lightmaps, at the cost of larger lightmap sizes and longer bake times.
+   * **Note:** Only effective if {@link generate_lightmap_uv2} is `true`.
+   */
+  generate_lightmap_uv2_texel_size: float;
+  /**
+   * If `true`, generates lower detail variants of the mesh which will be displayed in the distance to improve rendering performance. Not all meshes benefit from LOD, especially if they are never rendered from far away. Disabling this can reduce output file size and speed up importing. See Mesh level of detail (LOD) ($DOCS_URL/tutorials/3d/mesh_lod.html#doc-mesh-lod) for more information.
+   */
+  generate_lods: boolean;
+  /**
+   * If `true`, enables the generation of shadow meshes on import. This optimizes shadow rendering without reducing quality by welding vertices together when possible. This in turn reduces the memory bandwidth required to render shadows. Shadow mesh generation currently doesn't support using a lower detail level than the source mesh (but shadow rendering will make use of LODs when relevant).
+   */
+  generate_shadow_mesh: boolean;
+  /**
+   * If `true`, generate vertex tangents using Mikktspace (http://www.mikktspace.com/) if the source mesh doesn't have tangent data. When possible, it's recommended to let the 3D modeling software generate tangents on export instead on relying on this option. Tangents are required for correct display of normal and height maps, along with any material/shader features that require tangents.
+   * If you don't need material features that require tangents, disabling this can reduce output file size and speed up importing if the source 3D file doesn't contain tangents.
+   */
+  generate_tangents: boolean;
+  /**
+   * Offsets the mesh's data by the specified value. This can be used to work around misaligned meshes without having to modify the source file.
+   */
+  offset_mesh: Vector3;
+  /**
+   * Scales the mesh's data by the specified value. This can be used to work around misscaled meshes without having to modify the source file.
+   */
+  scale_mesh: Vector3;
+}

package/typings/classes/ResourceImporterSVG.d.ts

@@ -0,0 +1,24 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Imports an SVG file as an automatically scalable texture for use in UI elements and 2D rendering. */
+declare class ResourceImporterSVG extends ResourceImporter {
+  /** Texture scale. `1.0` is the original SVG size. Higher values result in a larger image. */
+  base_scale: float;
+  /** If set, remaps texture colors according to {@link Color}-{@link Color} map. */
+  color_map: Dictionary;
+  /** If `true`, uses lossless compression for the SVG source. */
+  compress: boolean;
+  /**
+   * If `true`, puts pixels of the same surrounding color in transition from transparent to opaque areas. For textures displayed with bilinear filtering, this helps to reduce the outline effect when exporting images from an image editor.
+   */
+  fix_alpha_border: boolean;
+  /**
+   * An alternative to fixing darkened borders with {@link fix_alpha_border} is to use premultiplied alpha. By enabling this option, the texture will be converted to this format. A premultiplied alpha texture requires specific materials to be displayed correctly:
+   * - In 2D, a {@link CanvasItemMaterial} will need to be created and configured to use the {@link CanvasItemMaterial.BLEND_MODE_PREMULT_ALPHA} blend mode on {@link CanvasItem}s that use this texture. In custom `canvas_item` shaders, `render_mode blend_premul_alpha;` should be used.
+   * - In 3D, a {@link BaseMaterial3D} will need to be created and configured to use the {@link BaseMaterial3D.BLEND_MODE_PREMULT_ALPHA} blend mode on materials that use this texture. In custom `spatial` shaders, `render_mode blend_premul_alpha;` should be used.
+   */
+  premult_alpha: boolean;
+  /** Overrides texture saturation. */
+  saturation: float;
+}