@ringozz/godot 0.1.0

package/gen/classes/Theme.ts

@@ -0,0 +1,438 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { PackedStringArray, StringName, Variant } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+import type { Font } from './Font.ts';
+import type { StyleBox } from './StyleBox.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * A resource used for styling/skinning {@link Control} and {@link Window} nodes. While individual controls can be styled using their local theme overrides (see {@link Control.addThemeColorOverride}), theme resources allow you to store and apply the same settings across all controls sharing the same type (e.g. style all {@link Button}s the same). One theme resource can be used for the entire project, but you can also set a separate theme resource to a branch of control nodes. A theme resource assigned to a control applies to the control itself, as well as all of its direct and indirect children (as long as a chain of controls is uninterrupted).
+ * Use {@link ProjectSettings.gui/theme/custom} to set up a project-scope theme that will be available to every control in your project.
+ * Use {@link Control.theme} of any control node to set up a theme that will be available to that control and all of its direct and indirect children.
+ */
+export class Theme extends Resource {
+    constructor(name = 790) { super(name); }
+
+    /**
+     * Creates or changes the value of the icon property defined by `name` and `themeType`. Use {@link clearIcon} to remove the property.
+     */
+    setIcon(name: StringName, themeType: StringName, texture: Texture2D): void { _C(this, 11645, name, themeType, texture); }
+
+    /**
+     * Returns the icon property defined by `name` and `themeType`, if it exists.
+     * Returns the engine fallback icon value if the property doesn't exist (see {@link ThemeDB.fallbackIcon}). Use {@link hasIcon} to check for existence.
+     */
+    getIcon(name: StringName, themeType: StringName): Texture2D { return _C(this, 5051, name, themeType) as Texture2D; }
+
+    /**
+     * Returns `true` if the icon property defined by `name` and `themeType` exists.
+     * Returns `false` if it doesn't exist. Use {@link setIcon} to define it.
+     */
+    hasIcon(name: StringName, themeType: StringName): boolean { return _C(this, 7402, name, themeType) as boolean; }
+
+    /**
+     * Renames the icon property defined by `oldName` and `themeType` to `name`, if it exists.
+     * Fails if it doesn't exist, or if a similar property with the new name already exists. Use {@link hasIcon} to check for existence, and {@link clearIcon} to remove the existing property.
+     */
+    renameIcon(oldName: StringName, name: StringName, themeType: StringName): void { _C(this, 9999, oldName, name, themeType); }
+
+    /**
+     * Removes the icon property defined by `name` and `themeType`, if it exists.
+     * Fails if it doesn't exist. Use {@link hasIcon} to check for existence.
+     */
+    clearIcon(name: StringName, themeType: StringName): void { _C(this, 2274, name, themeType); }
+
+    /**
+     * Returns a list of names for icon properties defined with `themeType`. Use {@link getIconTypeList} to get a list of possible theme type names.
+     */
+    getIconList(themeType: string): PackedStringArray { return _C(this, 5054, themeType) as PackedStringArray; }
+
+    /**
+     * Returns a list of all unique theme type names for icon properties. Use {@link getTypeList} to get a list of all unique theme types.
+     */
+    getIconTypeList(): PackedStringArray { return _C(this, 5061) as PackedStringArray; }
+
+    /**
+     * Creates or changes the value of the {@link StyleBox} property defined by `name` and `themeType`. Use {@link clearStylebox} to remove the property.
+     */
+    setStylebox(name: StringName, themeType: StringName, texture: StyleBox): void { _C(this, 12915, name, themeType, texture); }
+
+    /**
+     * Returns the {@link StyleBox} property defined by `name` and `themeType`, if it exists.
+     * Returns the engine fallback stylebox value if the property doesn't exist (see {@link ThemeDB.fallbackStylebox}). Use {@link hasStylebox} to check for existence.
+     */
+    getStylebox(name: StringName, themeType: StringName): StyleBox { return _C(this, 6587, name, themeType) as StyleBox; }
+
+    /**
+     * Returns `true` if the {@link StyleBox} property defined by `name` and `themeType` exists.
+     * Returns `false` if it doesn't exist. Use {@link setStylebox} to define it.
+     */
+    hasStylebox(name: StringName, themeType: StringName): boolean { return _C(this, 7454, name, themeType) as boolean; }
+
+    /**
+     * Renames the {@link StyleBox} property defined by `oldName` and `themeType` to `name`, if it exists.
+     * Fails if it doesn't exist, or if a similar property with the new name already exists. Use {@link hasStylebox} to check for existence, and {@link clearStylebox} to remove the existing property.
+     */
+    renameStylebox(oldName: StringName, name: StringName, themeType: StringName): void { _C(this, 10002, oldName, name, themeType); }
+
+    /**
+     * Removes the {@link StyleBox} property defined by `name` and `themeType`, if it exists.
+     * Fails if it doesn't exist. Use {@link hasStylebox} to check for existence.
+     */
+    clearStylebox(name: StringName, themeType: StringName): void { _C(this, 2298, name, themeType); }
+
+    /**
+     * Returns a list of names for {@link StyleBox} properties defined with `themeType`. Use {@link getStyleboxTypeList} to get a list of possible theme type names.
+     */
+    getStyleboxList(themeType: string): PackedStringArray { return _C(this, 6588, themeType) as PackedStringArray; }
+
+    /**
+     * Returns a list of all unique theme type names for {@link StyleBox} properties. Use {@link getTypeList} to get a list of all unique theme types.
+     */
+    getStyleboxTypeList(): PackedStringArray { return _C(this, 6589) as PackedStringArray; }
+
+    /**
+     * Creates or changes the value of the {@link Font} property defined by `name` and `themeType`. Use {@link clearFont} to remove the property.
+     */
+    setFont(name: StringName, themeType: StringName, font: Font): void { _C(this, 11452, name, themeType, font); }
+
+    /**
+     * Returns the {@link Font} property defined by `name` and `themeType`, if it exists.
+     * Returns the default theme font if the property doesn't exist and the default theme font is set up (see {@link defaultFont}). Use {@link hasFont} to check for existence of the property and {@link hasDefaultFont} to check for existence of the default theme font.
+     * Returns the engine fallback font value, if neither exist (see {@link ThemeDB.fallbackFont}).
+     */
+    getFont(name: StringName, themeType: StringName): Font { return _C(this, 4846, name, themeType) as Font; }
+
+    /**
+     * Returns `true` if the {@link Font} property defined by `name` and `themeType` exists, or if the default theme font is set up (see {@link hasDefaultFont}).
+     * Returns `false` if neither exist. Use {@link setFont} to define the property.
+     */
+    hasFont(name: StringName, themeType: StringName): boolean { return _C(this, 7398, name, themeType) as boolean; }
+
+    /**
+     * Renames the {@link Font} property defined by `oldName` and `themeType` to `name`, if it exists.
+     * Fails if it doesn't exist, or if a similar property with the new name already exists. Use {@link hasFont} to check for existence, and {@link clearFont} to remove the existing property.
+     */
+    renameFont(oldName: StringName, name: StringName, themeType: StringName): void { _C(this, 9997, oldName, name, themeType); }
+
+    /**
+     * Removes the {@link Font} property defined by `name` and `themeType`, if it exists.
+     * Fails if it doesn't exist. Use {@link hasFont} to check for existence.
+     */
+    clearFont(name: StringName, themeType: StringName): void { _C(this, 2268, name, themeType); }
+
+    /**
+     * Returns a list of names for {@link Font} properties defined with `themeType`. Use {@link getFontTypeList} to get a list of possible theme type names.
+     */
+    getFontList(themeType: string): PackedStringArray { return _C(this, 4849, themeType) as PackedStringArray; }
+
+    /**
+     * Returns a list of all unique theme type names for {@link Font} properties. Use {@link getTypeList} to get a list of all unique theme types.
+     */
+    getFontTypeList(): PackedStringArray { return _C(this, 4858) as PackedStringArray; }
+
+    /**
+     * Creates or changes the value of the font size property defined by `name` and `themeType`. Use {@link clearFontSize} to remove the property.
+     */
+    setFontSize(name: StringName, themeType: StringName, fontSize: number): void { _C(this, 11457, name, themeType, fontSize); }
+
+    /**
+     * Returns the font size property defined by `name` and `themeType`, if it exists.
+     * Returns the default theme font size if the property doesn't exist and the default theme font size is set up (see {@link defaultFontSize}). Use {@link hasFontSize} to check for existence of the property and {@link hasDefaultFontSize} to check for existence of the default theme font.
+     * Returns the engine fallback font size value, if neither exist (see {@link ThemeDB.fallbackFontSize}).
+     */
+    getFontSize(name: StringName, themeType: StringName): number { return _C(this, 4852, name, themeType) as number; }
+
+    /**
+     * Returns `true` if the font size property defined by `name` and `themeType` exists, or if the default theme font size is set up (see {@link hasDefaultFontSize}).
+     * Returns `false` if neither exist. Use {@link setFontSize} to define the property.
+     */
+    hasFontSize(name: StringName, themeType: StringName): boolean { return _C(this, 7399, name, themeType) as boolean; }
+
+    /**
+     * Renames the font size property defined by `oldName` and `themeType` to `name`, if it exists.
+     * Fails if it doesn't exist, or if a similar property with the new name already exists. Use {@link hasFontSize} to check for existence, and {@link clearFontSize} to remove the existing property.
+     */
+    renameFontSize(oldName: StringName, name: StringName, themeType: StringName): void { _C(this, 9998, oldName, name, themeType); }
+
+    /**
+     * Removes the font size property defined by `name` and `themeType`, if it exists.
+     * Fails if it doesn't exist. Use {@link hasFontSize} to check for existence.
+     */
+    clearFontSize(name: StringName, themeType: StringName): void { _C(this, 2269, name, themeType); }
+
+    /**
+     * Returns a list of names for font size properties defined with `themeType`. Use {@link getFontSizeTypeList} to get a list of possible theme type names.
+     */
+    getFontSizeList(themeType: string): PackedStringArray { return _C(this, 4853, themeType) as PackedStringArray; }
+
+    /**
+     * Returns a list of all unique theme type names for font size properties. Use {@link getTypeList} to get a list of all unique theme types.
+     */
+    getFontSizeTypeList(): PackedStringArray { return _C(this, 4854) as PackedStringArray; }
+
+    /**
+     * Creates or changes the value of the {@link Color} property defined by `name` and `themeType`. Use {@link clearColor} to remove the property.
+     */
+    setColor(name: StringName, themeType: StringName, color: Color): void { _C(this, 10905, name, themeType, color); }
+
+    /**
+     * Returns the {@link Color} property defined by `name` and `themeType`, if it exists.
+     * Returns the default color value if the property doesn't exist. Use {@link hasColor} to check for existence.
+     */
+    getColor(name: StringName, themeType: StringName): Color { return _C(this, 4219, name, themeType) as Color; }
+
+    /**
+     * Returns `true` if the {@link Color} property defined by `name` and `themeType` exists.
+     * Returns `false` if it doesn't exist. Use {@link setColor} to define it.
+     */
+    hasColor(name: StringName, themeType: StringName): boolean { return _C(this, 7376, name, themeType) as boolean; }
+
+    /**
+     * Renames the {@link Color} property defined by `oldName` and `themeType` to `name`, if it exists.
+     * Fails if it doesn't exist, or if a similar property with the new name already exists. Use {@link hasColor} to check for existence, and {@link clearColor} to remove the existing property.
+     */
+    renameColor(oldName: StringName, name: StringName, themeType: StringName): void { _C(this, 9995, oldName, name, themeType); }
+
+    /**
+     * Removes the {@link Color} property defined by `name` and `themeType`, if it exists.
+     * Fails if it doesn't exist. Use {@link hasColor} to check for existence.
+     */
+    clearColor(name: StringName, themeType: StringName): void { _C(this, 2250, name, themeType); }
+
+    /**
+     * Returns a list of names for {@link Color} properties defined with `themeType`. Use {@link getColorTypeList} to get a list of possible theme type names.
+     */
+    getColorList(themeType: string): PackedStringArray { return _C(this, 4225, themeType) as PackedStringArray; }
+
+    /**
+     * Returns a list of all unique theme type names for {@link Color} properties. Use {@link getTypeList} to get a list of all unique theme types.
+     */
+    getColorTypeList(): PackedStringArray { return _C(this, 4231) as PackedStringArray; }
+
+    /**
+     * Creates or changes the value of the constant property defined by `name` and `themeType`. Use {@link clearConstant} to remove the property.
+     */
+    setConstant(name: StringName, themeType: StringName, constant: number): void { _C(this, 10942, name, themeType, constant); }
+
+    /**
+     * Returns the constant property defined by `name` and `themeType`, if it exists.
+     * Returns `0` if the property doesn't exist. Use {@link hasConstant} to check for existence.
+     */
+    getConstant(name: StringName, themeType: StringName): number { return _C(this, 4283, name, themeType) as number; }
+
+    /**
+     * Returns `true` if the constant property defined by `name` and `themeType` exists.
+     * Returns `false` if it doesn't exist. Use {@link setConstant} to define it.
+     */
+    hasConstant(name: StringName, themeType: StringName): boolean { return _C(this, 7380, name, themeType) as boolean; }
+
+    /**
+     * Renames the constant property defined by `oldName` and `themeType` to `name`, if it exists.
+     * Fails if it doesn't exist, or if a similar property with the new name already exists. Use {@link hasConstant} to check for existence, and {@link clearConstant} to remove the existing property.
+     */
+    renameConstant(oldName: StringName, name: StringName, themeType: StringName): void { _C(this, 9996, oldName, name, themeType); }
+
+    /**
+     * Removes the constant property defined by `name` and `themeType`, if it exists.
+     * Fails if it doesn't exist. Use {@link hasConstant} to check for existence.
+     */
+    clearConstant(name: StringName, themeType: StringName): void { _C(this, 2254, name, themeType); }
+
+    /**
+     * Returns a list of names for constant properties defined with `themeType`. Use {@link getConstantTypeList} to get a list of possible theme type names.
+     */
+    getConstantList(themeType: string): PackedStringArray { return _C(this, 4288, themeType) as PackedStringArray; }
+
+    /**
+     * Returns a list of all unique theme type names for constant properties. Use {@link getTypeList} to get a list of all unique theme types.
+     */
+    getConstantTypeList(): PackedStringArray { return _C(this, 4290) as PackedStringArray; }
+
+    /**
+     * Returns `true` if {@link defaultBaseScale} has a valid value.
+     * Returns `false` if it doesn't. The value must be greater than `0.0` to be considered valid.
+     */
+    hasDefaultBaseScale(): boolean { return _C(this, 7386) as boolean; }
+
+    /**
+     * Returns `true` if {@link defaultFont} has a valid value.
+     * Returns `false` if it doesn't.
+     */
+    hasDefaultFont(): boolean { return _C(this, 7387) as boolean; }
+
+    /**
+     * Returns `true` if {@link defaultFontSize} has a valid value.
+     * Returns `false` if it doesn't. The value must be greater than `0` to be considered valid.
+     */
+    hasDefaultFontSize(): boolean { return _C(this, 7388) as boolean; }
+
+    /**
+     * Creates or changes the value of the theme property of `dataType` defined by `name` and `themeType`. Use {@link clearThemeItem} to remove the property.
+     * Fails if the `value` type is not accepted by `dataType`.
+     * **Note:** This method is analogous to calling the corresponding data type specific method, but can be used for more generalized logic.
+     */
+    setThemeItem(dataType: DataType, name: StringName, themeType: StringName, value: Variant): void { _C(this, 13052, dataType, name, themeType, value); }
+
+    /**
+     * Returns the theme property of `dataType` defined by `name` and `themeType`, if it exists.
+     * Returns the engine fallback value if the property doesn't exist (see {@link ThemeDB}). Use {@link hasThemeItem} to check for existence.
+     * **Note:** This method is analogous to calling the corresponding data type specific method, but can be used for more generalized logic.
+     */
+    getThemeItem(dataType: DataType, name: StringName, themeType: StringName): Variant { return _C(this, 6768, dataType, name, themeType) as Variant; }
+
+    /**
+     * Returns `true` if the theme property of `dataType` defined by `name` and `themeType` exists.
+     * Returns `false` if it doesn't exist. Use {@link setThemeItem} to define it.
+     * **Note:** This method is analogous to calling the corresponding data type specific method, but can be used for more generalized logic.
+     */
+    hasThemeItem(dataType: DataType, name: StringName, themeType: StringName): boolean { return _C(this, 7468, dataType, name, themeType) as boolean; }
+
+    /**
+     * Renames the theme property of `dataType` defined by `oldName` and `themeType` to `name`, if it exists.
+     * Fails if it doesn't exist, or if a similar property with the new name already exists. Use {@link hasThemeItem} to check for existence, and {@link clearThemeItem} to remove the existing property.
+     * **Note:** This method is analogous to calling the corresponding data type specific method, but can be used for more generalized logic.
+     */
+    renameThemeItem(dataType: DataType, oldName: StringName, name: StringName, themeType: StringName): void { _C(this, 10003, dataType, oldName, name, themeType); }
+
+    /**
+     * Removes the theme property of `dataType` defined by `name` and `themeType`, if it exists.
+     * Fails if it doesn't exist. Use {@link hasThemeItem} to check for existence.
+     * **Note:** This method is analogous to calling the corresponding data type specific method, but can be used for more generalized logic.
+     */
+    clearThemeItem(dataType: DataType, name: StringName, themeType: StringName): void { _C(this, 2304, dataType, name, themeType); }
+
+    /**
+     * Returns a list of names for properties of `dataType` defined with `themeType`. Use {@link getThemeItemTypeList} to get a list of possible theme type names.
+     * **Note:** This method is analogous to calling the corresponding data type specific method, but can be used for more generalized logic.
+     */
+    getThemeItemList(dataType: DataType, themeType: string): PackedStringArray { return _C(this, 6769, dataType, themeType) as PackedStringArray; }
+
+    /**
+     * Returns a list of all unique theme type names for `dataType` properties. Use {@link getTypeList} to get a list of all unique theme types.
+     * **Note:** This method is analogous to calling the corresponding data type specific method, but can be used for more generalized logic.
+     */
+    getThemeItemTypeList(dataType: DataType): PackedStringArray { return _C(this, 6770, dataType) as PackedStringArray; }
+
+    /**
+     * Marks `themeType` as a variation of `baseType`.
+     * This adds `themeType` as a suggested option for {@link Control.themeTypeVariation} on a {@link Control} that is of the `baseType` class.
+     * Variations can also be nested, i.e. `baseType` can be another variation. If a chain of variations ends with a `baseType` matching the class of the {@link Control}, the whole chain is going to be suggested as options.
+     * **Note:** Suggestions only show up if this theme resource is set as the project default theme. See {@link ProjectSettings.gui/theme/custom}.
+     */
+    setTypeVariation(themeType: StringName, baseType: StringName): void { _C(this, 13164, themeType, baseType); }
+
+    /**
+     * Returns `true` if `themeType` is marked as a variation of `baseType`.
+     */
+    isTypeVariation(themeType: StringName, baseType: StringName): boolean { return _C(this, 8378, themeType, baseType) as boolean; }
+
+    /**
+     * Unmarks `themeType` as being a variation of another theme type. See {@link setTypeVariation}.
+     */
+    clearTypeVariation(themeType: StringName): void { _C(this, 2307, themeType); }
+
+    /**
+     * Returns the name of the base theme type if `themeType` is a valid variation type. Returns an empty string otherwise.
+     */
+    getTypeVariationBase(themeType: StringName): StringName { return _C(this, 6924, themeType) as StringName; }
+
+    /**
+     * Returns a list of all type variations for the given `baseType`.
+     */
+    getTypeVariationList(baseType: StringName): PackedStringArray { return _C(this, 6925, baseType) as PackedStringArray; }
+
+    /**
+     * Adds an empty theme type for every valid data type.
+     * **Note:** Empty types are not saved with the theme. This method only exists to perform in-memory changes to the resource. Use available `set_*` methods to add theme items.
+     */
+    addType(themeType: StringName): void { _C(this, 1323, themeType); }
+
+    /**
+     * Removes the theme type, gracefully discarding defined theme items. If the type is a variation, this information is also erased. If the type is a base for type variations, those variations lose their base.
+     */
+    removeType(themeType: StringName): void { _C(this, 9984, themeType); }
+
+    /**
+     * Renames the theme type `oldThemeType` to `themeType`, if the old type exists and the new one doesn't exist.
+     * **Note:** Renaming a theme type to an empty name or a variation to a type associated with a built-in class removes type variation connections in a way that cannot be undone by reversing the rename alone.
+     */
+    renameType(oldThemeType: StringName, themeType: StringName): void { _C(this, 10004, oldThemeType, themeType); }
+
+    /**
+     * Returns a list of all unique theme type names. Use the appropriate `get_*_type_list` method to get a list of unique theme types for a single data type.
+     */
+    getTypeList(): PackedStringArray { return _C(this, 6922) as PackedStringArray; }
+
+    /**
+     * Adds missing and overrides existing definitions with values from the `other` theme resource.
+     * **Note:** This modifies the current theme. If you want to merge two themes together without modifying either one, create a new empty theme and merge the other two into it one after another.
+     */
+    mergeWith(other: Theme): void { _C(this, 8855, other); }
+
+    /**
+     * Removes all the theme properties defined on the theme resource.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * The default base scale factor of this theme resource. Used by some controls to scale their visual properties based on the global scale factor. If this value is set to `0.0`, the global scale factor is used (see {@link ThemeDB.fallbackBaseScale}).
+     * Use {@link hasDefaultBaseScale} to check if this value is valid.
+     */
+    get defaultBaseScale(): number { return _C(this, 4440) as number; }
+    set defaultBaseScale(v: number) { _C(this, 11053, v); }
+
+    /**
+     * The default font of this theme resource. Used as the default value when trying to fetch a font resource that doesn't exist in this theme or is in invalid state. If the default font is also missing or invalid, the engine fallback value is used (see {@link ThemeDB.fallbackFont}).
+     * Use {@link hasDefaultFont} to check if this value is valid.
+     */
+    get defaultFont(): Font { return _C(this, 4449) as Font; }
+    set defaultFont(v: Font) { _C(this, 11063, v); }
+
+    /**
+     * The default font size of this theme resource. Used as the default value when trying to fetch a font size value that doesn't exist in this theme or is in invalid state. If the default font size is also missing or invalid, the engine fallback value is used (see {@link ThemeDB.fallbackFontSize}).
+     * Values below `1` are invalid and can be used to unset the property. Use {@link hasDefaultFontSize} to check if this value is valid.
+     */
+    get defaultFontSize(): number { return _C(this, 4450) as number; }
+    set defaultFontSize(v: number) { _C(this, 11064, v); }
+
+    static readonly name = _R(790, Theme);
+}
+
+export const DataType = {
+    /**
+     * Theme's {@link Color} item type.
+     */
+    DATA_TYPE_COLOR: 0,
+    /**
+     * Theme's constant item type.
+     */
+    DATA_TYPE_CONSTANT: 1,
+    /**
+     * Theme's {@link Font} item type.
+     */
+    DATA_TYPE_FONT: 2,
+    /**
+     * Theme's font size item type.
+     */
+    DATA_TYPE_FONT_SIZE: 3,
+    /**
+     * Theme's icon {@link Texture2D} item type.
+     */
+    DATA_TYPE_ICON: 4,
+    /**
+     * Theme's {@link StyleBox} item type.
+     */
+    DATA_TYPE_STYLEBOX: 5,
+    /**
+     * Maximum value for the DataType enum.
+     */
+    DATA_TYPE_MAX: 6,
+} as const;
+
+export type DataType = (typeof DataType)[keyof typeof DataType];
+

