@defold-typescript/types 0.48.0 → 0.50.0

package/generated/versions/defold-1.13.2/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`
+     * script_instance The calling script instance
+     * @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.2/http.d.ts

@@ -0,0 +1,83 @@
+/** @noSelfInFile */
+import type { Hash } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for performing HTTP and HTTPS requests.
+   */
+  namespace http {
+    /**
+     * HTTP request options
+     */
+    interface request_options {
+      /**
+       * timeout in seconds
+       */
+      timeout?: number;
+      /**
+       * absolute destination path; overwritten only for status 200
+       */
+      path?: string;
+      /**
+       * do not return cached data for status 304; unavailable on HTML5
+       */
+      ignore_cache?: boolean;
+      /**
+       * use chunked transfer encoding for HTTPS requests larger than 16 KB; defaults to true and is unavailable on HTML5
+       */
+      chunked_transfer?: boolean;
+      /**
+       * report transferred and total byte counts to the callback
+       */
+      report_progress?: boolean;
+    }
+    /**
+     * 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`
+     * script_instance The current script instance
+     * `id`
+     * hash Internal message identifier. Do not use!
+     * @param headers - optional table with custom headers
+     * @param post_data - optional data to send
+     * @param options - optional request options
+     * @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?: http.request_options): void;
+  }
+}
+
+export {};

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

