@ringozz/godot 0.1.0

package/gen/classes/Resource.ts

@@ -0,0 +1,171 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { RID, Signal } from '../heap-types/index.ts';
+import type { Node } from './Node.ts';
+
+/**
+ * Resource is the base class for all Godot-specific resource types, serving primarily as data containers. Since they inherit from {@link RefCounted}, resources are reference-counted and freed when no longer in use. They can also be nested within other resources, and saved on disk. {@link PackedScene}, one of the most common {@link Object}s in a Godot project, is also a resource, uniquely capable of storing and instantiating the {@link Node}s it contains as many times as desired.
+ * In GDScript, resources can loaded from disk by their {@link resourcePath} using `@GDScript.load` or `@GDScript.preload`.
+ * The engine keeps a global cache of all loaded resources, referenced by paths (see {@link ResourceLoader.hasCached}). A resource will be cached when loaded for the first time and removed from cache once all references are released. When a resource is cached, subsequent loads using its path will return the cached reference.
+ * **Note:** In C#, resources will not be freed instantly after they are no longer in use. Instead, garbage collection will run periodically and will free resources that are no longer in use. This means that unused resources will remain in memory for a while before being removed.
+ */
+export class Resource extends RefCounted {
+    constructor(name = 659) { super(name); }
+
+    /**
+     * Sets the {@link resourcePath} 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.
+     */
+    takeOverPath(path: string): void { _C(this, 14115, path); }
+
+    /**
+     * 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}.
+     */
+    setPathCache(path: string): void { _C(this, 12273, path); }
+
+    /**
+     * 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}.
+     */
+    getRid(): RID { return _C(this, 6177) as RID; }
+
+    /**
+     * If {@link resourceLocalToScene} 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`.
+     */
+    getLocalScene(): Node | null { return _C(this, 5399) as Node | null; }
+
+    /**
+     * Calls {@link _setupLocalToScene}. If {@link resourceLocalToScene} is set to `true`, this method is automatically called from {@link PackedScene.instantiate} by the newly duplicated resource within the scene instance.
+     */
+    setupLocalToScene(): void { _C(this, 13416); }
+
+    /**
+     * Makes the resource clear its non-exported properties. See also {@link _resetState}. Useful when implementing a custom resource format by extending {@link ResourceFormatLoader} and {@link ResourceFormatSaver}.
+     */
+    resetState(): void { _C(this, 10075); }
+
+    /**
+     * 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.
+     */
+    setIdForPath(path: string, id: string): void { _C(this, 11655, path, id); }
+
+    /**
+     * 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.
+     */
+    getIdForPath(path: string): string { return _C(this, 5063, path) as string; }
+
+    /**
+     * Returns `true` if the resource is saved on disk as a part of another resource's file.
+     */
+    isBuiltIn(): boolean { return _C(this, 7804) as boolean; }
+
+    /**
+     * 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 resourceSceneUniqueId}.
+     */
+    static generateSceneUniqueId(): string { return _C(659, 3639) as string; }
+
+    /**
+     * 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.
+     *
+     * ```text
+     *
+     * var damage:
+     * 	set(new_value):
+     * 		if damage != new_value:
+     * 			damage = new_value
+     * 			emit_changed()
+     *
+     * ```
+     */
+    emitChanged(): void { _C(this, 3046); }
+
+    /**
+     * 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 duplicateDeep}.
+     * 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 /* = false */): Resource { return _C(this, 2980, deep) as Resource; }
+
+    /**
+     * Duplicates this resource, deeply, like {@link duplicate} when passing `true`, with extra control over how subresources are handled.
+     */
+    duplicateDeep(deepSubresourcesMode?: DeepDuplicateMode /* = 1 */): Resource { return _C(this, 2982, deepSubresourcesMode) as Resource; }
+
+    /**
+     * Copies the data from `resource` into this resource. Both resources must share the same class.
+     */
+    copyFromResource(resource: Resource): Error { return _C(this, 2489, resource) as Error; }
+
+    /**
+     * 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.
+     */
+    get resourceLocalToScene(): boolean { return _C(this, 8087) as boolean; }
+    set resourceLocalToScene(v: boolean) { _C(this, 11940, v); }
+
+    /**
+     * 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 takeOverPath}.
+     */
+    get resourcePath(): string { return _C(this, 5840) as string; }
+    set resourcePath(v: string) { _C(this, 12271, v); }
+
+    /**
+     * 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.
+     */
+    get resourceName(): string { return _C(this, 5602) as string; }
+    set resourceName(v: string) { _C(this, 12113, v); }
+
+    /**
+     * 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 generateSceneUniqueId}.
+     * **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.
+     */
+    get resourceSceneUniqueId(): string { return _C(this, 6256) as string; }
+    set resourceSceneUniqueId(v: string) { _C(this, 12625, v); }
+
+    /**
+     * Emitted when the resource changes, usually when one of its properties is modified. See also {@link emitChanged}.
+     * **Note:** This signal is not emitted automatically for properties of custom resources. If necessary, a setter needs to be created to emit the signal.
+     */
+    get changed(): Signal<() => void> { return _G(this, 2190) as Signal<() => void>; }
+    set changed(v: (() => void) | null) { _G(this, 2190, v); }
+
+    /**
+     * Emitted by a newly duplicated resource with {@link resourceLocalToScene} set to `true`.
+     */
+    get setupLocalToSceneRequested(): Signal<() => void> { return _G(this, 13417) as Signal<() => void>; }
+    set setupLocalToSceneRequested(v: (() => void) | null) { _G(this, 13417, v); }
+
+    static readonly name = _R(659, Resource);
+}
+
+export const 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.
+     */
+    DEEP_DUPLICATE_NONE: 0,
+    /**
+     * Only subresources without a path or with a scene-local path will be duplicated.
+     */
+    DEEP_DUPLICATE_INTERNAL: 1,
+    /**
+     * 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.
+     */
+    DEEP_DUPLICATE_ALL: 2,
+} as const;
+
+export type DeepDuplicateMode = (typeof DeepDuplicateMode)[keyof typeof DeepDuplicateMode];
+

