typescript-to-gdscript 0.1.0

package/typings/classes/Font.d.ts

@@ -0,0 +1,144 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for fonts and font variations. */
+declare class Font extends Resource {
+  /**
+   * Array of fallback {@link Font}s to use as a substitute if a glyph is not found in this current {@link Font}.
+   * If this array is empty in a {@link FontVariation}, the {@link FontVariation.base_font}'s fallbacks are used instead.
+   */
+  fallbacks: Array<Font>;
+  set_fallbacks(value: Array<Font>): void;
+  get_fallbacks(): Array<Font>;
+
+  /**
+   * Draw a single Unicode character `char` into a canvas item using the font, at a given position, with `modulate` color. `pos` specifies the baseline, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+   * **Note:** Do not use this function to draw strings character by character, use {@link draw_string} or {@link TextLine} instead.
+   */
+  draw_char(canvas_item: RID, pos: Vector2 | Vector2i, char: int, font_size: int, modulate?: Color, oversampling?: float): float;
+  /**
+   * Draw a single Unicode character `char` outline into a canvas item using the font, at a given position, with `modulate` color and `size` outline size. `pos` specifies the baseline, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+   * **Note:** Do not use this function to draw strings character by character, use {@link draw_string} or {@link TextLine} instead.
+   */
+  draw_char_outline(canvas_item: RID, pos: Vector2 | Vector2i, char: int, font_size: int, size?: int, modulate?: Color, oversampling?: float): float;
+  /**
+   * Breaks `text` into lines using rules specified by `brk_flags` and draws it into a canvas item using the font, at a given position, with `modulate` color, optionally clipping the width and aligning horizontally. `pos` specifies the baseline of the first line, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+   * See also {@link CanvasItem.draw_multiline_string}.
+   */
+  draw_multiline_string(canvas_item: RID, pos: Vector2 | Vector2i, text: string | NodePath, alignment: int, width?: float, font_size?: int, max_lines?: int, modulate?: Color, brk_flags?: int, justification_flags?: int, direction?: int, orientation?: int, oversampling?: float): void;
+  /**
+   * Breaks `text` to the lines using rules specified by `brk_flags` and draws text outline into a canvas item using the font, at a given position, with `modulate` color and `size` outline size, optionally clipping the width and aligning horizontally. `pos` specifies the baseline of the first line, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+   * See also {@link CanvasItem.draw_multiline_string_outline}.
+   */
+  draw_multiline_string_outline(canvas_item: RID, pos: Vector2 | Vector2i, text: string | NodePath, alignment: int, width?: float, font_size?: int, max_lines?: int, size?: int, modulate?: Color, brk_flags?: int, justification_flags?: int, direction?: int, orientation?: int, oversampling?: float): void;
+  /**
+   * Draw `text` into a canvas item using the font, at a given position, with `modulate` color, optionally clipping the width and aligning horizontally. `pos` specifies the baseline, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+   * See also {@link CanvasItem.draw_string}.
+   */
+  draw_string(canvas_item: RID, pos: Vector2 | Vector2i, text: string | NodePath, alignment: int, width?: float, font_size?: int, modulate?: Color, justification_flags?: int, direction?: int, orientation?: int, oversampling?: float): void;
+  /**
+   * Draw `text` outline into a canvas item using the font, at a given position, with `modulate` color and `size` outline size, optionally clipping the width and aligning horizontally. `pos` specifies the baseline, not the top. To draw from the top, *ascent* must be added to the Y axis. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+   * See also {@link CanvasItem.draw_string_outline}.
+   */
+  draw_string_outline(canvas_item: RID, pos: Vector2 | Vector2i, text: string | NodePath, alignment: int, width?: float, font_size?: int, size?: int, modulate?: Color, justification_flags?: int, direction?: int, orientation?: int, oversampling?: float): void;
+  /** Returns {@link TextServer} RID of the font cache for specific variation. */
+  find_variation(variation_coordinates: Dictionary, face_index?: int, strength?: float, transform?: Transform2D, spacing_top?: int, spacing_bottom?: int, spacing_space?: int, spacing_glyph?: int, baseline_offset?: float): RID;
+  /**
+   * Returns the maximum font ascent (number of pixels above the baseline) of this font and all fallback fonts.
+   * **Note:** Real ascent of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate (e.g. as the ascent of empty line).
+   */
+  get_ascent(font_size?: int): float;
+  /**
+   * Returns the size of a character. Does not take kerning into account.
+   * **Note:** Do not use this function to calculate width of the string character by character, use {@link get_string_size} or {@link TextLine} instead. The height returned is the font height (see also {@link get_height}) and has no relation to the glyph height.
+   */
+  get_char_size(char: int, font_size: int): Vector2;
+  /**
+   * Returns the maximum font descent (number of pixels below the baseline) of this font and all fallback fonts.
+   * **Note:** Real descent of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate (e.g. as the descent of empty line).
+   */
+  get_descent(font_size?: int): float;
+  /** Returns number of faces in the TrueType / OpenType collection. */
+  get_face_count(): int;
+  /** Returns font family name. */
+  get_font_name(): string;
+  /**
+   * Returns font stretch amount, compared to a normal width. A percentage value between `50%` and `200%`.
+   */
+  get_font_stretch(): int;
+  /** Returns font style flags. */
+  get_font_style(): int;
+  /** Returns font style name. */
+  get_font_style_name(): string;
+  /**
+   * Returns weight (boldness) of the font. A value in the `100...999` range, normal font weight is `400`, bold font weight is `700`.
+   */
+  get_font_weight(): int;
+  /**
+   * Returns the total average font height (ascent plus descent) in pixels.
+   * **Note:** Real height of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate (e.g. as the height of empty line).
+   */
+  get_height(font_size?: int): float;
+  /**
+   * Returns the size of a bounding box of a string broken into the lines, taking kerning and advance into account.
+   * See also {@link draw_multiline_string}.
+   */
+  get_multiline_string_size(text: string | NodePath, alignment: int, width?: float, font_size?: int, max_lines?: int, brk_flags?: int, justification_flags?: int, direction?: int, orientation?: int): Vector2;
+  /**
+   * Returns a set of OpenType feature tags. More info: OpenType feature tags (https://docs.microsoft.com/en-us/typography/opentype/spec/featuretags).
+   */
+  get_opentype_features(): Dictionary;
+  /**
+   * Returns {@link Dictionary} with OpenType font name strings (localized font names, version, description, license information, sample text, etc.).
+   */
+  get_ot_name_strings(): Dictionary;
+  /**
+   * Returns {@link Array} of valid {@link Font} {@link RID}s, which can be passed to the {@link TextServer} methods.
+   */
+  get_rids(): Array<RID>;
+  /** Returns the amount of spacing for the given `spacing` type. */
+  get_spacing(spacing: int): int;
+  /**
+   * Returns the size of a bounding box of a single-line string, taking kerning, advance and subpixel positioning into account. See also {@link get_multiline_string_size} and {@link draw_string}.
+   * For example, to get the string size as displayed by a single-line Label, use:
+   * **Note:** Since kerning, advance and subpixel positioning are taken into account by {@link get_string_size}, using separate {@link get_string_size} calls on substrings of a string then adding the results together will return a different result compared to using a single {@link get_string_size} call on the full string.
+   * **Note:** Real height of the string is context-dependent and can be significantly different from the value returned by {@link get_height}.
+   */
+  get_string_size(text: string | NodePath, alignment: int, width?: float, font_size?: int, justification_flags?: int, direction?: int, orientation?: int): Vector2;
+  /**
+   * Returns a string containing all the characters available in the font.
+   * If a given character is included in more than one font data source, it appears only once in the returned string.
+   */
+  get_supported_chars(): string;
+  /** Returns list of OpenType features supported by font. */
+  get_supported_feature_list(): Dictionary;
+  /**
+   * Returns list of supported variation coordinates (https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg), each coordinate is returned as `tag: Vector3i(min_value,max_value,default_value)`.
+   * Font variations allow for continuous change of glyph characteristics along some given design axis, such as weight, width or slant.
+   * To print available variation axes of a variable font:
+   * **Note:** To set and get variation coordinates of a {@link FontVariation}, use {@link FontVariation.variation_opentype}.
+   */
+  get_supported_variation_list(): Dictionary;
+  /**
+   * Returns average pixel offset of the underline below the baseline.
+   * **Note:** Real underline position of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate.
+   */
+  get_underline_position(font_size?: int): float;
+  /**
+   * Returns average thickness of the underline.
+   * **Note:** Real underline thickness of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate.
+   */
+  get_underline_thickness(font_size?: int): float;
+  /** Returns `true` if a Unicode `char` is available in the font. */
+  has_char(char: int): boolean;
+  /**
+   * Returns `true` if the font supports the given language (as a ISO 639 (https://en.wikipedia.org/wiki/ISO_639-1) code).
+   */
+  is_language_supported(language: string | NodePath): boolean;
+  /**
+   * Returns `true` if the font supports the given script (as a ISO 15924 (https://en.wikipedia.org/wiki/ISO_15924) code).
+   */
+  is_script_supported(script: string | NodePath): boolean;
+  /** Sets LRU cache capacity for `draw_*` methods. */
+  set_cache_capacity(single_line: int, multi_line: int): void;
+}