@@ -0,0 +1,181 @@
+/** @noSelfInFile */
+import type { Opaque } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for creating image objects.
+   */
+  namespace image {
+    /**
+     * ASTC image header
+     */
+    interface astc_header {
+      /**
+       * Image width.
+       */
+      width: number;
+      /**
+       * Image height.
+       */
+      height: number;
+      /**
+       * Image depth.
+       */
+      depth: number;
+      /**
+       * Block size on the x-axis.
+       */
+      block_size_x: number;
+      /**
+       * Block size on the y-axis.
+       */
+      block_size_y: number;
+      /**
+       * Block size on the z-axis.
+       */
+      block_size_z: number;
+    }
+    /**
+     * Loaded buffer image data
+     */
+    interface load_buffer_result {
+      /**
+       * Image width.
+       */
+      width: number;
+      /**
+       * Image height.
+       */
+      height: number;
+      /**
+       * Image type.
+       */
+      type: image.TYPE;
+      /**
+       * Script buffer containing the decompressed image data.
+       */
+      buffer: Opaque<"buffer">;
+    }
+    /**
+     * Image loading options
+     */
+    interface load_options {
+      /**
+       * Whether to premultiply alpha into the color components. Defaults to `false`.
+       */
+      premultiply_alpha?: boolean;
+      /**
+       * Whether to flip the image contents vertically. Defaults to `false`.
+       */
+      flip_vertically?: boolean;
+    }
+    /**
+     * Loaded string image data
+     */
+    interface load_result {
+      /**
+       * Image width.
+       */
+      width: number;
+      /**
+       * Image height.
+       */
+      height: number;
+      /**
+       * Image type.
+       */
+      type: image.TYPE;
+      /**
+       * Raw image data.
+       */
+      buffer: string;
+    }
+    type TYPE = typeof image.TYPE_RGB | typeof image.TYPE_RGBA | typeof image.TYPE_LUMINANCE | typeof image.TYPE_LUMINANCE_ALPHA;
+    /**
+     * Luminance image type.
+     */
+    const TYPE_LUMINANCE: string & { readonly __brand: "image.TYPE_LUMINANCE" };
+    /**
+     * Luminance-alpha 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 the buffer is not a valid ASTC image
+     * @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): image.astc_header | undefined;
+    /**
+     * Load image (PNG or JPEG) from buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - Optional loading parameters. A boolean is accepted for backwards compatibility and controls `premultiply_alpha`.
+     * @returns loaded image, or `nil` if loading fails
+     * @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?: boolean | image.load_options): image.load_result | undefined;
+    /**
+     * Load image (PNG or JPEG) from a string buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - Optional loading parameters. A boolean is accepted for backwards compatibility and controls `premultiply_alpha`.
+     * @returns loaded image, or `nil` if loading fails
+     * @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?: boolean | image.load_options): image.load_buffer_result | undefined;
+  }
+}
+
+export {};

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

@@ -0,0 +1,63 @@
+/// <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 "./bullet3d";
+import "./bullet3d_collision_object";
+import "./bullet3d_constraint";
+import "./bullet3d_rigid_body";
+import "./bullet3d_shape";
+import "./bullet3d_world";
+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.2/json.d.ts

@@ -0,0 +1,94 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Manipulation of JSON data strings.
+   */
+  namespace json {
+    /**
+     * JSON decoding options
+     */
+    export interface decode_options {
+      /**
+       * Decode JSON `null` as json.null instead of `nil`.
+       */
+      decode_null_as_userdata?: boolean;
+    }
+    /**
+     * JSON encoding options
+     */
+    export interface encode_options {
+      /**
+       * Encode an empty table as an object instead of an array. The default is true.
+       */
+      encode_empty_table_as_object?: boolean;
+    }
+    /**
+     * 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 - optional decoding options
+     * @returns decoded JSON value
+     * @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?: json.decode_options): unknown;
+    /**
+     * Encode a lua table to a JSON string.
+     * A Lua error is raised for syntax errors.
+     *
+     * @param tbl - Lua value to encode
+     * @param options - optional encoding options
+     * @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: unknown, options?: json.encode_options): string;
+    export { _null as null };
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/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.2/label.d.ts

@@ -0,0 +1,164 @@
+/** @noSelfInFile */
+import type { Hash, Url, Vector3, Vector4 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Label API documentation
+   */
+  namespace label {
+    /**
+     * Rich-text layout object
+     */
+    interface layout_object {
+      /**
+       * object type, currently `link` or `sprite`
+       */
+      type: string;
+      /**
+       * the object's `id` attribute, or its generated layout object id
+       */
+      id: Hash;
+      /**
+       * zero-based UTF-32 offset in the visible text
+       */
+      text_offset: number;
+      /**
+       * visible UTF-32 text length covered by the object
+       */
+      text_length: number;
+      /**
+       * lower-left x-coordinate relative to the label's upper-left layout origin
+       */
+      x: number;
+      /**
+       * lower-left y-coordinate relative to the label's upper-left layout origin
+       */
+      y: number;
+      /**
+       * resolved object width
+       */
+      width: number;
+      /**
+       * resolved object height
+       */
+      height: number;
+      /**
+       * markup attributes keyed by name
+       */
+      attributes: LuaTable<string, string>;
+    }
+    /**
+     * Returns the sprites and links found in the label's current layout.
+     * Each entry contains `type`, `id`, the zero-based UTF-32 `text_offset`,
+     * `text_length`, resolved `x`, `y`, `width`
+     * and `height`, and an `attributes` table. The position is the lower-left
+     * object corner relative to the label's upper-left layout origin.
+     * Inline resource rendering is not part of this MVP; sprites use their explicit
+     * dimensions or a one-em square fallback.
+     *
+     * @param url - the label to inspect
+     * @returns layout objects in source order. **0️⃣ `text_offset` is 0-based; passed to Defold unchanged.**
+     * @example
+     * ```ts
+     * const objects = label.get_layout_objects("#label");
+     * for (const object of objects) {
+     *   if (object.type === "link") {
+     *     print(object.attributes.get("src"), object.text_offset, object.text_length);
+     *   } else if (object.type === "sprite") {
+     *     print(object.attributes.get("src"), object.x, object.y, object.width, object.height);
+     *   }
+     * }
+     * ```
+     */
+    function get_layout_objects(url: string | Hash | Url): label.layout_object[];
+    /**
+     * Gets the text from a label component
+     * This function is deprecated. Use `go.get("#label", "text")` instead.
+     *
+     * @param url - the label to get the text from
+     * @returns the label text
+     * @example
+     * ```ts
+     * export default defineScript({
+     *   init() {
+     *     const text = go.get<label.properties>()("#label", "text");
+     *     print(text);
+     *   },
+     * });
+     * ```
+     */
+    function get_text(url: string | Hash | Url): string;
+    /**
+     * Sets the text of a label component
+     * This function is deprecated. Use `go.set("#label", "text", value)` instead.
+     * 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() {
+     *     go.set<label.properties>()("#label", "text", "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 text of the label.
+       */
+      text: string;
+      /**
+       * 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 {};