package/gen/classes/ResourceFormatLoader.ts

@@ -0,0 +1,44 @@
+// 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 { GodotDictionary, PackedStringArray, StringName, Variant } from '../heap-types/index.ts';
+
+/**
+ * Godot loads resources in the editor or in exported games using ResourceFormatLoaders. They are queried automatically via the {@link ResourceLoader} singleton, or when a resource with internal dependencies is loaded. Each file type may load as a different resource type, so multiple ResourceFormatLoaders are registered in the engine.
+ * Extending this class allows you to define your own loader. Be sure to respect the documented return types and values. You should give it a global class name with `class_name` for it to be registered. Like built-in ResourceFormatLoaders, it will be called automatically when loading resources of its handled type(s). You may also implement a {@link ResourceFormatSaver}.
+ * **Note:** You can also extend {@link EditorImportPlugin} if the resource type you need exists but Godot is unable to load its format. Choosing one way over another depends on if the format is suitable or not for the final exported game. For example, it's better to import `.png` textures as `.ctex` ({@link CompressedTexture2D}) first, so they can be loaded with better efficiency on the graphics card.
+ */
+export class ResourceFormatLoader extends RefCounted {
+    constructor(name = 660) { super(name); }
+
+    static readonly name = _R(660, ResourceFormatLoader);
+}
+
+export const 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}.
+     */
+    CACHE_MODE_IGNORE: 0,
+    /**
+     * 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).
+     */
+    CACHE_MODE_REUSE: 1,
+    /**
+     * 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.
+     */
+    CACHE_MODE_REPLACE: 2,
+    /**
+     * Like {@link CACHE_MODE_IGNORE}, but propagated recursively down the tree of dependencies (external resources).
+     */
+    CACHE_MODE_IGNORE_DEEP: 3,
+    /**
+     * Like {@link CACHE_MODE_REPLACE}, but propagated recursively down the tree of dependencies (external resources).
+     */
+    CACHE_MODE_REPLACE_DEEP: 4,
+} as const;
+
+export type CacheMode = (typeof CacheMode)[keyof typeof CacheMode];
+

package/gen/classes/ResourceFormatSaver.ts