package/typings/classes/FontFile.d.ts

@@ -0,0 +1,286 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Holds font source data and prerendered glyph cache, imported from a dynamic or a bitmap font. */
+declare class FontFile extends Font {
+  /** If set to `true`, system fonts can be automatically used as fallbacks. */
+  allow_system_fallback: boolean;
+  /** Font anti-aliasing mode. */
+  antialiasing: int;
+  /** Contents of the dynamic font source file. */
+  data: PackedByteArray;
+  /**
+   * If set to `true`, embedded font bitmap loading is disabled (bitmap-only and color fonts ignore this property).
+   */
+  disable_embedded_bitmaps: boolean;
+  /** Font size, used only for the bitmap fonts. */
+  fixed_size: int;
+  /** Scaling mode, used only for the bitmap fonts with {@link fixed_size} greater than zero. */
+  fixed_size_scale_mode: int;
+  /** Font family name. */
+  font_name: string;
+  /** Font stretch amount, compared to a normal width. A percentage value between `50%` and `200%`. */
+  font_stretch: int;
+  /** Font style flags. */
+  font_style: int;
+  /**
+   * Weight (boldness) of the font. A value in the `100...999` range, normal font weight is `400`, bold font weight is `700`.
+   */
+  font_weight: int;
+  /**
+   * If set to `true`, auto-hinting is supported and preferred over font built-in hinting. Used by dynamic fonts only (MSDF fonts don't support hinting).
+   */
+  force_autohinter: boolean;
+  /** If set to `true`, generate mipmaps for the font textures. */
+  generate_mipmaps: boolean;
+  /** Font hinting mode. Used by dynamic fonts only. */
+  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;
+  /**
+   * 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 `16` allows outline sizes up to `8` 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.
+   */
+  msdf_size: int;
+  /**
+   * If set to `true`, glyphs of all sizes are rendered using single multichannel signed distance field (MSDF) generated from the dynamic font vector data. 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). As a downside, font hinting is not available with MSDF. The lack of font hinting may result in less crisp and less readable fonts at small sizes.
+   * **Note:** If using font outlines, {@link msdf_pixel_range} must be set to at least *twice* the size of the largest font outline.
+   * **Note:** MSDF font rendering does not render glyphs with overlapping shapes correctly. Overlapping shapes are not valid per the OpenType standard, but are still commonly found in many font files, especially those converted by Google Fonts. To avoid issues with overlapping glyphs, consider downloading the font file directly from the type foundry instead of relying on Google Fonts.
+   */
+  multichannel_signed_distance_field: boolean;
+  /** Font OpenType feature set override. */
+  opentype_feature_overrides: 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;
+  /** Font style name. */
+  style_name: string;
+  /**
+   * Font glyph subpixel positioning mode. Subpixel positioning provides shaper text and better kerning for smaller font sizes, at the cost of higher memory usage and lower font rasterization speed. Use {@link TextServer.SUBPIXEL_POSITIONING_AUTO} to automatically enable it based on the font size.
+   */
+  subpixel_positioning: int;
+  set_allow_system_fallback(value: boolean): void;
+  is_allow_system_fallback(): boolean;
+  set_antialiasing(value: int): void;
+  get_antialiasing(): int;
+  set_data(value: PackedByteArray | Array<unknown>): void;
+  get_data(): PackedByteArray;
+  set_disable_embedded_bitmaps(value: boolean): void;
+  get_disable_embedded_bitmaps(): boolean;
+  set_fixed_size(value: int): void;
+  get_fixed_size(): int;
+  set_fixed_size_scale_mode(value: int): void;
+  get_fixed_size_scale_mode(): int;
+  set_font_name(value: string | NodePath): void;
+  set_font_stretch(value: int): void;
+  set_font_style(value: int): void;
+  set_font_weight(value: int): void;
+  set_force_autohinter(value: boolean): void;
+  is_force_autohinter(): boolean;
+  set_generate_mipmaps(value: boolean): void;
+  get_generate_mipmaps(): boolean;
+  set_hinting(value: int): void;
+  get_hinting(): int;
+  set_keep_rounding_remainders(value: boolean): void;
+  get_keep_rounding_remainders(): boolean;
+  set_modulate_color_glyphs(value: boolean): void;
+  is_modulate_color_glyphs(): boolean;
+  set_msdf_pixel_range(value: int): void;
+  get_msdf_pixel_range(): int;
+  set_msdf_size(value: int): void;
+  get_msdf_size(): int;
+  set_multichannel_signed_distance_field(value: boolean): void;
+  is_multichannel_signed_distance_field(): boolean;
+  set_opentype_feature_overrides(value: Dictionary): void;
+  get_opentype_feature_overrides(): Dictionary;
+  set_oversampling(value: float): void;
+  get_oversampling(): float;
+  set_font_style_name(value: string | NodePath): void;
+  set_subpixel_positioning(value: int): void;
+  get_subpixel_positioning(): int;
+
+  /** Removes all font cache entries. */
+  clear_cache(): void;
+  /**
+   * Removes all rendered glyph information from the cache entry.
+   * **Note:** This function will not remove textures associated with the glyphs, use {@link remove_texture} to remove them manually.
+   */
+  clear_glyphs(cache_index: int, size: Vector2i | Vector2): void;
+  /** Removes all kerning overrides. */
+  clear_kerning_map(cache_index: int, size: int): void;
+  /** Removes all font sizes from the cache entry. */
+  clear_size_cache(cache_index: int): void;
+  /**
+   * Removes all textures from font cache entry.
+   * **Note:** This function will not remove glyphs associated with the texture, use {@link remove_glyph} to remove them manually.
+   */
+  clear_textures(cache_index: int, size: Vector2i | Vector2): void;
+  /** Returns the font ascent (number of pixels above the baseline). */
+  get_cache_ascent(cache_index: int, size: int): float;
+  /** Returns number of the font cache entries. */
+  get_cache_count(): int;
+  /** Returns the font descent (number of pixels below the baseline). */
+  get_cache_descent(cache_index: int, size: int): float;
+  /** Returns scaling factor of the color bitmap font. */
+  get_cache_scale(cache_index: int, size: int): float;
+  /** Returns pixel offset of the underline below the baseline. */
+  get_cache_underline_position(cache_index: int, size: int): float;
+  /** Returns thickness of the underline in pixels. */
+  get_cache_underline_thickness(cache_index: int, size: int): float;
+  /**
+   * Returns character code associated with `glyph_index`, or `0` if `glyph_index` is invalid. See {@link get_glyph_index}.
+   */
+  get_char_from_glyph_index(size: int, glyph_index: int): int;
+  /**
+   * Returns embolden strength, if is not equal to zero, emboldens the font outlines. Negative values reduce the outline thickness.
+   */
+  get_embolden(cache_index: int): float;
+  /** Returns extra baseline offset (as a fraction of font height). */
+  get_extra_baseline_offset(cache_index: int): float;
+  /** Returns spacing for `spacing` in pixels (not relative to the font size). */
+  get_extra_spacing(cache_index: int, spacing: int): int;
+  /** Returns an active face index in the TrueType / OpenType collection. */
+  get_face_index(cache_index: int): int;
+  /**
+   * Returns glyph advance (offset of the next glyph).
+   * **Note:** Advance for glyphs outlines is the same as the base glyph advance and is not saved.
+   */
+  get_glyph_advance(cache_index: int, size: int, glyph: int): Vector2;
+  /** Returns the glyph index of a `char`, optionally modified by the `variation_selector`. */
+  get_glyph_index(size: int, char: int, variation_selector: int): int;
+  /** Returns list of rendered glyphs in the cache entry. */
+  get_glyph_list(cache_index: int, size: Vector2i | Vector2): PackedInt32Array;
+  /** Returns glyph offset from the baseline. */
+  get_glyph_offset(cache_index: int, size: Vector2i | Vector2, glyph: int): Vector2;
+  /** Returns glyph size. */
+  get_glyph_size(cache_index: int, size: Vector2i | Vector2, glyph: int): Vector2;
+  /** Returns index of the cache texture containing the glyph. */
+  get_glyph_texture_idx(cache_index: int, size: Vector2i | Vector2, glyph: int): int;
+  /** Returns rectangle in the cache texture containing the glyph. */
+  get_glyph_uv_rect(cache_index: int, size: Vector2i | Vector2, glyph: int): Rect2;
+  /** Returns kerning for the pair of glyphs. */
+  get_kerning(cache_index: int, size: int, glyph_pair: Vector2i | Vector2): Vector2;
+  /** Returns list of the kerning overrides. */
+  get_kerning_list(cache_index: int, size: int): Array<Vector2i>;
+  /** Returns `true` if support override is enabled for the `language`. */
+  get_language_support_override(language: string | NodePath): boolean;
+  /** Returns list of language support overrides. */
+  get_language_support_overrides(): PackedStringArray;
+  /** Returns `true` if support override is enabled for the `script`. */
+  get_script_support_override(script: string | NodePath): boolean;
+  /** Returns list of script support overrides. */
+  get_script_support_overrides(): PackedStringArray;
+  /**
+   * Returns list of the font sizes in the cache. Each size is {@link Vector2i} with font size and outline size.
+   */
+  get_size_cache_list(cache_index: int): Array<Vector2i>;
+  /** Returns number of textures used by font cache entry. */
+  get_texture_count(cache_index: int, size: Vector2i | Vector2): int;
+  /** Returns a copy of the font cache texture image. */
+  get_texture_image(cache_index: int, size: Vector2i | Vector2, texture_index: int): Image | null;
+  /** Returns a copy of the array containing glyph packing data. */
+  get_texture_offsets(cache_index: int, size: Vector2i | Vector2, texture_index: int): PackedInt32Array;
+  /**
+   * Returns 2D transform, applied to the font outlines, can be used for slanting, flipping and rotating glyphs.
+   */
+  get_transform(cache_index: int): Transform2D;
+  /**
+   * Returns variation coordinates for the specified font cache entry. See {@link Font.get_supported_variation_list} for more info.
+   */
+  get_variation_coordinates(cache_index: int): Dictionary;
+  /**
+   * Loads an AngelCode BMFont (.fnt, .font) bitmap font from file `path`.
+   * **Warning:** This method should only be used in the editor or in cases when you need to load external fonts at run-time, such as fonts located at the `user://` directory.
+   */
+  load_bitmap_font(path: string | NodePath): int;
+  /**
+   * Loads a TrueType (.ttf), OpenType (.otf), WOFF (.woff), WOFF2 (.woff2) or Type 1 (.pfb, .pfm) dynamic font from file `path`.
+   * **Warning:** This method should only be used in the editor or in cases when you need to load external fonts at run-time, such as fonts located at the `user://` directory.
+   */
+  load_dynamic_font(path: string | NodePath): int;
+  /** Removes specified font cache entry. */
+  remove_cache(cache_index: int): void;
+  /**
+   * Removes specified rendered glyph information from the cache entry.
+   * **Note:** This function will not remove textures associated with the glyphs, use {@link remove_texture} to remove them manually.
+   */
+  remove_glyph(cache_index: int, size: Vector2i | Vector2, glyph: int): void;
+  /** Removes kerning override for the pair of glyphs. */
+  remove_kerning(cache_index: int, size: int, glyph_pair: Vector2i | Vector2): void;
+  /** Remove language support override. */
+  remove_language_support_override(language: string | NodePath): void;
+  /** Removes script support override. */
+  remove_script_support_override(script: string | NodePath): void;
+  /** Removes specified font size from the cache entry. */
+  remove_size_cache(cache_index: int, size: Vector2i | Vector2): void;
+  /**
+   * Removes specified texture from the cache entry.
+   * **Note:** This function will not remove glyphs associated with the texture. Remove them manually using {@link remove_glyph}.
+   */
+  remove_texture(cache_index: int, size: Vector2i | Vector2, texture_index: int): void;
+  /** Renders specified glyph to the font cache texture. */
+  render_glyph(cache_index: int, size: Vector2i | Vector2, index: int): void;
+  /** Renders the range of characters to the font cache texture. */
+  render_range(cache_index: int, size: Vector2i | Vector2, start: int, end: int): void;
+  /** Sets the font ascent (number of pixels above the baseline). */
+  set_cache_ascent(cache_index: int, size: int, ascent: float): void;
+  /** Sets the font descent (number of pixels below the baseline). */
+  set_cache_descent(cache_index: int, size: int, descent: float): void;
+  /** Sets scaling factor of the color bitmap font. */
+  set_cache_scale(cache_index: int, size: int, scale: float): void;
+  /** Sets pixel offset of the underline below the baseline. */
+  set_cache_underline_position(cache_index: int, size: int, underline_position: float): void;
+  /** Sets thickness of the underline in pixels. */
+  set_cache_underline_thickness(cache_index: int, size: int, underline_thickness: float): void;
+  /**
+   * Sets embolden strength, if is not equal to zero, emboldens the font outlines. Negative values reduce the outline thickness.
+   */
+  set_embolden(cache_index: int, strength: float): void;
+  /** Sets extra baseline offset (as a fraction of font height). */
+  set_extra_baseline_offset(cache_index: int, baseline_offset: float): void;
+  /** Sets the spacing for `spacing` to `value` in pixels (not relative to the font size). */
+  set_extra_spacing(cache_index: int, spacing: int, value: int): void;
+  /** Sets an active face index in the TrueType / OpenType collection. */
+  set_face_index(cache_index: int, face_index: int): void;
+  /**
+   * Sets glyph advance (offset of the next glyph).
+   * **Note:** Advance for glyphs outlines is the same as the base glyph advance and is not saved.
+   */
+  set_glyph_advance(cache_index: int, size: int, glyph: int, advance: Vector2 | Vector2i): void;
+  /** Sets glyph offset from the baseline. */
+  set_glyph_offset(cache_index: int, size: Vector2i | Vector2, glyph: int, offset: Vector2 | Vector2i): void;
+  /** Sets glyph size. */
+  set_glyph_size(cache_index: int, size: Vector2i | Vector2, glyph: int, gl_size: Vector2 | Vector2i): void;
+  /** Sets index of the cache texture containing the glyph. */
+  set_glyph_texture_idx(cache_index: int, size: Vector2i | Vector2, glyph: int, texture_idx: int): void;
+  /** Sets rectangle in the cache texture containing the glyph. */
+  set_glyph_uv_rect(cache_index: int, size: Vector2i | Vector2, glyph: int, uv_rect: Rect2 | Rect2i): void;
+  /** Sets kerning for the pair of glyphs. */
+  set_kerning(cache_index: int, size: int, glyph_pair: Vector2i | Vector2, kerning: Vector2 | Vector2i): void;
+  /** Adds override for {@link Font.is_language_supported}. */
+  set_language_support_override(language: string | NodePath, supported: boolean): void;
+  /** Adds override for {@link Font.is_script_supported}. */
+  set_script_support_override(script: string | NodePath, supported: boolean): void;
+  /** Sets font cache texture image. */
+  set_texture_image(cache_index: int, size: Vector2i | Vector2, texture_index: int, image: Image): void;
+  /** Sets array containing glyph packing data. */
+  set_texture_offsets(cache_index: int, size: Vector2i | Vector2, texture_index: int, offset: PackedInt32Array | Array<unknown>): void;
+  /**
+   * Sets 2D transform, applied to the font outlines, can be used for slanting, flipping, and rotating glyphs.
+   */
+  set_transform(cache_index: int, transform: Transform2D): void;
+  /**
+   * Sets variation coordinates for the specified font cache entry. See {@link Font.get_supported_variation_list} for more info.
+   */
+  set_variation_coordinates(cache_index: int, variation_coordinates: Dictionary): void;
+}

