@defold-typescript/types 0.19.4 → 0.20.1

package/generated/versions/defold-1.12.4/html5.d.ts

@@ -0,0 +1,53 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * HTML5 platform specific functions.
+   *
+   * [icon:html5] The following functions are only available on HTML5 builds, the `html5.*` Lua namespace will not be available on other platforms.
+   */
+  namespace html5 {
+    /**
+     * Executes the supplied string as JavaScript inside the browser.
+     * A call to this function is blocking, the result is returned as-is, as a string.
+     * (Internally this will execute the string using the `eval()` JavaScript function.)
+     *
+     * @param code - Javascript code to run
+     * @returns result as string
+     * @example
+     * ```ts
+     * const res = html5.run("10 + 20"); // returns the string "30"
+     * print(res);
+     * const res_num = tonumber(res); // convert to number
+     * print(res_num - 20); // prints 10
+     * ```
+     */
+    function run(code: string): string;
+    /**
+     * Set a JavaScript interaction listener callaback from lua that will be
+     * invoked when a user interacts with the web page by clicking, touching or typing.
+     * The callback can then call DOM restricted actions like requesting a pointer lock,
+     * or start playing sounds the first time the callback is invoked.
+     *
+     * @param callback - The interaction callback. Pass an empty function or `nil` if you no longer wish to receive callbacks.
+     *
+     * `self`
+     * object The calling script
+     * @example
+     * ```ts
+     * function on_interaction(self) {
+     *   print("on_interaction called");
+     *   html5.set_interaction_listener(undefined);
+     * }
+     *
+     * export default defineScript({
+     *   init() {
+     *     html5.set_interaction_listener(on_interaction);
+     *   },
+     * });
+     * ```
+     */
+    function set_interaction_listener(callback?: (self: unknown) => void): void;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/http.d.ts

@@ -0,0 +1,84 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Functions for performing HTTP and HTTPS requests.
+   */
+  namespace http {
+    /**
+     * Perform a HTTP/HTTPS request.
+     * If no timeout value is passed, the configuration value "network.http_timeout" is used. If that is not set, the timeout value is `0` (which blocks indefinitely).
+     *
+     * @param url - target url
+     * @param method - HTTP/HTTPS method, e.g. "GET", "PUT", "POST" etc.
+     * @param callback - response callback function
+     *
+     * `self`
+     * object The script instance
+     * `id`
+     * hash Internal message identifier. Do not use!
+     * `response`
+     * table The response data. Contains the fields:
+     *
+     * - number `status`: the status of the response
+     *
+     * - string `response`: the response data (if not saved on disc)
+     *
+     * - table `headers`: all the returned headers (if status is 200 or 206)
+     *
+     * - string `path`: the stored path (if saved to disc)
+     *
+     * - string `error`: if any unforeseen errors occurred (e.g. file I/O)
+     *
+     * - number `bytes_received`: the amount of bytes received/sent for a request, only if option `report_progress` is true
+     *
+     * - number `bytes_total`: the total amount of bytes for a request, only if option `report_progress` is true
+     *
+     * - number `range_start`: the start offset into the requested file
+     *
+     * - number `range_end`: the end offset into the requested file (inclusive)
+     *
+     * - number `document_size`: the full size of the requested file
+     * @param headers - optional table with custom headers
+     * @param post_data - optional data to send
+     * @param options - optional table with request parameters. Supported entries:
+     *
+     * - number `timeout`: timeout in seconds
+     *
+     * - string `path`: path on disc where to download the file. Only overwrites the path if status is 200. Path should be absolute
+     *
+     * - boolean `ignore_cache`: don't return cached data if we get a 304. Not available in HTML5 build
+     *
+     * - boolean `chunked_transfer`: use chunked transfer encoding for https requests larger than 16kb. Defaults to true. Not available in HTML5 build
+     *
+     * - boolean `report_progress`: when it is true, the amount of bytes sent and/or received for a request will be passed into the callback function
+     * @example
+     * ```ts
+     * // Basic HTTP-GET request. The callback receives a table with the response
+     * // in the fields status, the response (the data) and headers (a table).
+     * export default defineScript({
+     *   init() {
+     *     http.request(
+     *       "http://www.google.com",
+     *       "GET",
+     *       (self, _id, response) => {
+     *         if (response.bytes_total !== undefined) {
+     *           update_my_progress_bar(self, response.bytes_received / response.bytes_total);
+     *         } else {
+     *           print(response.status);
+     *           print(response.response);
+     *           pprint(response.headers);
+     *         }
+     *       },
+     *       undefined,
+     *       undefined,
+     *       { report_progress: true },
+     *     );
+     *   },
+     * });
+     * ```
+     */
+    function request(url: string, method: string, callback: (self: unknown, id: unknown, response: unknown) => void, headers?: LuaMap<string, string>, post_data?: string, options?: { timeout?: number; path?: string; ignore_cache?: boolean; chunked_transfer?: boolean; report_progress?: boolean }): void;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/iac.d.ts

@@ -0,0 +1,18 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Functions and constants for doing inter-app communication. Supported on iOS and Android. [icon:ios] [icon:android]
+   */
+  namespace iac {
+    /**
+     * Sets the listener function for inter-app communication events.
+     *
+     * @param payload - The iac payload.
+     * @param type - The type of iac, an iac.TYPE_ enumeration. It can be one of the predefined constants below
+     * - `iac.TYPE_INVOCATION`
+     */
+    function set_listener(payload: Record<string | number, unknown>, type: number): void;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/iap.d.ts

@@ -0,0 +1,60 @@
+/** @noSelfInFile */
+import type { Opaque } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions and constants for doing in-app purchases. Supported on iOS, Android (Google Play and Amazon) and Facebook Canvas platforms. [icon:ios] [icon:googleplay] [icon:amazon] [icon:facebook]
+   */
+  namespace iap {
+    /**
+     * Acknowledge a transaction. [icon:attention] Calling iap.acknowledge is required on a successful transaction on Google Play unless iap.finish is called. The transaction.state field must equal iap.TRANS_STATE_PURCHASED.
+     *
+     * @param transaction - transaction table parameter as supplied in listener callback
+     */
+    function acknowledge(transaction: { ident?: string; state?: number; trans_ident?: string; date?: string; original_trans?: string; receipt?: string; signature?: string; user_id?: string }): void;
+    /**
+     * Purchase a product.
+     *
+     * @param id - product to buy
+     * @param options - optional parameters as properties. The following parameters can be set
+     */
+    function buy(id: string, options: { request_id?: string; token?: string }): void;
+    /**
+     * Explicitly finish a product transaction. [icon:attention] Calling iap.finish is required on a successful transaction if `auto_finish_transactions` is disabled in project settings. Calling this function with `auto_finish_transactions` set will be ignored and a warning is printed. The `transaction.state` field must equal `iap.TRANS_STATE_PURCHASED`.
+     *
+     * @param transaction - transaction table parameter as supplied in listener callback
+     */
+    function finish(transaction: { ident?: string; state?: number; trans_ident?: string; date?: string; original_trans?: string; receipt?: string; signature?: string; user_id?: string }): void;
+    /**
+     * Get current iap provider
+     *
+     * @returns one of the following values
+     * - `iap.PROVIDER_ID_GOOGLE`
+     * - `iap.PROVIDER_ID_AMAZON`
+     * - `iap.PROVIDER_ID_APPLE`
+     * - `iap.PROVIDER_ID_FACEBOOK`
+     */
+    function get_provider_id(): Opaque<"constant">;
+    /**
+     * Get a list of all avaliable iap products.
+     *
+     * @param ids - table (array) of identifiers to get products from
+     * @param callback - result callback taking the following parameters
+     */
+    function list(ids: string[], callback: (...args: unknown[]) => unknown): void;
+    /**
+     * Restore previously purchased products.
+     *
+     * @returns value is `true` if current store supports handling restored transactions, otherwise `false`.
+     */
+    function restore(): boolean;
+    /**
+     * Set the callback function to receive purchase transaction events.
+     *
+     * @param listener - listener callback function. Pass an empty function if you no longer wish to receive callbacks.
+     */
+    function set_listener(listener: (...args: unknown[]) => unknown): void;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/image.d.ts

@@ -0,0 +1,139 @@
+/** @noSelfInFile */
+import type { Opaque } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for creating image objects.
+   */
+  namespace image {
+    /**
+     * luminance image type
+     */
+    const TYPE_LUMINANCE: number & { readonly __brand: "image.TYPE_LUMINANCE" };
+    /**
+     * luminance image type
+     */
+    const TYPE_LUMINANCE_ALPHA: number & { readonly __brand: "image.TYPE_LUMINANCE_ALPHA" };
+    /**
+     * RGB image type
+     */
+    const TYPE_RGB: number & { readonly __brand: "image.TYPE_RGB" };
+    /**
+     * RGBA image type
+     */
+    const TYPE_RGBA: number & { readonly __brand: "image.TYPE_RGBA" };
+    /**
+     * get the header of an .astc buffer
+     *
+     * @param buffer - .astc file data buffer
+     * @returns header or `nil` if buffer is not a valid .astc. The header has these fields:
+     *
+     * - number `width`: image width
+     *
+     * - number `height`: image height
+     *
+     * - number `depth`: image depth
+     *
+     * - number `block_size_x`: block size x
+     *
+     * - number `block_size_y`: block size y
+     *
+     * - number `block_size_z`: block size z
+     * @example
+     * ```ts
+     * // How to get the block size and dimensions from a .astc file
+     * const [s] = sys.load_resource("/assets/cat.astc");
+     * const header = image.get_astc_header(s);
+     * pprint(s);
+     * ```
+     */
+    function get_astc_header(buffer: string): { width: number; height: number; depth: number; block_size_x: number; block_size_y: number; block_size_z: number } | undefined;
+    /**
+     * Load image (PNG or JPEG) from buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - An optional table containing parameters for loading the image. Supported entries:
+     *
+     * `premultiply_alpha`
+     * boolean True if alpha should be premultiplied into the color components. Defaults to `false`.
+     * `flip_vertically`
+     * boolean True if the image contents should be flipped vertically. Defaults to `false`.
+     * @returns object or `nil` if loading fails. The object is a table with the following fields:
+     *
+     * - number `width`: image width
+     *
+     * - number `height`: image height
+     *
+     * - constant `type`: image type
+     *
+     * - `image.TYPE_RGB`
+     *
+     * - `image.TYPE_RGBA`
+     *
+     * - `image.TYPE_LUMINANCE`
+     *
+     * - `image.TYPE_LUMINANCE_ALPHA`
+     *
+     * - string `buffer`: the raw image data
+     * @example
+     * ```ts
+     * // How to load an image from an URL and create a GUI texture from it:
+     * const imgurl = "http://www.site.com/image.png";
+     * http.request(imgurl, "GET", (self, id, response) => {
+     *   const img = image.load(response.response);
+     *   const tx = gui.new_texture("image_node", img.width, img.height, img.type, img.buffer);
+     * });
+     * ```
+     */
+    function load(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: string } | undefined;
+    /**
+     * Load image (PNG or JPEG) from a string buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - An optional table containing parameters for loading the image. Supported entries:
+     *
+     * `premultiply_alpha`
+     * boolean True if alpha should be premultiplied into the color components. Defaults to `false`.
+     * `flip_vertically`
+     * boolean True if the image contents should be flipped vertically. Defaults to `false`.
+     * @returns object or `nil` if loading fails. The object is a table with the following fields:
+     *
+     * - number `width`: image width
+     *
+     * - number `height`: image height
+     *
+     * - constant `type`: image type
+     *
+     * - `image.TYPE_RGB`
+     *
+     * - `image.TYPE_RGBA`
+     *
+     * - `image.TYPE_LUMINANCE`
+     *
+     * - `image.TYPE_LUMINANCE_ALPHA`
+     *
+     * - buffer `buffer`: the script buffer that holds the decompressed image data. See buffer.create how to use the buffer.
+     * @example
+     * ```ts
+     * // Load an image from an URL as a buffer and create a texture resource from it:
+     * const imgurl = "http://www.site.com/image.png";
+     * http.request(imgurl, "GET", (self, id, response) => {
+     *   const img = image.load_buffer(response.response, { flip_vertically: true });
+     *   const tparams = {
+     *     width: img.width,
+     *     height: img.height,
+     *     type: graphics.TEXTURE_TYPE_2D,
+     *     format: graphics.TEXTURE_FORMAT_RGBA,
+     *   };
+     *
+     *   const my_texture_id = resource.create_texture("/my_custom_texture.texturec", tparams, img.buffer);
+     *   // Apply the texture to a model
+     *   go.set("/go1#model", "texture0", my_texture_id);
+     * });
+     * ```
+     */
+    function load_buffer(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: Opaque<"buffer"> } | undefined;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/index.d.ts

@@ -0,0 +1,41 @@
+import "./b2d";
+import "./b2d_body";
+import "./buffer";
+import "./camera";
+import "./collectionfactory";
+import "./collectionproxy";
+import "./crash";
+import "./factory";
+import "./font";
+import "./go";
+import "./graphics";
+import "./gui";
+import "./html5";
+import "./http";
+import "./iac";
+import "./iap";
+import "./image";
+import "./json";
+import "./label";
+import "./liveupdate";
+import "./model";
+import "./msg";
+import "./particlefx";
+import "./physics";
+import "./profiler";
+import "./push";
+import "./render";
+import "./resource";
+import "./socket";
+import "./sound";
+import "./sprite";
+import "./sys";
+import "./tilemap";
+import "./timer";
+import "./types";
+import "./vmath";
+import "./webview";
+import "./window";
+import "./zlib";
+
+export {};

package/generated/versions/defold-1.12.4/json.d.ts

@@ -0,0 +1,76 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Manipulation of JSON data strings.
+   */
+  namespace json {
+    /**
+     * Represents the null primitive from a json file
+     */
+    const _null: unknown;
+    /**
+     * Decode a string of JSON data into a Lua table.
+     * A Lua error is raised for syntax errors.
+     *
+     * @param json - json data
+     * @param options - table with decode options
+     *
+     * - boolean `decode_null_as_userdata`: wether to decode a JSON null value as json.null or nil (default is nil)
+     * @returns decoded json
+     * @example
+     * ```ts
+     * // Converting a string containing JSON data into a table:
+     * export default defineScript({
+     *   init() {
+     *     const jsonstring = '{"persons":[{"name":"John Doe"},{"name":"Darth Vader"}]}';
+     *     const data = json.decode(jsonstring);
+     *     pprint(data);
+     *   },
+     * });
+     *
+     * // Results in the following printout:
+     * // {
+     * //   persons = {
+     * //     1 = {
+     * //       name = John Doe,
+     * //     }
+     * //     2 = {
+     * //       name = Darth Vader,
+     * //     }
+     * //   }
+     * // }
+     * ```
+     */
+    export function decode(json: string, options?: { decode_null_as_userdata?: boolean }): Record<string | number, unknown>;
+    /**
+     * Encode a lua table to a JSON string.
+     * A Lua error is raised for syntax errors.
+     *
+     * @param tbl - lua table to encode
+     * @param options - table with encode options
+     *
+     * - string `encode_empty_table_as_object`: wether to encode an empty table as an JSON object or array (default is object)
+     * @returns encoded json
+     * @example
+     * ```ts
+     * // Convert a table to a JSON string:
+     * export default defineScript({
+     *   init() {
+     *     const tbl = {
+     *       persons: [{ name: "John Doe" }, { name: "Darth Vader" }],
+     *     };
+     *     const jsonstring = json.encode(tbl);
+     *     pprint(jsonstring);
+     *   },
+     * });
+     *
+     * // Results in the following printout:
+     * // {"persons":[{"name":"John Doe"},{"name":"Darth Vader"}]}
+     * ```
+     */
+    export function encode(tbl: Record<string | number, unknown>, options?: { encode_empty_table_as_object?: string }): string;
+    export { _null as null };
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/label.d.ts

@@ -0,0 +1,94 @@
+/** @noSelfInFile */
+import type { Hash, Url, Vector3, Vector4 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions to manipulate a label component.
+   */
+  namespace label {
+    /**
+     * Gets the text from a label component
+     *
+     * @param url - the label to get the text from
+     * @returns the label text
+     * @example
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     const text = label.get_text("#label");
+     *     print(text);
+     *   },
+     * });
+     * ```
+     */
+    function get_text(url: string | Hash | Url): string;
+    /**
+     * Sets the text of a label component
+     * This method uses the message passing that means the value will be set after `dispatch messages` step.
+     * More information is available in the Application Lifecycle manual.
+     *
+     * @param url - the label that should have a constant set
+     * @param text - the text
+     * @example
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     label.set_text("#label", "Hello World!");
+     *   },
+     * });
+     * ```
+     */
+    function set_text(url: string | Hash | Url, text: string | number): void;
+    interface properties {
+      /**
+       * The color of the label. The type of the property is vector4.
+       */
+      color: Vector4;
+      /**
+       * The font used when rendering the label. The type of the property is hash.
+       */
+      font: Hash;
+      /**
+       * The leading of the label. This value is used to scale the line spacing of text.
+       * The type of the property is number.
+       */
+      leading: number;
+      /**
+       * The line break of the label.
+       * This value is used to adjust the vertical spacing of characters in the text.
+       * The type of the property is boolean.
+       */
+      line_break: boolean;
+      /**
+       * The material used when rendering the label. The type of the property is hash.
+       */
+      material: Hash;
+      /**
+       * The outline color of the label. The type of the property is vector4.
+       */
+      outline: Vector4;
+      /**
+       * The scale of the label. The type of the property is number (uniform)
+       * or vector3 (non uniform).
+       */
+      scale: number | Vector3;
+      /**
+       * The shadow color of the label. The type of the property is vector4.
+       */
+      shadow: Vector4;
+      /**
+       * Returns the size of the label. The size will constrain the text if line break is enabled.
+       * The type of the property is vector3.
+       */
+      size: Vector3;
+      /**
+       * The tracking of the label.
+       * This value is used to adjust the vertical spacing of characters in the text.
+       * The type of the property is number.
+       */
+      tracking: number;
+    }
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/liveupdate.d.ts

@@ -0,0 +1,122 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Functions and constants to access resources.
+   */
+  namespace liveupdate {
+    /**
+     * Mismatch between between expected bundled resources and actual bundled resources. The manifest expects a resource to be in the bundle, but it was not found in the bundle. This is typically the case when a non-excluded resource was modified between publishing the bundle and publishing the manifest.
+     */
+    const LIVEUPDATE_BUNDLED_RESOURCE_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_BUNDLED_RESOURCE_MISMATCH" };
+    /**
+     * Mismatch between running engine version and engine versions supported by manifest.
+     */
+    const LIVEUPDATE_ENGINE_VERSION_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_ENGINE_VERSION_MISMATCH" };
+    /**
+     * Failed to parse manifest data buffer. The manifest was probably produced by a different engine version.
+     */
+    const LIVEUPDATE_FORMAT_ERROR: number & { readonly __brand: "liveupdate.LIVEUPDATE_FORMAT_ERROR" };
+    /**
+     * Argument was invalid
+     */
+    const LIVEUPDATE_INVAL: number & { readonly __brand: "liveupdate.LIVEUPDATE_INVAL" };
+    /**
+     * The handled resource is invalid.
+     */
+    const LIVEUPDATE_INVALID_HEADER: number & { readonly __brand: "liveupdate.LIVEUPDATE_INVALID_HEADER" };
+    /**
+     * The header of the resource is invalid.
+     */
+    const LIVEUPDATE_INVALID_RESOURCE: number & { readonly __brand: "liveupdate.LIVEUPDATE_INVALID_RESOURCE" };
+    /**
+     * I/O operation failed
+     */
+    const LIVEUPDATE_IO_ERROR: number & { readonly __brand: "liveupdate.LIVEUPDATE_IO_ERROR" };
+    /**
+     * Memory wasn't allocated
+     */
+    const LIVEUPDATE_MEM_ERROR: number & { readonly __brand: "liveupdate.LIVEUPDATE_MEM_ERROR" };
+    /**
+     * LIVEUPDATE_OK
+     */
+    const LIVEUPDATE_OK: number & { readonly __brand: "liveupdate.LIVEUPDATE_OK" };
+    /**
+     * Mismatch between scheme used to load resources. Resources are loaded with a different scheme than from manifest, for example over HTTP or directly from file. This is typically the case when running the game directly from the editor instead of from a bundle.
+     */
+    const LIVEUPDATE_SCHEME_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_SCHEME_MISMATCH" };
+    /**
+     * Mismatch between expected and actual integrity data for legacy liveupdate verification.
+     */
+    const LIVEUPDATE_SIGNATURE_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_SIGNATURE_MISMATCH" };
+    /**
+     * Unspecified error
+     */
+    const LIVEUPDATE_UNKNOWN: number & { readonly __brand: "liveupdate.LIVEUPDATE_UNKNOWN" };
+    /**
+     * Mismatch between manifest expected version and actual version.
+     */
+    const LIVEUPDATE_VERSION_MISMATCH: number & { readonly __brand: "liveupdate.LIVEUPDATE_VERSION_MISMATCH" };
+    /**
+     * Adds a resource mount to the resource system.
+     * The mounts are persisted between sessions.
+     * After the mount succeeded, the resources are available to load. (i.e. no reboot required)
+     *
+     * @param name - Unique name of the mount
+     * @param uri - The uri of the mount, including the scheme. Currently supported schemes are 'zip' and 'archive'.
+     * @param priority - Priority of mount. Larger priority takes prescedence
+     * @param callback - Callback after the asynchronous request completed
+     * @returns The result of the request
+     * @example
+     * ```lua
+     * Add multiple mounts. Higher priority takes precedence.
+     * liveupdate.add_mount("common", "zip:/path/to/common_stuff.zip", 10, function (result) end) -- base pack
+     * liveupdate.add_mount("levelpack_1", "zip:/path/to/levels_1_to_20.zip", 20, function (result) end) -- level pack
+     * liveupdate.add_mount("season_pack_1", "zip:/path/to/easter_pack_1.zip", 30, function (result) end) -- season pack, overriding content in the other packs
+     * ```
+     */
+    function add_mount(name: string, uri: string, priority: number, callback: (...args: unknown[]) => unknown): number;
+    /**
+     * Get an array of the current mounts
+     * This can be used to determine if a new mount is needed or not
+     *
+     * @returns Array of mounts
+     * @example
+     * ```lua
+     * Output the current resource mounts
+     * pprint("MOUNTS", liveupdate.get_mounts())
+     *
+     * Give an output like:
+     * DEBUG:SCRIPT: MOUNTS,
+     * { --[[0x119667bf0]]
+     *   1 = { --[[0x119667c50]]
+     *     name = "liveupdate",
+     *     uri = "zip:/device/path/to/acchives/liveupdate.zip",
+     *     priority = 5
+     *   },
+     *   2 = { --[[0x119667d50]]
+     *     name = "_base",
+     *     uri = "archive:build/default/game.dmanifest",
+     *     priority = -10
+     *   }
+     * }
+     * ```
+     */
+    function get_mounts(): { name: string; uri: string; priority: number }[];
+    /**
+     * Remove a mount the resource system.
+     * The remaining mounts are persisted between sessions.
+     * Removing a mount does not affect any loaded resources.
+     *
+     * @param name - Unique name of the mount
+     * @returns The result of the call
+     * @example
+     * ```ts
+     * // Add multiple mounts. Higher priority takes precedence.
+     * liveupdate.remove_mount("season_pack_1");
+     * ```
+     */
+    function remove_mount(name: string): number;
+  }
+}
+
+export {};