@@ -0,0 +1,18 @@
+// 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 { PackedStringArray } from '../heap-types/index.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * The engine can save resources when you do it from the editor, or when you use the {@link ResourceSaver} singleton. This is accomplished thanks to multiple {@link ResourceFormatSaver}s, each handling its own format and called automatically by the engine.
+ * By default, Godot saves resources as `.tres` (text-based), `.res` (binary) or another built-in format, but you can choose to create your own format by extending this class. Be sure to respect the documented return types and values. You should give it a global class name with `class_name` for it to be registered. Like built-in ResourceFormatSavers, it will be called automatically when saving resources of its recognized type(s). You may also implement a {@link ResourceFormatLoader}.
+ */
+export class ResourceFormatSaver extends RefCounted {
+    constructor(name = 661) { super(name); }
+
+    static readonly name = _R(661, ResourceFormatSaver);
+}

package/gen/classes/ResourceImporter.ts

@@ -0,0 +1,28 @@
+// 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 { PackedStringArray } from '../heap-types/index.ts';
+
+/**
+ * This is the base class for Godot's resource importers. To implement your own resource importers using editor plugins, see {@link EditorImportPlugin}.
+ */
+export class ResourceImporter extends RefCounted {
+
+    static readonly name = _R(662, ResourceImporter);
+}
+
+export const ImportOrder = {
+    /**
+     * The default import order.
+     */
+    IMPORT_ORDER_DEFAULT: 0,
+    /**
+     * 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.
+     */
+    IMPORT_ORDER_SCENE: 100,
+} as const;
+
+export type ImportOrder = (typeof ImportOrder)[keyof typeof ImportOrder];
+

package/gen/classes/ResourceLoader.ts