package/gen/classes/ThemeDB.ts

@@ -0,0 +1,72 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Font } from './Font.ts';
+import type { StyleBox } from './StyleBox.ts';
+import type { Texture2D } from './Texture2D.ts';
+import type { Theme } from './Theme.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 791));
+
+/**
+ * This singleton provides access to static information about {@link Theme} resources used by the engine and by your projects. You can fetch the default engine theme, as well as your project configured theme.
+ * {@link ThemeDB} also contains fallback values for theme properties.
+ */
+export class ThemeDB extends GodotVar {
+
+    /**
+     * Returns a reference to the default engine {@link Theme}. This theme resource is responsible for the out-of-the-box look of {@link Control} nodes and cannot be overridden.
+     */
+    static getDefaultTheme(): Theme { return _C($(), 4455) as Theme; }
+
+    /**
+     * Returns a reference to the custom project {@link Theme}. This theme resources allows to override the default engine theme for every control node in the project.
+     * To set the project theme, see {@link ProjectSettings.gui/theme/custom}.
+     */
+    static getProjectTheme(): Theme { return _C($(), 6041) as Theme; }
+
+    /**
+     * The fallback base scale factor of every {@link Control} node and {@link Theme} resource. Used when no other value is available to the control.
+     * See also {@link Theme.defaultBaseScale}.
+     */
+    static get fallbackBaseScale(): number { return _C($(), 4748) as number; }
+    static set fallbackBaseScale(v: number) { _C($(), 11359, v); }
+
+    /**
+     * The fallback font of every {@link Control} node and {@link Theme} resource. Used when no other value is available to the control.
+     * See also {@link Theme.defaultFont}.
+     */
+    static get fallbackFont(): Font { return _C($(), 4750) as Font; }
+    static set fallbackFont(v: Font) { _C($(), 11361, v); }
+
+    /**
+     * The fallback font size of every {@link Control} node and {@link Theme} resource. Used when no other value is available to the control.
+     * See also {@link Theme.defaultFontSize}.
+     */
+    static get fallbackFontSize(): number { return _C($(), 4751) as number; }
+    static set fallbackFontSize(v: number) { _C($(), 11362, v); }
+
+    /**
+     * The fallback icon of every {@link Control} node and {@link Theme} resource. Used when no other value is available to the control.
+     */
+    static get fallbackIcon(): Texture2D { return _C($(), 4752) as Texture2D; }
+    static set fallbackIcon(v: Texture2D) { _C($(), 11363, v); }
+
+    /**
+     * The fallback stylebox of every {@link Control} node and {@link Theme} resource. Used when no other value is available to the control.
+     */
+    static get fallbackStylebox(): StyleBox { return _C($(), 4756) as StyleBox; }
+    static set fallbackStylebox(v: StyleBox) { _C($(), 11367, v); }
+
+    /**
+     * Emitted when one of the fallback values had been changed. Use it to refresh the look of controls that may rely on the fallback theme items.
+     */
+    static get fallbackChanged(): Signal<() => void> { return _G($(), 3223) as Signal<() => void>; }
+    static set fallbackChanged(v: (() => void) | null) { _G($(), 3223, v); }
+
+    static readonly name = _R(791, ThemeDB);
+}

