@defold-typescript/types 0.49.0 → 0.50.0

package/generated/versions/defold-1.13.2/crash.d.ts

@@ -0,0 +1,157 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Native crash logging functions and constants.
+   */
+  namespace crash {
+    /**
+     * Loaded crash module
+     */
+    interface module_info {
+      /**
+       * module name
+       */
+      name: string;
+      /**
+       * module load address
+       */
+      address: string;
+    }
+    type USERFIELD = number;
+    type SYSFIELD = typeof crash.SYSFIELD_ENGINE_VERSION | typeof crash.SYSFIELD_ENGINE_HASH | typeof crash.SYSFIELD_DEVICE_MODEL | typeof crash.SYSFIELD_MANUFACTURER | typeof crash.SYSFIELD_SYSTEM_NAME | typeof crash.SYSFIELD_SYSTEM_VERSION | typeof crash.SYSFIELD_LANGUAGE | typeof crash.SYSFIELD_DEVICE_LANGUAGE | typeof crash.SYSFIELD_TERRITORY | typeof crash.SYSFIELD_ANDROID_BUILD_FINGERPRINT;
+    /**
+     * android build fingerprint
+     */
+    const SYSFIELD_ANDROID_BUILD_FINGERPRINT: number & { readonly __brand: "crash.SYSFIELD_ANDROID_BUILD_FINGERPRINT" };
+    /**
+     * system device language as reported by sys.get_sys_info
+     */
+    const SYSFIELD_DEVICE_LANGUAGE: number & { readonly __brand: "crash.SYSFIELD_DEVICE_LANGUAGE" };
+    /**
+     * device model as reported by sys.get_sys_info
+     */
+    const SYSFIELD_DEVICE_MODEL: number & { readonly __brand: "crash.SYSFIELD_DEVICE_MODEL" };
+    /**
+     * engine version as hash
+     */
+    const SYSFIELD_ENGINE_HASH: number & { readonly __brand: "crash.SYSFIELD_ENGINE_HASH" };
+    /**
+     * engine version as release number
+     */
+    const SYSFIELD_ENGINE_VERSION: number & { readonly __brand: "crash.SYSFIELD_ENGINE_VERSION" };
+    /**
+     * system language as reported by sys.get_sys_info
+     */
+    const SYSFIELD_LANGUAGE: number & { readonly __brand: "crash.SYSFIELD_LANGUAGE" };
+    /**
+     * device manufacturer as reported by sys.get_sys_info
+     */
+    const SYSFIELD_MANUFACTURER: number & { readonly __brand: "crash.SYSFIELD_MANUFACTURER" };
+    /**
+     * The max number of sysfields.
+     */
+    const SYSFIELD_MAX: number & { readonly __brand: "crash.SYSFIELD_MAX" };
+    /**
+     * system name as reported by sys.get_sys_info
+     */
+    const SYSFIELD_SYSTEM_NAME: number & { readonly __brand: "crash.SYSFIELD_SYSTEM_NAME" };
+    /**
+     * system version as reported by sys.get_sys_info
+     */
+    const SYSFIELD_SYSTEM_VERSION: number & { readonly __brand: "crash.SYSFIELD_SYSTEM_VERSION" };
+    /**
+     * system territory as reported by sys.get_sys_info
+     */
+    const SYSFIELD_TERRITORY: number & { readonly __brand: "crash.SYSFIELD_TERRITORY" };
+    /**
+     * The max number of user fields.
+     */
+    const USERFIELD_MAX: number & { readonly __brand: "crash.USERFIELD_MAX" };
+    /**
+     * The max size of a single user field.
+     */
+    const USERFIELD_SIZE: number & { readonly __brand: "crash.USERFIELD_SIZE" };
+    /**
+     * A table is returned containing the addresses of the call stack.
+     *
+     * @param handle - crash dump handle
+     * @returns table containing the backtrace
+     */
+    function get_backtrace(handle: number): string[];
+    /**
+     * The format of read text blob is platform specific
+     * and not guaranteed
+     * but can be useful for manual inspection.
+     *
+     * @param handle - crash dump handle
+     * @returns string with the platform specific data
+     */
+    function get_extra_data(handle: number): string;
+    /**
+     * get all loaded modules from when the crash occured
+     *
+     * @param handle - crash dump handle
+     * @returns loaded modules
+     */
+    function get_modules(handle: number): crash.module_info[];
+    /**
+     * read signal number from a crash report
+     *
+     * @param handle - crash dump handle
+     * @returns signal number
+     */
+    function get_signum(handle: number): number;
+    /**
+     * reads a system field from a loaded crash dump
+     *
+     * @param handle - crash dump handle
+     * @param index - system field enum. Must be less than crash.SYSFIELD_MAX
+     * @returns value recorded in the crash dump, or `nil` if it didn't exist
+     */
+    function get_sys_field(handle: number, index: crash.SYSFIELD): string | undefined;
+    /**
+     * reads user field from a loaded crash dump
+     *
+     * @param handle - crash dump handle
+     * @param index - user data slot index. **0️⃣ 0-based; passed to Defold unchanged.**
+     * @returns user data value recorded in the crash dump
+     */
+    function get_user_field(handle: number, index: crash.USERFIELD): string;
+    /**
+     * The crash dump will be removed from disk upon a successful
+     * load, so loading is one-shot.
+     *
+     * @returns handle to the loaded dump, or `nil` if no dump was found
+     */
+    function load_previous(): number | undefined;
+    /**
+     * releases a previously loaded crash dump
+     *
+     * @param handle - handle to loaded crash dump
+     */
+    function release(handle: number): void;
+    /**
+     * Crashes occuring before the path is set will be stored to a default engine location.
+     *
+     * @param path - file path to use
+     */
+    function set_file_path(path: string): void;
+    /**
+     * Store a user value that will get written to a crash dump when
+     * a crash occurs. This can be user id:s, breadcrumb data etc.
+     * There are 32 slots indexed from 0. Each slot stores at most 255 characters.
+     *
+     * @param index - slot index. 0-indexed. **0️⃣ 0-based; passed to Defold unchanged.**
+     * @param value - string value to store
+     */
+    function set_user_field(index: crash.USERFIELD, value: string): void;
+    /**
+     * Performs the same steps as if a crash had just occured but
+     * allows the program to continue.
+     * The generated dump can be read by crash.load_previous
+     */
+    function write_dump(): void;
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/editor-vm/http.d.ts

@@ -0,0 +1,139 @@
+/** @noSelfInFile */
+import type { Opaque } from "../../../../src/core-types";
+
+declare global {
+  /**
+   * Editor scripting documentation
+   */
+  namespace http {
+    type response = Opaque<"http.response">;
+    type route = Opaque<"http.route">;
+    /**
+     * Perform an HTTP request
+     *
+     * @param url - request URL
+     * @param opts - request options
+     * @returns HTTP response
+     */
+    function request(url: string, opts?: http.request.options): http.request.response;
+    namespace request {
+      type method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | string;
+      /**
+       * Options for http.request
+       */
+      interface options {
+        /**
+         * request method, defaults to `"GET"`
+         */
+        method?: http.request.method;
+        /**
+         * request headers
+         */
+        headers?: LuaTable<string, string>;
+        /**
+         * request body
+         */
+        body?: string;
+        /**
+         * response body converter; mutually exclusive with `path`
+         */
+        as?: "string" | "json";
+        /**
+         * destination file path, resolved against project root if relative; mutually exclusive with `as`
+         */
+        path?: string;
+      }
+      /**
+       * Response returned by http.request
+       */
+      interface response {
+        /**
+         * response code
+         */
+        status: number;
+        /**
+         * response headers, where keys are lowercase and repeated headers have arrays of values
+         */
+        headers: LuaTable<string, string | string[]>;
+        /**
+         * response body, present only when the `as` option was provided
+         */
+        body?: unknown;
+        /**
+         * resolved absolute destination path, present after a successful response was written using the `path` option
+         */
+        path?: string;
+      }
+    }
+    namespace server {
+      type handler = (request: http.server.request) => LuaMultiReturn<[http.response | number | undefined, LuaTable<string, string> | undefined, string | undefined]>;
+      /**
+       * HTTP server request
+       */
+      interface request {
+        /**
+         * route path parameter extracted from a path pattern
+         */
+        "[string]": unknown;
+        /**
+         * full matched path, starting with `/`
+         */
+        path: string;
+        /**
+         * HTTP request method, e.g. `"POST"`
+         */
+        method: string;
+        /**
+         * request headers, keyed by lowercase header name
+         */
+        headers: LuaTable<string, string | string[]>;
+        /**
+         * query string
+         */
+        query?: string;
+        /**
+         * request body, whose type depends on the route's `as` argument
+         */
+        body?: unknown;
+      }
+      /**
+       * Create HTTP response that will stream the content of a file defined by the path
+       *
+       * @param path - External file path, resolved against project root if relative
+       * @param status - HTTP status code, an integer, default 200
+       * @param headers - HTTP response headers, a table from lower-case header names to header values
+       * @returns HTTP response value, userdata
+       */
+      function external_file_response(path: string, status?: number, headers?: LuaMap<string, string> | Record<string, string>): http.response;
+      /**
+       * Create HTTP response with a JSON value
+       *
+       * @param value - Any Lua value that may be represented as JSON
+       * @param status - HTTP status code, an integer, default 200
+       * @param headers - HTTP response headers, a table from lower-case header names to header values
+       * @returns HTTP response value, userdata
+       */
+      function json_response(value: unknown, status?: number, headers?: LuaMap<string, string> | Record<string, string>): http.response;
+      /**
+       * Create HTTP response that will stream the content of a resource defined by the resource path
+       *
+       * @param resource_path - Resource path (starting with `/`)
+       * @param status - HTTP status code, an integer, default 200
+       * @param headers - HTTP response headers, a table from lower-case header names to header values
+       * @returns HTTP response value, userdata
+       */
+      function resource_response(resource_path: string, status?: number, headers?: LuaMap<string, string> | Record<string, string>): http.response;
+      /**
+       * Create HTTP response
+       *
+       * @param status - HTTP status code, an integer, default 200
+       * @param headers - HTTP response headers, a table from lower-case header names to header values
+       * @param body - HTTP response body
+       * @returns HTTP response value, userdata
+       */
+      function response(status?: number, headers?: LuaMap<string, string> | Record<string, string>, body?: string): http.response;
+    }
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/editor-vm/image.d.ts

@@ -0,0 +1,48 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Editor scripting documentation
+   */
+  namespace image {
+    /**
+     * Load an image file for reading
+     *
+     * @param path - External file path, resolved against project root if relative
+     * @returns image userdata
+     */
+    function load_file(path: string): editor.image;
+    /**
+     * Return the color of a pixel from a loaded image.
+     * Coordinates are 1-based, with `1, 1` at the top-left corner.
+     *
+     * @param image - image userdata returned by `image.load_file()`
+     * @param x - 1-based horizontal pixel coordinate. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param y - 1-based vertical pixel coordinate. **⚠️ 1-based; passed to Defold unchanged.**
+     */
+    function pixel(image: editor.image, x: number, y: number): LuaMultiReturn<[number, number, number, number]>;
+    /**
+     * Iterate over pixels in a loaded image.
+     * The iterator returns pixels row by row from top-left to bottom-right. Coordinates are 1-based.
+     *
+     * @param image - image userdata returned by `image.load_file()`
+     * @returns iterator function returning `x, y, r, g, b, a` for each pixel. **⚠️ 1-based; passed to Defold unchanged.**
+     * @example
+     * ```lua
+     * local img = image.load_file("assets/source.png")
+     * local width, height = image.size(img)
+     * for x, y, r, g, b, a in image.pixels(img) do
+     *   print(x, y, r, g, b, a)
+     * end
+     * ```
+     */
+    function pixels(image: editor.image): (...args: unknown[]) => unknown;
+    /**
+     * Return the width and height of a loaded image.
+     *
+     * @param image - image userdata returned by `image.load_file()`
+     */
+    function size(image: editor.image): LuaMultiReturn<[number, number]>;
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/editor-vm/json.d.ts

@@ -0,0 +1,21 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Editor scripting documentation
+   */
+  namespace json {
+    namespace decode {
+      /**
+       * Options for json.decode
+       */
+      interface options {
+        /**
+         * if true, decodes all JSON values in a string and returns an array
+         */
+        all?: boolean;
+      }
+    }
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/editor-vm/localization.d.ts

@@ -0,0 +1,42 @@
+/** @noSelfInFile */
+import type { Opaque } from "../../../../src/core-types";
+
+declare global {
+  /**
+   * Editor scripting documentation
+   */
+  namespace localization {
+    /**
+     * Create a message pattern that renders a list with the "and" conjunction (for example: a, b, and c) once it is stringified
+     *
+     * @param items - array of values; each value may be `nil`, `boolean`, `number`, `string`, or another `message` instance
+     * @returns a userdata value that, when stringified with `tostring()`, will produce a localized text according to the currently selected language in the editor
+     */
+    function and_list(items: (undefined | boolean | number | string | Opaque<"message">)[]): Opaque<"message">;
+    /**
+     * Create a message pattern that concatenates values (similar to `table.concat`) and performs the actual concatenation when stringified
+     *
+     * @param items - array of values; each value may be `nil`, `boolean`, `number`, `string`, or another `message` instance
+     * @param separator - optional separator inserted between values; defaults to an empty string
+     * @returns a userdata value that, when stringified with `tostring()`, will produce a localized text according to the currently selected language in the editor
+     */
+    function concat(items: (undefined | boolean | number | string | Opaque<"message">)[], separator?: boolean | number | string | Opaque<"message">): Opaque<"message">;
+    /**
+     * Create a message pattern for a localization key defined in an `.editor_localization` file; the actual localization happens when the returned value is stringified
+     *
+     * @param key - localization key defined in an `.editor_localization` file
+     * @param vars - optional table with variables to be substituted in the localized string that uses ICU Message Format syntax; keys must be strings; values must be either `nil`, `boolean`, `number`, `string`, or another `message` instance
+     * @returns a userdata value that, when stringified with `tostring()`, will produce a localized text according to the currently selected language in the editor
+     */
+    function message(key: string, vars?: LuaMap<string, undefined | boolean | number | string | Opaque<"message">> | Record<string, undefined | boolean | number | string | Opaque<"message">>): Opaque<"message">;
+    /**
+     * Create a message pattern that renders a list with the "or" conjunction (for example: a, b, or c) once it is stringified
+     *
+     * @param items - array of values; each value may be `nil`, `boolean`, `number`, `string`, or another `message` instance
+     * @returns a userdata value that, when stringified with `tostring()`, will produce a localized text according to the currently selected language in the editor
+     */
+    function or_list(items: (undefined | boolean | number | string | Opaque<"message">)[]): Opaque<"message">;
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/editor-vm/tilemap_tiles.d.ts

@@ -0,0 +1,126 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Editor scripting documentation
+   */
+  namespace tilemap.tiles {
+    /**
+     * Remove all tiles
+     *
+     * @param tiles - unbounded 2d grid of tiles
+     * @returns unbounded 2d grid of tiles
+     */
+    export function clear(tiles: editor.tiles): editor.tiles;
+    /**
+     * Get full information from a tile at a particular coordinate
+     *
+     * @param tiles - unbounded 2d grid of tiles
+     * @param x - x coordinate of a tile
+     * @param y - y coordinate of a tile
+     * @returns full tile information, or nil if no tile is set at the coordinate. **⚠️ `index` is 1-based; passed to Defold unchanged.**
+     */
+    export function get_info(tiles: editor.tiles, x: number, y: number): tilemap.tiles.get_info.result | undefined;
+    /**
+     * Get a tile index at a particular coordinate
+     *
+     * @param tiles - unbounded 2d grid of tiles
+     * @param x - x coordinate of a tile
+     * @param y - y coordinate of a tile
+     * @returns 1-indexed tile index of a tilemap's tilesource. **⚠️ 1-based; passed to Defold unchanged.**
+     */
+    export function get_tile(tiles: editor.tiles, x: number, y: number): number;
+    /**
+     * Create an iterator over all tiles in a tiles data structure
+     * When iterating using for loop, each iteration returns x, y and tile index of a tile in a tile map
+     *
+     * @param tiles - unbounded 2d grid of tiles
+     * @returns iterator
+     * @example
+     * ```lua
+     * Iterate over all tiles in a tile map:
+     * local layers = editor.get("/level.tilemap", "layers")
+     * for i = 1, #layers do
+     *   local tiles = editor.get(layers[i], "tiles")
+     *   for x, y, i in tilemap.tiles.iterator(tiles) do
+     *     print(x, y, i)
+     *   end
+     * end
+     * ```
+     */
+    export function iterator(tiles: editor.tiles): (...args: unknown[]) => unknown;
+    /**
+     * Create a new unbounded 2d grid data structure for storing tilemap layer tiles
+     *
+     * @returns unbounded 2d grid of tiles
+     */
+    function _new(): editor.tiles;
+    /**
+     * Remove a tile at a particular coordinate
+     *
+     * @param tiles - unbounded 2d grid of tiles
+     * @param x - x coordinate of a tile
+     * @param y - y coordinate of a tile
+     * @returns unbounded 2d grid of tiles
+     */
+    export function remove(tiles: editor.tiles, x: number, y: number): editor.tiles;
+    /**
+     * Set a tile at a particular coordinate
+     *
+     * @param tiles - unbounded 2d grid of tiles
+     * @param x - x coordinate of a tile
+     * @param y - y coordinate of a tile
+     * @param tile_or_info - Either 1-indexed tile index of a tilemap's tilesource or full tile information. **⚠️ 1-based; passed to Defold unchanged.** **⚠️ `index` is 1-based; passed to Defold unchanged.**
+     * @returns unbounded 2d grid of tiles
+     */
+    export function set(tiles: editor.tiles, x: number, y: number, tile_or_info: number | tilemap.tiles.set.info): editor.tiles;
+    export { _new as new };
+    export namespace get_info {
+      /**
+       * Full tile information returned by tilemap.tiles.get_info
+       */
+      interface result {
+        /**
+         * 1-indexed tile index of a tilemap's tilesource
+         */
+        index: number;
+        /**
+         * horizontal flip
+         */
+        h_flip: boolean;
+        /**
+         * vertical flip
+         */
+        v_flip: boolean;
+        /**
+         * whether the tile is rotated 90 degrees clockwise
+         */
+        rotate_90: boolean;
+      }
+    }
+    export namespace set {
+      /**
+       * Tile information accepted by tilemap.tiles.set
+       */
+      interface info {
+        /**
+         * 1-indexed tile index of a tilemap's tilesource
+         */
+        index: number;
+        /**
+         * horizontal flip
+         */
+        h_flip?: boolean;
+        /**
+         * vertical flip
+         */
+        v_flip?: boolean;
+        /**
+         * whether the tile is rotated 90 degrees clockwise
+         */
+        rotate_90?: boolean;
+      }
+    }
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/editor-vm/zip.d.ts

@@ -0,0 +1,38 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Editor scripting documentation
+   */
+  namespace zip {
+    namespace pack {
+      type entries = (string | zip.pack.entry)[];
+      type entry = { 1: string; 2?: string; method?: unknown; level?: number };
+      /**
+       * Options for zip.pack
+       */
+      interface options {
+        /**
+         * compression method, defaults to `zip.METHOD.DEFLATED`
+         */
+        method?: unknown;
+        /**
+         * compression level from 0 to 9 for deflated entries; defaults to 6
+         */
+        level?: number;
+      }
+    }
+    namespace unpack {
+      /**
+       * Options for zip.unpack
+       */
+      interface options {
+        /**
+         * conflict resolution strategy
+         */
+        on_conflict: unknown;
+      }
+    }
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/editor-vm/zlib.d.ts

@@ -0,0 +1,24 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Editor scripting documentation
+   */
+  namespace zlib {
+    /**
+     * Deflate (compress) a buffer
+     *
+     * @param buf - buffer to deflate
+     * @returns deflated buffer
+     */
+    function deflate(buf: string): string;
+    /**
+     * Inflate (decompress) a buffer
+     *
+     * @param buf - buffer to inflate
+     * @returns inflated buffer
+     */
+    function inflate(buf: string): string;
+  }
+}
+
+export {};