@@ -0,0 +1,178 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, PackedStringArray } from '../heap-types/index.ts';
+import type { Resource } from './Resource.ts';
+import type { ResourceFormatLoader } from './ResourceFormatLoader.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 663));
+
+/**
+ * A singleton used to load resource files from the filesystem.
+ * It uses the many {@link ResourceFormatLoader} classes registered in the engine (either built-in or from a plugin) to load files into memory and convert them to a format that can be used by the engine.
+ * **Note:** You have to import the files into the engine first to load them using {@link load}. If you want to load {@link Image}s at run-time, you may use {@link Image.load}. If you want to import audio files, you can use the snippet described in {@link AudioStreamMP3.data}.
+ * **Note:** Non-resource files such as plain text files cannot be read using {@link ResourceLoader}. Use {@link FileAccess} for those files instead, and be aware that non-resource files are not exported by default (see notes in the {@link FileAccess} class description for instructions on exporting them).
+ */
+export class ResourceLoader extends GodotVar {
+
+    /**
+     * Loads the resource using threads. If `useSubThreads` is `true`, multiple threads will be used to load the resource, which makes loading faster, but may affect the main thread (and thus cause game slowdowns).
+     * The `cacheMode` parameter defines whether and how the cache should be used or updated when loading the resource.
+     */
+    static loadThreadedRequest(path: string, typeHint?: string /* = "" */, useSubThreads?: boolean /* = false */, cacheMode?: CacheMode /* = 1 */): Error { return _C($(), 8691, path, typeHint, useSubThreads, cacheMode) as Error; }
+
+    /**
+     * Returns the status of a threaded loading operation started with {@link loadThreadedRequest} for the resource at `path`.
+     * An array variable can optionally be passed via `progress`, and will return a one-element array containing the ratio of completion of the threaded loading (between `0.0` and `1.0`).
+     * **Note:** The recommended way of using this method is to call it during different frames (e.g., in {@link Node.Process}, instead of a loop).
+     */
+    static loadThreadedGetStatus(path: string, progress?: GodotArray /* = [] */): ThreadLoadStatus { return _C($(), 8690, path, progress) as ThreadLoadStatus; }
+
+    /**
+     * Returns the resource loaded by {@link loadThreadedRequest}.
+     * If this is called before the loading thread is done (i.e. {@link loadThreadedGetStatus} is not {@link THREAD_LOAD_LOADED}), the calling thread will be blocked until the resource has finished loading. However, it's recommended to use {@link loadThreadedGetStatus} to known when the load has actually completed.
+     */
+    static loadThreadedGet(path: string): Resource { return _C($(), 8689, path) as Resource; }
+
+    /**
+     * Loads a resource at the given `path`, caching the result for further access.
+     * The registered {@link ResourceFormatLoader}s are queried sequentially to find the first one which can handle the file's extension, and then attempt loading. If loading fails, the remaining ResourceFormatLoaders are also attempted.
+     * An optional `typeHint` can be used to further specify the {@link Resource} type that should be handled by the {@link ResourceFormatLoader}. Anything that inherits from {@link Resource} can be used as a type hint, for example {@link Image}.
+     * The `cacheMode` property defines whether and how the cache should be used or updated when loading the resource.
+     * Returns an empty resource if no {@link ResourceFormatLoader} could handle the file, and prints an error if no file is found at the specified path.
+     * GDScript has a simplified `@GDScript.load` built-in method which can be used in most situations, leaving the use of {@link ResourceLoader} for more advanced scenarios.
+     * **Note:** If {@link ProjectSettings.editor/export/convertTextResourcesToBinary} is `true`, `@GDScript.load` will not be able to read converted files in an exported project. If you rely on run-time loading of files present within the PCK, set {@link ProjectSettings.editor/export/convertTextResourcesToBinary} to `false`.
+     * **Note:** Relative paths will be prefixed with `"res://"` before loading, to avoid unexpected results make sure your paths are absolute.
+     */
+    static load(path: string, typeHint?: string /* = "" */, cacheMode?: CacheMode /* = 1 */): Resource { return _C($(), 8665, path, typeHint, cacheMode) as Resource; }
+
+    /**
+     * Returns the list of recognized extensions for a resource type.
+     */
+    static getRecognizedExtensionsForType(type: string): PackedStringArray { return _C($(), 6090, type) as PackedStringArray; }
+
+    /**
+     * Registers a new {@link ResourceFormatLoader}. The ResourceLoader will use the ResourceFormatLoader as described in {@link load}.
+     * This method is performed implicitly for ResourceFormatLoaders written in GDScript (see {@link ResourceFormatLoader} for more information).
+     */
+    static addResourceFormatLoader(formatLoader: ResourceFormatLoader, atFront?: boolean /* = false */): void { _C($(), 1283, formatLoader, atFront); }
+
+    /**
+     * Unregisters the given {@link ResourceFormatLoader}.
+     */
+    static removeResourceFormatLoader(formatLoader: ResourceFormatLoader): void { _C($(), 9951, formatLoader); }
+
+    /**
+     * Changes the behavior on missing sub-resources. The default behavior is to abort loading.
+     */
+    static setAbortOnMissingResources(abort: boolean): void { _C($(), 10396, abort); }
+
+    /**
+     * Returns the dependencies for the resource at the given `path`.
+     * Each dependency is a string that can be divided into sections by `::`. There can be either one section or three sections, with the second section always being empty. When there is one section, it contains the file path. When there are three sections, the first section contains the UID and the third section contains the fallback path.
+     *
+     * ```text
+     *
+     * for dependency in ResourceLoader.get_dependencies(path):
+     * 	if dependency.contains("::"):
+     * 		print(dependency.get_slice("::", 0)) # Prints the UID.
+     * 		print(dependency.get_slice("::", 2)) # Prints the fallback path.
+     * 	else:
+     * 		print(dependency) # Prints the path.
+     *
+     * ```
+     */
+    static getDependencies(path: string): PackedStringArray { return _C($(), 4467, path) as PackedStringArray; }
+
+    /**
+     * Returns whether a cached resource is available for the given `path`.
+     * Once a resource has been loaded by the engine, it is cached in memory for faster access, and future calls to the {@link load} method will use the cached version. The cached resource can be overridden by using {@link Resource.takeOverPath} on a new resource for that same path.
+     */
+    static hasCached(path: string): boolean { return _C($(), 7371, path) as boolean; }
+
+    /**
+     * Returns the cached resource reference for the given `path`.
+     * **Note:** If the resource is not cached, the returned {@link Resource} will be invalid.
+     */
+    static getCachedRef(path: string): Resource { return _C($(), 4051, path) as Resource; }
+
+    /**
+     * Returns whether a recognized resource exists for the given `path`.
+     * An optional `typeHint` can be used to further specify the {@link Resource} type that should be handled by the {@link ResourceFormatLoader}. Anything that inherits from {@link Resource} can be used as a type hint, for example {@link Image}.
+     * **Note:** If you use {@link Resource.takeOverPath}, this method will return `true` for the taken path even if the resource wasn't saved (i.e. exists only in resource cache).
+     */
+    static exists(path: string, typeHint?: string /* = "" */): boolean { return _C($(), 3184, path, typeHint) as boolean; }
+
+    /**
+     * Returns the ID associated with a given resource path, or `-1` when no such ID exists.
+     */
+    static getResourceUid(path: string): number { return _C($(), 6163, path) as number; }
+
+    /**
+     * Lists a directory, returning all resources and subdirectories contained within. The resource files have the original file names as visible in the editor before exporting. The directories have `"/"` appended.
+     *
+     * ```text
+     *
+     * # Prints ["extra_data/", "model.gltf", "model.tscn", "model_slime.png"]
+     * print(ResourceLoader.list_directory("res://assets/enemies/slime"))
+     *
+     * ```
+     *
+     * **Note:** The order of files and directories returned by this method is not deterministic, and can vary between operating systems.
+     * **Note:** To normally traverse the filesystem, see {@link DirAccess}.
+     */
+    static listDirectory(directoryPath: string): PackedStringArray { return _C($(), 8663, directoryPath) as PackedStringArray; }
+
+    static readonly name = _R(663, ResourceLoader);
+}
+
+export const ThreadLoadStatus = {
+    /**
+     * The resource is invalid, or has not been loaded with {@link loadThreadedRequest}.
+     */
+    THREAD_LOAD_INVALID_RESOURCE: 0,
+    /**
+     * The resource is still being loaded.
+     */
+    THREAD_LOAD_IN_PROGRESS: 1,
+    /**
+     * Some error occurred during loading and it failed.
+     */
+    THREAD_LOAD_FAILED: 2,
+    /**
+     * The resource was loaded successfully and can be accessed via {@link loadThreadedGet}.
+     */
+    THREAD_LOAD_LOADED: 3,
+} as const;
+
+export type ThreadLoadStatus = (typeof ThreadLoadStatus)[keyof typeof ThreadLoadStatus];
+
+export const 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}.
+     */
+    CACHE_MODE_IGNORE: 0,
+    /**
+     * 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).
+     */
+    CACHE_MODE_REUSE: 1,
+    /**
+     * 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.
+     */
+    CACHE_MODE_REPLACE: 2,
+    /**
+     * Like {@link CACHE_MODE_IGNORE}, but propagated recursively down the tree of dependencies (external resources).
+     */
+    CACHE_MODE_IGNORE_DEEP: 3,
+    /**
+     * Like {@link CACHE_MODE_REPLACE}, but propagated recursively down the tree of dependencies (external resources).
+     */
+    CACHE_MODE_REPLACE_DEEP: 4,
+} as const;
+
+export type CacheMode = (typeof CacheMode)[keyof typeof CacheMode];
+