package/typings/classes/FontVariation.d.ts

@@ -0,0 +1,56 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A variation of a font with additional settings. */
+declare class FontVariation extends Font {
+  /** Base font used to create a variation. If not set, default {@link Theme} font is used. */
+  base_font: Font | null;
+  /** Extra baseline offset (as a fraction of font height). */
+  baseline_offset: float;
+  /**
+   * A set of OpenType feature tags. More info: OpenType feature tags (https://docs.microsoft.com/en-us/typography/opentype/spec/featuretags).
+   */
+  opentype_features: Dictionary;
+  /** Extra spacing at the bottom of the line in pixels. */
+  spacing_bottom: int;
+  /** Extra spacing between graphical glyphs. */
+  spacing_glyph: int;
+  /** Extra width of the space glyphs. */
+  spacing_space: int;
+  /** Extra spacing at the top of the line in pixels. */
+  spacing_top: int;
+  /**
+   * If is not equal to zero, emboldens the font outlines. Negative values reduce the outline thickness.
+   * **Note:** Emboldened fonts might have self-intersecting outlines, which will prevent MSDF fonts and {@link TextMesh} from working correctly.
+   */
+  variation_embolden: float;
+  /** Active face index in the TrueType / OpenType collection file. */
+  variation_face_index: int;
+  /**
+   * Font OpenType variation coordinates. More info: OpenType variation tags (https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg).
+   * **Note:** This {@link Dictionary} uses OpenType tags as keys. Variation axes can be identified both by tags ([int], e.g. `0x77678674`) and names ({@link String}, e.g. `wght`). Some axes might be accessible by multiple names. For example, `wght` refers to the same axis as `weight`. Tags on the other hand are unique. To convert between names and tags, use {@link TextServer.name_to_tag} and {@link TextServer.tag_to_name}.
+   * **Note:** To get available variation axes of a font, use {@link Font.get_supported_variation_list}.
+   */
+  variation_opentype: Dictionary;
+  /**
+   * 2D transform, applied to the font outlines, can be used for slanting, flipping and rotating glyphs.
+   * For example, to simulate italic typeface by slanting, apply the following transform `Transform2D(1.0, slant, 0.0, 1.0, 0.0, 0.0)`.
+   */
+  variation_transform: Transform2D;
+  set_base_font(value: Font | null): void;
+  get_base_font(): Font | null;
+  set_baseline_offset(value: float): void;
+  get_baseline_offset(): float;
+  set_opentype_features(value: Dictionary): void;
+  set_variation_embolden(value: float): void;
+  get_variation_embolden(): float;
+  set_variation_face_index(value: int): void;
+  get_variation_face_index(): int;
+  set_variation_opentype(value: Dictionary): void;
+  get_variation_opentype(): Dictionary;
+  set_variation_transform(value: Transform2D): void;
+  get_variation_transform(): Transform2D;
+
+  /** Sets the spacing for `spacing` to `value` in pixels (not relative to the font size). */
+  set_spacing(spacing: int, value: int): void;
+}

