@defold-typescript/types 0.4.3 → 0.5.1

package/generated/http.d.ts

@@ -1,6 +1,56 @@
 /** @noSelfInFile */
 declare global {
   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
+     * ```lua
+     * Basic HTTP-GET request. The callback receives a table with the response
+     * in the fields status, the response (the data) and headers (a table).
+     * local function http_result(self, _, response)
+     *     if response.bytes_total ~= nil then
+     *         update_my_progress_bar(self, response.bytes_received / response.bytes_total)
+     *     else
+     *         print(response.status)
+     *         print(response.response)
+     *         pprint(response.headers)
+     *     end
+     * end
+     *
+     * function init(self)
+     *     http.request("http://www.google.com", "GET", http_result, nil, nil, { report_progress = true })
+     * end
+     * ```
+     */
     function request(url: string, method: string, callback: (self: unknown, id: unknown, response: unknown) => void, headers?: Record<string | number, unknown>, post_data?: string, options?: { timeout?: number; path?: string; ignore_cache?: boolean; chunked_transfer?: boolean; report_progress?: boolean }): void;
   }
 }

package/generated/iac.d.ts

@@ -1,6 +1,13 @@
 /** @noSelfInFile */
 declare global {
   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;
   }
 }

package/generated/iap.d.ts

@@ -3,12 +3,53 @@ import type { Opaque } from "../src/core-types";
 
 declare global {
   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: Record<string | number, unknown>): 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: Record<string | number, unknown>): 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: Record<string | number, unknown>): 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;
   }
 }

package/generated/image.d.ts