package/gen/classes/ResourcePreloader.ts

@@ -0,0 +1,50 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+import type { GodotArray, PackedStringArray, StringName } from '../heap-types/index.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * This node is used to preload sub-resources inside a scene, so when the scene is loaded, all the resources are ready to use and can be retrieved from the preloader. You can add the resources using the ResourcePreloader tab when the node is selected.
+ * GDScript has a simplified `@GDScript.preload` built-in method which can be used in most situations, leaving the use of {@link ResourcePreloader} for more advanced scenarios.
+ */
+export class ResourcePreloader extends Node {
+    constructor(name = 664) { super(name); }
+
+    /**
+     * Adds a resource to the preloader with the given `name`. If a resource with the given `name` already exists, the new resource will be renamed to "`name` N" where N is an incrementing number starting from 2.
+     */
+    addResource(name: StringName, resource: Resource): void { _C(this, 1282, name, resource); }
+
+    /**
+     * Removes the resource associated to `name` from the preloader.
+     */
+    removeResource(name: StringName): void { _C(this, 9950, name); }
+
+    /**
+     * Renames a resource inside the preloader from `name` to `newname`.
+     */
+    renameResource(name: StringName, newname: StringName): void { _C(this, 10001, name, newname); }
+
+    /**
+     * Returns `true` if the preloader contains a resource associated to `name`.
+     */
+    hasResource(name: StringName): boolean { return _C(this, 7435, name) as boolean; }
+
+    /**
+     * Returns the resource associated to `name`.
+     */
+    getResource(name: StringName): Resource { return _C(this, 6160, name) as Resource; }
+
+    /**
+     * Returns the list of resources inside the preloader.
+     */
+    getResourceList(): PackedStringArray { return _C(this, 6162) as PackedStringArray; }
+
+    get resources(): GodotArray { return _C(this, 1012) as GodotArray; }
+    set resources(v: GodotArray) { _C(this, 1042, v); }
+
+    static readonly name = _R(664, ResourcePreloader);
+}