package/typings/classes/FramebufferCacheRD.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Framebuffer cache manager for Rendering Device based renderers. */
+declare class FramebufferCacheRD extends GodotObject {
+  /**
+   * Creates, or obtains a cached, framebuffer. `textures` lists textures accessed. `passes` defines the subpasses and texture allocation, if left empty a single pass is created and textures are allocated depending on their usage flags. `views` defines the number of views used when rendering.
+   */
+  static get_cache_multipass(textures: Array<RID>, passes: Array<RDFramebufferPass>, views: int): RID;
+}

package/typings/classes/GDExtension.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A native library for GDExtension. */
+declare class GDExtension extends Resource {
+  /**
+   * Returns the lowest level required for this extension to be properly initialized (see the {@link InitializationLevel} enum).
+   */
+  get_minimum_library_initialization_level(): int;
+  /** Returns `true` if this extension's library has been opened. */
+  is_library_open(): boolean;
+
+  // enum InitializationLevel
+  /** The library is initialized at the same time as the core features of the engine. */
+  static readonly INITIALIZATION_LEVEL_CORE: int;
+  /**
+   * The library is initialized at the same time as the engine's servers (such as {@link RenderingServer} or {@link PhysicsServer3D}).
+   */
+  static readonly INITIALIZATION_LEVEL_SERVERS: int;
+  /** The library is initialized at the same time as the engine's scene-related classes. */
+  static readonly INITIALIZATION_LEVEL_SCENE: int;
+  /**
+   * The library is initialized at the same time as the engine's editor classes. Only happens when loading the GDExtension in the editor.
+   */
+  static readonly INITIALIZATION_LEVEL_EDITOR: int;
+}