@@ -3,12 +3,107 @@ import type { Opaque } from "../src/core-types";
 
 declare global {
   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
+     * ```lua
+     * How to get the block size and dimensions from a .astc file
+     * local s = sys.load_resource("/assets/cat.astc")
+     * local 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 } | unknown;
+    /**
+     * 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
+     * ```lua
+     * How to load an image from an URL and create a GUI texture from it:
+     * local imgurl = "http://www.site.com/image.png"
+     * http.request(imgurl, "GET", function(self, id, response)
+     *         local img = image.load(response.response)
+     *         local tx = gui.new_texture("image_node", img.width, img.height, img.type, img.buffer)
+     *     end)
+     * ```
+     */
     function load(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: string } | unknown;
+    /**
+     * 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
+     * ```lua
+     * Load an image from an URL as a buffer and create a texture resource from it:
+     * local imgurl = "http://www.site.com/image.png"
+     * http.request(imgurl, "GET", function(self, id, response)
+     *         local img = image.load_buffer(response.response, { flip_vertically = true })
+     *         local tparams = {
+     *             width  = img.width,
+     *             height = img.height,
+     *             type   = graphics.TEXTURE_TYPE_2D,
+     *             format = graphics.TEXTURE_FORMAT_RGBA }
+     *
+     *         local 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)
+     *     end)
+     * ```
+     */
     function load_buffer(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: Opaque<"buffer"> } | unknown;
   }
 }

package/generated/json.d.ts

@@ -1,8 +1,67 @@
 /** @noSelfInFile */
 declare global {
   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
+     * ```lua
+     * Converting a string containing JSON data into a Lua table:
+     * function init(self)
+     *     local jsonstring = '{"persons":[{"name":"John Doe"},{"name":"Darth Vader"}]}'
+     *     local data = json.decode(jsonstring)
+     *     pprint(data)
+     * end
+     *
+     * 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
+     * ```lua
+     * Convert a lua table to a JSON string:
+     * function init(self)
+     *      local tbl = {
+     *           persons = {
+     *                { name = "John Doe"},
+     *                { name = "Darth Vader"}
+     *           }
+     *      }
+     *      local jsonstring = json.encode(tbl)
+     *      pprint(jsonstring)
+     * end
+     *
+     * 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 };
   }

package/generated/label.d.ts

@@ -3,18 +3,82 @@ import type { Hash, Url, Vector3, Vector4 } from "../src/core-types";
 
 declare global {
   namespace label {
+    /**
+     * Gets the text from a label component
+     *
+     * @param url - the label to get the text from
+     * @returns the label text
+     * @example
+     * ```lua
+     * function init(self)
+     *     local text = label.get_text("#label")
+     *     print(text)
+     * end
+     * ```
+     */
     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
+     * ```lua
+     * function init(self)
+     *     label.set_text("#label", "Hello World!")
+     * end
+     * ```
+     */
     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;
     }
   }

package/generated/liveupdate.d.ts

@@ -1,21 +1,117 @@
 /** @noSelfInFile */
 declare global {
   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(): Record<string | number, unknown>;
+    /**
+     * 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
+     * ```lua
+     * Add multiple mounts. Higher priority takes precedence.
+     * liveupdate.remove_mount("season_pack_1")
+     * ```
+     */
     function remove_mount(name: string): number;
   }
 }

package/generated/model.d.ts

@@ -3,18 +3,174 @@ import type { Hash, Opaque, Url } from "../src/core-types";
 
 declare global {
   namespace model {
+    /**
+     * Cancels all animation on a model component.
+     *
+     * @param url - the model for which to cancel the animation
+     */
     function cancel(url: string | Hash | Url): void;
+    /**
+     * Get AABB of the whole model in local coordinate space.
+     * AABB information return as a table with `min` and `max` fields, where `min` and `max` has type `vmath.vector3`.
+     *
+     * @param url - the model
+     * @returns A table containing AABB of the model. If model has no meshes - return vmath.vector3(0,0,0) for min and max fields.
+     * @example
+     * ```lua
+     * model.get_aabb("#model") -> { min = vmath.vector3(-2.5, -3.0, 0), max = vmath.vector3(1.5, 5.5, 0) }
+     * model.get_aabb("#empty") -> { min = vmath.vector3(0, 0, 0), max = vmath.vector3(0, 0, 0) }
+     * ```
+     */
     function get_aabb(url: string | Hash | Url): Record<string | number, unknown>;
+    /**
+     * Gets the id of the game object that corresponds to a model skeleton bone.
+     * The returned game object can be used for parenting and transform queries.
+     * This function has complexity `O(n)`, where `n` is the number of bones in the model skeleton.
+     * Game objects corresponding to a model skeleton bone can not be individually deleted.
+     *
+     * @param url - the model to query
+     * @param bone_id - id of the corresponding bone
+     * @returns id of the game object
+     * @example
+     * ```lua
+     * The following examples assumes that the model component has id "model".
+     * How to parent the game object of the calling script to the "right_hand" bone of the model in a player game object:
+     * function init(self)
+     *     local parent = model.get_go("player#model", "right_hand")
+     *     msg.post(".", "set_parent", {parent_id = parent})
+     * end
+     * ```
+     */
     function get_go(url: string | Hash | Url, bone_id: string | Hash): Hash;
+    /**
+     * Get AABB of all meshes.
+     * AABB information return as a table with `min` and `max` fields, where `min` and `max` has type `vmath.vector3`.
+     *
+     * @param url - the model
+     * @returns A table containing info about all AABB in the format
+     * @example
+     * ```lua
+     * model.get_mesh_aabb("#model") -> { hash("Sword") = { min = vmath.vector3(-0.5, -0.5, 0), max = vmath.vector3(0.5, 0.5, 0) }, hash("Shield") = { min = vmath.vector3(-0.5, -0.5, -0.5), max = vmath.vector3(0.5, 0.5, 0.5) } }
+     * ```
+     */
     function get_mesh_aabb(url: string | Hash | Url): Record<string | number, unknown>;
+    /**
+     * Get the enabled state of a mesh
+     *
+     * @param url - the model
+     * @param mesh_id - the id of the mesh
+     * @returns true if the mesh is visible, false otherwise
+     * @example
+     * ```lua
+     * function init(self)
+     *     if model.get_mesh_enabled("#model", "Sword") then
+     *        -- set properties specific for the sword
+     *        self.weapon_properties = game.data.weapons["Sword"]
+     *     end
+     * end
+     * ```
+     */
     function get_mesh_enabled(url: string | Hash | Url, mesh_id: string | Hash | Url): boolean;
+    /**
+     * Plays an animation on a model component with specified playback
+     * mode and parameters.
+     * An optional completion callback function can be provided that will be called when
+     * the animation has completed playing. If no function is provided,
+     * a model_animation_done message is sent to the script that started the animation.
+     * The callback is not called (or message sent) if the animation is
+     * cancelled with model.cancel. The callback is called (or message sent) only for
+     * animations that play with the following playback modes:
+     * - `go.PLAYBACK_ONCE_FORWARD`
+     * - `go.PLAYBACK_ONCE_BACKWARD`
+     * - `go.PLAYBACK_ONCE_PINGPONG`
+     *
+     * @param url - the model for which to play the animation
+     * @param anim_id - id of the animation to play
+     * @param playback - playback mode of the animation
+  - `go.PLAYBACK_ONCE_FORWARD`
+  - `go.PLAYBACK_ONCE_BACKWARD`
+  - `go.PLAYBACK_ONCE_PINGPONG`
+  - `go.PLAYBACK_LOOP_FORWARD`
+  - `go.PLAYBACK_LOOP_BACKWARD`
+  - `go.PLAYBACK_LOOP_PINGPONG`
+     * @param play_properties - optional table with properties
+  Play properties table:
+  `blend_duration`
+  number Duration of a linear blend between the current and new animation.
+  `offset`
+  number The normalized initial value of the animation cursor when the animation starts playing.
+  `playback_rate`
+  number The rate with which the animation will be played. Must be positive.
+     * @param complete_function - function to call when the animation has completed.
+  `self`
+  object The current object.
+  `message_id`
+  hash The name of the completion message, `"model_animation_done"`.
+  `message`
+  table Information about the completion:
+  - hash `animation_id` - the animation that was completed.
+  - constant `playback` - the playback mode for the animation.
+  `sender`
+  url The invoker of the callback: the model component.
+     * @example
+     * ```lua
+     * The following examples assumes that the model has id "model".
+     * How to play the "jump" animation followed by the "run" animation:
+     * local function anim_done(self, message_id, message, sender)
+     *   if message_id == hash("model_animation_done") then
+     *     if message.animation_id == hash("jump") then
+     *       -- open animation done, chain with "run"
+     *       local properties = { blend_duration = 0.2 }
+     *       model.play_anim(url, "run", go.PLAYBACK_LOOP_FORWARD, properties, anim_done)
+     *     end
+     *   end
+     * end
+     *
+     * function init(self)
+     *     local url = msg.url("#model")
+     *     local play_properties = { blend_duration = 0.1 }
+     *     -- first blend during 0.1 sec into the jump, then during 0.2 s into the run animation
+     *     model.play_anim(url, "jump", go.PLAYBACK_ONCE_FORWARD, play_properties, anim_done)
+     * end
+     * ```
+     */
     function play_anim(url: string | Hash | Url, anim_id: string | Hash, playback: Opaque<"constant">, play_properties?: { blend_duration?: number; offset?: number; playback_rate?: number }, complete_function?: (self: unknown, message_id: unknown, message: unknown, sender: unknown) => void): void;
+    /**
+     * Enable or disable visibility of a mesh
+     *
+     * @param url - the model
+     * @param mesh_id - the id of the mesh
+     * @param enabled - true if the mesh should be visible, false if it should be hideen
+     * @example
+     * ```lua
+     * function init(self)
+     *     model.set_mesh_enabled("#model", "Sword", false) -- hide the sword
+     *     model.set_mesh_enabled("#model", "Axe", true)    -- show the axe
+     * end
+     * ```
+     */
     function set_mesh_enabled(url: string | Hash | Url, mesh_id: string | Hash | Url, enabled: boolean): void;
     interface properties {
+      /**
+       * The current animation set on the component. The type of the property is hash.
+       */
       animation: Hash;
+      /**
+       * The normalized animation cursor. The type of the property is number.
+       * Please note that model events may not fire as expected when the cursor is manipulated directly.
+       */
       cursor: number;
+      /**
+       * The material used when rendering the model. The type of the property is hash.
+       */
       material: Hash;
+      /**
+       * The animation playback rate. A multiplier to the animation playback rate. The type of the property is number.
+       */
       playback_rate: number;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
       textureN: Hash;
     }
   }