package/gen/classes/ResourceSaver.ts

@@ -0,0 +1,94 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedStringArray } from '../heap-types/index.ts';
+import type { Resource } from './Resource.ts';
+import type { ResourceFormatSaver } from './ResourceFormatSaver.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 665));
+
+/**
+ * A singleton for saving resource types to the filesystem.
+ * It uses the many {@link ResourceFormatSaver} classes registered in the engine (either built-in or from a plugin) to save resource data to text-based (e.g. `.tres` or `.tscn`) or binary files (e.g. `.res` or `.scn`).
+ */
+export class ResourceSaver extends GodotVar {
+
+    /**
+     * Saves a resource to disk to the given path, using a {@link ResourceFormatSaver} that recognizes the resource object. If `path` is empty, {@link ResourceSaver} will try to use {@link Resource.resourcePath}.
+     * The `flags` bitmask can be specified to customize the save behavior.
+     * Returns {@link OK} on success.
+     * **Note:** When the project is running, any generated UID associated with the resource will not be saved as the required code is only executed in editor mode.
+     */
+    static save(resource: Resource, path?: string /* = "" */, flags?: SaverFlags /* = 0 */): Error { return _C($(), 10195, resource, path, flags) as Error; }
+
+    /**
+     * Sets the UID of the given `resource` path to `uid`. You can generate a new UID using {@link ResourceUID.createId}.
+     * Since resources will normally get a UID automatically, this method is only useful in very specific cases.
+     */
+    static setUid(resource: string, uid: number /* int64 */): Error { return _C($(), 13166, resource, uid) as Error; }
+
+    /**
+     * Returns the list of extensions available for saving a resource of a given type.
+     */
+    static getRecognizedExtensions(type: Resource): PackedStringArray { return _C($(), 6089, type) as PackedStringArray; }
+
+    /**
+     * Registers a new {@link ResourceFormatSaver}. The ResourceSaver will use the ResourceFormatSaver as described in {@link save}.
+     * This method is performed implicitly for ResourceFormatSavers written in GDScript (see {@link ResourceFormatSaver} for more information).
+     */
+    static addResourceFormatSaver(formatSaver: ResourceFormatSaver, atFront?: boolean /* = false */): void { _C($(), 1284, formatSaver, atFront); }
+
+    /**
+     * Unregisters the given {@link ResourceFormatSaver}.
+     */
+    static removeResourceFormatSaver(formatSaver: ResourceFormatSaver): void { _C($(), 9952, formatSaver); }
+
+    /**
+     * Returns the resource ID for the given path. If `generate` is `true`, a new resource ID will be generated if one for the path is not found. If `generate` is `false` and the path is not found, {@link ResourceUID.INVALID_ID} is returned.
+     */
+    static getResourceIdForPath(path: string, generate?: boolean /* = false */): number { return _C($(), 6161, path, generate) as number; }
+
+    static readonly name = _R(665, ResourceSaver);
+}
+
+export const SaverFlags = {
+    /**
+     * No resource saving option.
+     */
+    FLAG_NONE: 0,
+    /**
+     * Save the resource with a path relative to the scene which uses it.
+     */
+    FLAG_RELATIVE_PATHS: 1,
+    /**
+     * Bundles external resources.
+     */
+    FLAG_BUNDLE_RESOURCES: 2,
+    /**
+     * Changes the {@link Resource.resourcePath} of the saved resource to match its new location.
+     */
+    FLAG_CHANGE_PATH: 4,
+    /**
+     * Do not save editor-specific metadata (identified by their `__editor` prefix).
+     */
+    FLAG_OMIT_EDITOR_PROPERTIES: 8,
+    /**
+     * Save as big endian (see {@link FileAccess.bigEndian}).
+     */
+    FLAG_SAVE_BIG_ENDIAN: 16,
+    /**
+     * Compress the resource on save using {@link FileAccess.COMPRESSION_ZSTD}. Only available for binary resource types.
+     */
+    FLAG_COMPRESS: 32,
+    /**
+     * Take over the paths of the saved subresources (see {@link Resource.takeOverPath}).
+     */
+    FLAG_REPLACE_SUBRESOURCE_PATHS: 64,
+} as const;
+
+export type SaverFlags = (typeof SaverFlags)[keyof typeof SaverFlags];
+