@defold-typescript/types 0.39.0 → 0.41.0

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

@@ -0,0 +1,55 @@
+/** @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
+     * if (res_num !== undefined) {
+     *   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: unknown) {
+     *   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) | undefined): void;
+  }
+}
+
+export {};

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

@@ -0,0 +1,77 @@
+/** @noSelfInFile */
+import type { Hash } from "../../../src/core-types";
+
+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
+     * function update_my_progress_bar(self: unknown, fraction: number) {
+     *   // draw the progress bar at the given fraction
+     * }
+     *
+     * // 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_received !== undefined && 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: Hash, response: { status: number; response?: string; headers?: LuaMap<string, string>; path?: string; error?: string; bytes_received?: number; bytes_total?: number; range_start?: number; range_end?: number; document_size?: number }) => void, headers?: LuaMap<string, string> | Record<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.13.1/image.d.ts

@@ -0,0 +1,131 @@
+/** @noSelfInFile */
+import type { Opaque } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for creating image objects.
+   */
+  namespace image {
+    /**
+     * luminance image type
+     */
+    const TYPE_LUMINANCE: string & { readonly __brand: "image.TYPE_LUMINANCE" };
+    /**
+     * luminance image type
+     */
+    const TYPE_LUMINANCE_ALPHA: string & { readonly __brand: "image.TYPE_LUMINANCE_ALPHA" };
+    /**
+     * RGB image type
+     */
+    const TYPE_RGB: string & { readonly __brand: "image.TYPE_RGB" };
+    /**
+     * RGBA image type
+     */
+    const TYPE_RGBA: string & { 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");
+     * if (s !== undefined) {
+     *   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 = response.response !== undefined ? image.load(response.response) : undefined;
+     *   if (img !== undefined) {
+     *     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 =
+     *     response.response !== undefined
+     *       ? image.load_buffer(response.response, { flip_vertically: true })
+     *       : undefined;
+     *   // the engine registers a texture format only when the driver supports it
+     *   const format = graphics.TEXTURE_FORMAT_RGBA;
+     *   if (img !== undefined && format !== undefined) {
+     *     const tparams = {
+     *       width: img.width,
+     *       height: img.height,
+     *       type: graphics.TEXTURE_TYPE_2D,
+     *       format,
+     *     };
+     *
+     *     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.13.1/index.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="lua-types/5.1" />
+/// <reference types="lua-types/special/jit-only" />
+import "./b2d";
+import "./b2d_body";
+import "./b2d_chain";
+import "./b2d_fixture";
+import "./b2d_joint";
+import "./b2d_shape";
+import "./b2d_world";
+import "./buffer";
+import "./camera";
+import "./collectionfactory";
+import "./collectionproxy";
+import "./compute";
+import "./crash";
+import "./factory";
+import "./font";
+import "./go";
+import "./graphics";
+import "./gui";
+import "./html5";
+import "./http";
+import "./image";
+import "./json";
+import "./label";
+import "./liveupdate";
+import "./material";
+import "./model";
+import "./msg";
+import "./particlefx";
+import "./physics";
+import "./profiler";
+import "./render";
+import "./resource";
+import "./socket";
+import "./sound";
+import "./sprite";
+import "./sys";
+import "./tilemap";
+import "./timer";
+import "./types";
+import "./vmath";
+import "./window";
+import "./zlib";
+import "../../../src/custom-messages";
+import "../../../src/engine-globals";
+import "../../../src/msg-overloads";
+import "../../../src/message-guard";
+import "../../../src/window-event-guard";
+import "../../../src/scene-addresses";
+import "../../../src/go-overloads";
+import "../../../src/component-properties";
+import "../../../src/render-overloads";
+import "../../../src/vmath-overloads";
+import "../../../src/sys-overloads";
+
+export {};

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

@@ -0,0 +1,80 @@
+/** @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`: whether to decode a JSON null value as json.null or nil (default is nil)
+     * @returns decoded json
+     * @example
+     * Converting a string containing JSON data into a Lua table:
+     * ```ts
+     * export default defineScript({
+     *   init() {
+     *     const jsonstring = '{"persons":[{"name":"John Doe"},{"name":"Darth Vader"}]}';
+     *     const data = json.decode(jsonstring);
+     *     pprint(data);
+     *   },
+     * });
+     * ```
+     * @example
+     * Results in the following printout:
+     * ```ts
+     * // {
+     * //   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`: whether to encode an empty table as an JSON object or array (default is object)
+     * @returns encoded json
+     * @example
+     * Convert a lua table to a JSON string:
+     * ```ts
+     * export default defineScript({
+     *   init() {
+     *     const tbl = {
+     *       persons: [{ name: "John Doe" }, { name: "Darth Vader" }],
+     *     };
+     *     const jsonstring = json.encode(tbl);
+     *     pprint(jsonstring);
+     *   },
+     * });
+     * ```
+     * @example
+     * Results in the following printout:
+     * ```ts
+     * // {"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.13.1/kinds/editor-script.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="lua-types/5.1" />
+import "../editor";
+import "../editor-vm/http";
+import "../editor-vm/image";
+import "../editor-vm/json";
+import "../editor-vm/localization";
+import "../editor-vm/zip";
+import "../editor-vm/zlib";
+import "../editor-vm/tilemap_tiles";
+import "../../../../src/editor-overloads";
+import "../../../../src/editor-vm-globals";
+
+export { defineEditorScript, defineEditorCommand } from "../../../../src/editor";
+export type { EditorCommandQuery, EditorNode } from "../../../../src/editor";

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

@@ -0,0 +1,93 @@
+/** @noSelfInFile */
+import type { Hash, Url, Vector3, Vector4 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Label API documentation
+   */
+  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. `go.get` returns and `go.set` takes a vector3; `go.animate` also takes a number, which sets a uniform scale.
+       */
+      scale: 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.13.1/liveupdate.d.ts

@@ -0,0 +1,142 @@
+/** @noSelfInFile */
+import type { Hash } from "../../../src/core-types";
+
+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.
+     * 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
+     * - `name` hash Unique name of the mount
+     * - `uri` string The uri of the mount
+     * - `result` number The result of the request
+     * @returns The result of the request
+     * @example
+     * ```ts
+     * // Add multiple mounts. Higher priority takes precedence.
+     * liveupdate.add_mount("common", "zip:/path/to/common_stuff.zip", 10, (result) => {}); // base pack
+     * liveupdate.add_mount("levelpack_1", "zip:/path/to/levels_1_to_20.zip", 20, (result) => {}); // level pack
+     * liveupdate.add_mount("season_pack_1", "zip:/path/to/easter_pack_1.zip", 30, (result) => {}); // season pack, overriding content in the other packs
+     * ```
+     */
+    function add_mount(name: string | Hash, uri: string, priority: number, callback: (self: unknown, name: unknown, uri: unknown, result: unknown) => void): 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
+     * Output the current resource mounts
+     * ```ts
+     * pprint("MOUNTS", liveupdate.get_mounts());
+     * ```
+     * @example
+     * Give an output like:
+     * ```ts
+     * // DEBUG:SCRIPT: MOUNTS,
+     * // {
+     * //   1 = {
+     * //     name = hash: [liveupdate],
+     * //     uri = "zip:/device/path/to/acchives/liveupdate.zip",
+     * //     priority = 5
+     * //   },
+     * //   2 = {
+     * //     name = hash: [_base],
+     * //     uri = "archive:build/default/game.dmanifest",
+     * //     priority = -10
+     * //   }
+     * // }
+     * ```
+     */
+    function get_mounts(): { name: string; uri: string; priority: number }[];
+    /**
+     * Checks if the bundled application was built with one or more resources
+     * excluded from the main bundle, through a collection proxy with
+     * `Exclude` enabled.
+     * This value is based on metadata in the bundled manifest. It does not check
+     * whether any live update archive has been mounted or whether the excluded
+     * resources are currently available on device.
+     *
+     * @returns true if the bundled application was built with excluded files
+     * @example
+     * ```ts
+     * if (liveupdate.is_built_with_excluded_files()) print("The bundle expects live update content.");
+     * ```
+     */
+    function is_built_with_excluded_files(): boolean;
+    /**
+     * Remove a mount the resource system.
+     * 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 | Hash): number;
+  }
+}
+
+export {};