package/gen/classes/Thread.ts

@@ -0,0 +1,86 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { Callable, Variant } from '../heap-types/index.ts';
+
+/**
+ * A unit of execution in a process. Can run methods on {@link Object}s simultaneously. The use of synchronization via {@link Mutex} or {@link Semaphore} is advised if working with shared objects.
+ * **Warning:** To ensure proper cleanup without crashes or deadlocks, when a {@link Thread}'s reference count reaches zero and it is therefore destroyed, the following conditions must be met:
+ * - It must not have any {@link Mutex} objects locked.
+ * - It must not be waiting on any {@link Semaphore} objects.
+ * - {@link waitToFinish} should have been called on it.
+ */
+export class Thread extends RefCounted {
+    constructor(name = 792) { super(name); }
+
+    /**
+     * Starts a new {@link Thread} that calls `callable`.
+     * If the method takes some arguments, you can pass them using {@link Callable.bind}.
+     * The `priority` of the {@link Thread} can be changed by passing a value from the {@link Priority} enum.
+     * Returns {@link OK} on success, or {@link ERR_CANT_CREATE} on failure.
+     */
+    start(callable: Callable, priority?: Priority /* = 1 */): Error { return _C(this, 13829, callable, priority) as Error; }
+
+    /**
+     * Returns the current {@link Thread}'s ID, uniquely identifying it among all threads. If the {@link Thread} has not started running or if {@link waitToFinish} has been called, this returns an empty string.
+     */
+    getId(): string { return _C(this, 5062) as string; }
+
+    /**
+     * Returns `true` if this {@link Thread} has been started. Once started, this will return `true` until it is joined using {@link waitToFinish}. For checking if a {@link Thread} is still executing its task, use {@link isAlive}.
+     */
+    isStarted(): boolean { return _C(this, 8337) as boolean; }
+
+    /**
+     * Returns `true` if this {@link Thread} is currently running the provided function. This is useful for determining if {@link waitToFinish} can be called without blocking the calling thread.
+     * To check if a {@link Thread} is joinable, use {@link isStarted}.
+     */
+    isAlive(): boolean { return _C(this, 7750) as boolean; }
+
+    /**
+     * Joins the {@link Thread} and waits for it to finish. Returns the output of the {@link Callable} passed to {@link start}.
+     * Should either be used when you want to retrieve the value returned from the method called by the {@link Thread} or before freeing the instance that contains the {@link Thread}.
+     * To determine if this can be called without blocking the calling thread, check if {@link isAlive} is `false`.
+     */
+    waitToFinish(): Variant { return _C(this, 14838) as Variant; }
+
+    /**
+     * Sets whether the thread safety checks the engine normally performs in methods of certain classes (e.g., {@link Node}) should happen **on the current thread**.
+     * The default, for every thread, is that they are enabled (as if called with `enabled` being `true`).
+     * Those checks are conservative. That means that they will only succeed in considering a call thread-safe (and therefore allow it to happen) if the engine can guarantee such safety.
+     * Because of that, there may be cases where the user may want to disable them (`enabled` being `false`) to make certain operations allowed again. By doing so, it becomes the user's responsibility to ensure thread safety (e.g., by using {@link Mutex}) for those objects that are otherwise protected by the engine.
+     * **Note:** This is an advanced usage of the engine. You are advised to use it only if you know what you are doing and there is no safer way.
+     * **Note:** This is useful for scripts running on either arbitrary {@link Thread} objects or tasks submitted to the {@link WorkerThreadPool}. It doesn't apply to code running during {@link Node} group processing, where the checks will be always performed.
+     * **Note:** Even in the case of having disabled the checks in a {@link WorkerThreadPool} task, there's no need to re-enable them at the end. The engine will do so.
+     */
+    static setThreadSafetyChecksEnabled(enabled: boolean): void { _C(792, 13057, enabled); }
+
+    /**
+     * Returns `true` if the thread this method was called from is the main thread.
+     * **Note:** This is a static method and isn't associated with a specific {@link Thread} object.
+     */
+    static isMainThread(): boolean { return _C(792, 8095) as boolean; }
+
+    static readonly name = _R(792, Thread);
+}
+
+export const Priority = {
+    /**
+     * A thread running with lower priority than normally.
+     */
+    PRIORITY_LOW: 0,
+    /**
+     * A thread with a standard priority.
+     */
+    PRIORITY_NORMAL: 1,
+    /**
+     * A thread running with higher priority than normally.
+     */
+    PRIORITY_HIGH: 2,
+} as const;
+
+export type Priority = (typeof Priority)[keyof typeof Priority];
+