package/typings/classes/GDExtensionManager.d.ts

@@ -0,0 +1,60 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides access to GDExtension functionality. */
+declare interface GDExtensionManager extends GodotObject {
+  /**
+   * Returns the {@link GDExtension} at the given file `path`, or `null` if it has not been loaded or does not exist.
+   */
+  get_extension(path: string | NodePath): GDExtension | null;
+  /** Returns the file paths of all currently loaded extensions. */
+  get_loaded_extensions(): PackedStringArray;
+  /**
+   * Returns `true` if the extension at the given file `path` has already been loaded successfully. See also {@link get_loaded_extensions}.
+   */
+  is_extension_loaded(path: string | NodePath): boolean;
+  /**
+   * Loads an extension by absolute file path. The `path` needs to point to a valid {@link GDExtension}. Returns {@link LOAD_STATUS_OK} if successful.
+   */
+  load_extension(path: string | NodePath): int;
+  /**
+   * Loads the extension already in address space via the given path and initialization function. The `path` needs to be unique and start with `"libgodot://"`. Returns {@link LOAD_STATUS_OK} if successful.
+   */
+  load_extension_from_function(path: string | NodePath, init_func: unknown): int;
+  /**
+   * Reloads the extension at the given file path. The `path` needs to point to a valid {@link GDExtension}, otherwise this method may return either {@link LOAD_STATUS_NOT_LOADED} or {@link LOAD_STATUS_FAILED}.
+   * **Note:** You can only reload extensions in the editor. In release builds, this method always fails and returns {@link LOAD_STATUS_FAILED}.
+   */
+  reload_extension(path: string | NodePath): int;
+  /**
+   * Unloads an extension by file path. The `path` needs to point to an already loaded {@link GDExtension}, otherwise this method returns {@link LOAD_STATUS_NOT_LOADED}.
+   */
+  unload_extension(path: string | NodePath): int;
+
+  /**
+   * Emitted after the editor has finished loading a new extension.
+   * **Note:** This signal is only emitted in editor builds.
+   */
+  extension_loaded: Signal<[GDExtension]>;
+  /**
+   * Emitted before the editor starts unloading an extension.
+   * **Note:** This signal is only emitted in editor builds.
+   */
+  extension_unloading: Signal<[GDExtension]>;
+  /** Emitted after the editor has finished reloading one or more extensions. */
+  extensions_reloaded: Signal<[]>;
+
+  // enum LoadStatus
+  /** The extension has loaded successfully. */
+  readonly LOAD_STATUS_OK: int;
+  /** The extension has failed to load, possibly because it does not exist or has missing dependencies. */
+  readonly LOAD_STATUS_FAILED: int;
+  /** The extension has already been loaded. */
+  readonly LOAD_STATUS_ALREADY_LOADED: int;
+  /** The extension has not been loaded. */
+  readonly LOAD_STATUS_NOT_LOADED: int;
+  /** The extension requires the application to restart to fully load. */
+  readonly LOAD_STATUS_NEEDS_RESTART: int;
+}
+declare const GDExtensionManager: GDExtensionManager;
+