@defold-typescript/types 0.51.0 → 0.52.0

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

@@ -1,5 +1,5 @@
 /** @noSelfInFile */
-import type { Hash, Matrix4, Opaque, Quaternion, Url, Vector, Vector3, Vector4 } from "../../../src/core-types";
+import type { Hash, Opaque, Quaternion, Vector3, Vector4 } from "../../../src/core-types";
 
 declare global {
   /**
@@ -518,83 +518,6 @@ declare global {
      * text type
      */
     const TYPE_TEXT: number & { readonly __brand: "gui.TYPE_TEXT" };
-    /**
-     * This starts an animation of a node property according to the specified parameters.
-     * If the node property is already being animated, that animation will be canceled and
-     * replaced by the new one. Note however that several different node properties
-     * can be animated simultaneously. Use `gui.cancel_animations` to stop the animation
-     * before it has completed.
-     * Composite properties of type vector3, vector4 or quaternion
-     * also expose their sub-components (x, y, z and w).
-     * You can address the components individually by suffixing the name with a dot '.'
-     * and the name of the component.
-     * For instance, `"position.x"` (the position x coordinate) or `"color.w"`
-     * (the color alpha value).
-     * If a `complete_function` (Lua function) is specified, that function will be called
-     * when the animation has completed.
-     * By starting a new animation in that function, several animations can be sequenced
-     * together. See the examples below for more information.
-     *
-     * @param node - node to animate
-     * @param property - property to animate; each gui.PROP member equals its corresponding property name string
-     * @param to - target property value
-     * @param easing - easing to use during animation.
-     * Either specify one of the `gui.EASING_*` constants or provide a
-     * vector with a custom curve. See the animation guide for more information.
-     * @param duration - duration of the animation in seconds.
-     * @param delay - delay before the animation starts in seconds.
-     * @param complete_function - function to call when the
-     * animation has completed
-     * @param playback - playback mode
-     * @example
-     * How to start a simple color animation, where the node fades in to white during 0.5 seconds:
-     * ```ts
-     * // How to start a simple color animation, where the node fades in to white during 0.5 seconds:
-     * const node = gui.get_node("my_node");
-     * gui.set_color(node, vmath.vector4(0, 0, 0, 0)); // node is fully transparent
-     * gui.animate(node, gui.PROP_COLOR, vmath.vector4(1, 1, 1, 1), gui.EASING_INOUTQUAD, 0.5); // start animation
-     * ```
-     * @example
-     * How to start a sequenced animation where the node fades in to white during 0.5 seconds, stays visible for 2 seconds and then fades out:
-     * ```ts
-     * // How to start a sequenced animation where the node fades in to white during 0.5
-     * // seconds, stays visible for 2 seconds and then fades out:
-     * function on_animation_done(self: unknown, node: unknown) {
-     *   // fade out node, but wait 2 seconds before the animation starts
-     *   gui.animate(node as Opaque<"node">, gui.PROP_COLOR, vmath.vector4(0, 0, 0, 0), gui.EASING_OUTQUAD, 0.5, 2.0);
-     * }
-     *
-     * export default defineGuiScript({
-     *   init(self) {
-     *     // fetch the node we want to animate
-     *     const my_node = gui.get_node("my_node");
-     *     // node is initially set to fully transparent
-     *     gui.set_color(my_node, vmath.vector4(0, 0, 0, 0));
-     *     // animate the node immediately and call on_animation_done when the animation has completed
-     *     gui.animate(my_node, gui.PROP_COLOR, vmath.vector4(1, 1, 1, 1), gui.EASING_INOUTQUAD, 0.5, 0.0, on_animation_done);
-     *   },
-     * });
-     * ```
-     * @example
-     * How to animate a node's y position using a crazy custom easing curve:
-     * ```ts
-     * // How to animate a node's y position using a crazy custom easing curve:
-     * export default defineGuiScript({
-     *   init(self) {
-     *     const values = [
-     *       0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
-     *       0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
-     *       0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
-     *       0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
-     *     ];
-     *     const vec = vmath.vector(values);
-     *     const node = gui.get_node("box");
-     *     gui.animate(node, "position.y", 100, vec, 4.0, 0, undefined, gui.PLAYBACK_LOOP_PINGPONG);
-     *   },
-     * });
-     * ```
-     */
-    function animate(node: Opaque<"node">, property: string | Hash | gui.PROP, to: number | Vector3 | Vector4 | Quaternion, easing: gui.EASING | Vector, duration: number, delay?: number, complete_function?: (self: unknown, node: Opaque<"node">) => void, playback?: gui.PLAYBACK): void;
     /**
      * If one or more animations of the specified node is currently running (started by `gui.animate`), they will immediately be canceled.
      *
@@ -665,10 +588,10 @@ declare global {
      * Make a clone instance of a node and all its children.
      * Use gui.clone to clone a node excluding its children.
      *
-     * @param node - root node to clone
+     * @param node - root node to clone, or `nil` to clone the whole scene; leaving the argument out raises an error
      * @returns a table mapping node ids to the corresponding cloned nodes
      */
-    function clone_tree(node: Opaque<"node">): LuaTable<Hash, Opaque<"node">> & { get: LuaTableGetMethod<string, Opaque<"node">> };
+    function clone_tree(node: Opaque<"node"> | undefined): LuaTable<Hash, Opaque<"node">> & { get: LuaTableGetMethod<string, Opaque<"node">> };
     /**
      * Deletes the specified node. Any child nodes of the specified node will be
      * recursively deleted.
@@ -703,66 +626,6 @@ declare global {
      * ```
      */
     function delete_texture(texture: string | Hash): void;
-    /**
-     * This is a callback-function, which is called by the engine when a gui component is finalized (destroyed). It can
-     * be used to e.g. take some last action, report the finalization to other game object instances
-     * or release user input focus (see `release_input_focus`). There is no use in starting any animations or similar
-     * from this function since the gui component is about to be destroyed.
-     *
-     * @param self - script instance used for storing state
-     * @example
-     * ```ts
-     * export default defineScript({
-     *   init() {
-     *     return { some_value: 0 };
-     *   },
-     *
-     *   final(self) {
-     *     // report finalization
-     *     msg.post("my_friend_instance", "im_dead", { my_stats: self.some_value });
-     *   },
-     * });
-     * ```
-     */
-    function final(self: unknown): void;
-    /**
-     * Instead of using specific getters such as gui.get_position or gui.get_scale,
-     * you can use gui.get instead and supply the property as a string or a hash.
-     * While this function is similar to go.get, there are a few more restrictions
-     * when operating in the gui namespace. Most notably, only these explicitly named properties are supported:
-     *
-     * - `"position"`
-     * - `"rotation"`
-     * - `"euler"`
-     * - `"scale"`
-     * - `"color"`
-     * - `"outline"`
-     * - `"shadow"`
-     * - `"size"`
-     * - `"fill_angle"` (pie)
-     * - `"inner_radius"` (pie)
-     * - `"leading"` (text)
-     * - `"tracking"` (text)
-     * - `"slice9"` (slice9)
-     *
-     * The value returned will either be a vmath.vector4 or a single number, i.e getting the "position"
-     * property will return a vec4 while getting the "position.x" property will return a single value.
-     * You can also use this function to get material constants.
-     *
-     * @param node - node to get the property for
-     * @param property - the property to retrieve
-     * @param options - optional options table (only applicable for material constants)
-     * - `index` integer index into array property (1 based)
-     *
-     * **⚠️ `index` is 1-based; passed to Defold unchanged.**
-     * @example
-     * ```ts
-     * // Get properties on existing nodes:
-     * const node = gui.get_node("my_box_node");
-     * const node_position = gui.get(node, "position");
-     * ```
-     */
-    function get(node: Opaque<"node">, property: string | Hash | gui.PROP, options?: { index?: number; key?: string | Hash; keys?: (Hash | string)[] }): unknown;
     /**
      * Returns the adjust mode of a node.
      * The adjust mode defines how the node will adjust itself to screen
@@ -1174,10 +1037,10 @@ declare global {
     /**
      * Get a node and all its children as a Lua table.
      *
-     * @param node - root node to get node tree from
+     * @param node - root node to get node tree from, or `nil` to get the whole scene; leaving the argument out raises an error
      * @returns a table mapping node ids to the corresponding nodes
      */
-    function get_tree(node: Opaque<"node">): LuaTable<Hash, Opaque<"node">> & { get: LuaTableGetMethod<string, Opaque<"node">> };
+    function get_tree(node: Opaque<"node"> | undefined): LuaTable<Hash, Opaque<"node">> & { get: LuaTableGetMethod<string, Opaque<"node">> };
     /**
      * gets the node type
      *
@@ -1224,22 +1087,6 @@ declare global {
      * Hides the on-display touch keyboard on the device.
      */
     function hide_keyboard(): void;
-    /**
-     * This is a callback-function, which is called by the engine when a gui component is initialized. It can be used
-     * to set the initial state of the script and gui scene.
-     *
-     * @param self - script instance used for storing state
-     * @example
-     * ```ts
-     * export default defineScript({
-     *   init() {
-     *     // set up useful data
-     *     return { my_value: 1 };
-     *   },
-     * });
-     * ```
-     */
-    function init(self: unknown): void;
     /**
      * Returns `true` if a node is enabled and `false` if it's not.
      * Disabled nodes are not rendered and animations acting on them are not evaluated.
@@ -1357,76 +1204,66 @@ declare global {
      * }
      * ```
      */
-    function new_texture(texture_id: string | Hash, width: number, height: number, type: string | image.TYPE, buffer: string, flip?: boolean): LuaMultiReturn<[boolean, gui.RESULT | undefined]>;
-    /**
-     * This is a callback-function, which is called by the engine when user input is sent to the instance of the gui component.
-     * It can be used to take action on the input, e.g. modify the gui according to the input.
-     * For an instance to obtain user input, it must first acquire input
-     * focus through the message `acquire_input_focus`.
-     * Any instance that has obtained input will be put on top of an
-     * input stack. Input is sent to all listeners on the stack until the
-     * end of stack is reached, or a listener returns `true`
-     * to signal that it wants input to be consumed.
-     * See the documentation of acquire_input_focus for more
-     * information.
-     *
-     * @param self - script instance used for storing state
-     * @param action_id - id of the received input action, as mapped in the input_binding-file, or `nil` for mouse movement
-     * @param action - input data for the action. **0️⃣ `gamepad` is 0-based; passed to Defold unchanged.**
-     * @returns optional boolean to signal if the input should be consumed (not passed on to others) or not, default is false
+    function new_texture(texture_id: string | Hash, width: number, height: number, type: string | image.TYPE, buffer: string): LuaMultiReturn<[boolean, gui.RESULT | undefined]>;
+    /**
+     * Dynamically create a new texture.
+     *
+     * @param texture_id - texture id
+     * @param width - texture width
+     * @param height - texture height
+     * @param type - texture type
+     *
+     * - `"rgb"` or `image.TYPE_RGB` - RGB
+     * - `"rgba"` or `image.TYPE_RGBA` - RGBA
+     * - `"l"` or `image.TYPE_LUMINANCE` - LUMINANCE
+     * - `"astc"` - ASTC compressed format
+     * @param buffer - texture data
+     * @param flip - flip texture vertically
      * @example
+     * How to create a texture and apply it to a new box node:
      * ```ts
      * export default defineGuiScript({
-     *   init(): { my_value: number | undefined } {
-     *     return { my_value: undefined };
-     *   },
+     *   init(self) {
+     *     const w = 200;
+     *     const h = 300;
      *
-     *   on_input(self, action_id, action) {
-     *     // check for input
-     *     if (action_id === hash("my_action")) {
-     *       // take appropriate action
-     *       self.my_value = action.value;
+     *     // A nice orange. String with the RGB values.
+     *     const orange = String.fromCharCode(0xff, 0x80, 0x10);
+     *
+     *     // Create the texture. Repeat the color string for each pixel.
+     *     const [ok, reason] = gui.new_texture("orange_tx", w, h, "rgb", orange.repeat(w * h));
+     *     if (ok) {
+     *       // Create a box node and apply the texture to it.
+     *       const n = gui.new_box_node(vmath.vector3(200, 200, 0), vmath.vector3(w, h, 0));
+     *       gui.set_texture(n, "orange_tx");
+     *     } else {
+     *       // Could not create texture for some reason...
+     *       if (reason === gui.RESULT_TEXTURE_ALREADY_EXISTS) {
+     *         // ...
+     *       } else {
+     *         // ...
+     *       }
      *     }
-     *     // consume input
-     *     return true;
      *   },
      * });
      * ```
-     */
-    function on_input(self: unknown, action_id: Hash | undefined, action: go.on_input.action): boolean | undefined;
-    /**
-     * This is a callback-function, which is called by the engine whenever a message has been sent to the gui component.
-     * It can be used to take action on the message, e.g. update the gui or send a response back to the sender of the message.
-     * The `message` parameter is a table containing the message data. If the message is sent from the engine, the
-     * documentation of the message specifies which data is supplied.
-     * See the update function for examples on how to use this callback-function.
-     *
-     * @param self - script instance used for storing state
-     * @param message_id - id of the received message
-     * @param message - a table containing the message data
-     * @param sender - address of the sender
-     */
-    function on_message(self: unknown, message_id: Hash, message: LuaMap<AnyNotNil, unknown> | Record<string, unknown>, sender: Url): void;
-    /**
-     * This is a callback-function, which is called by the engine when the gui script is reloaded, e.g. from the editor.
-     * It can be used for live development, e.g. to tweak constants or set up the state properly for the script.
-     *
-     * @param self - script instance used for storing state
      * @example
+     * How to create a texture using .astc format
      * ```ts
-     * export default defineGuiScript({
-     *   init() {
-     *     return { my_original_color: gui.get_color(gui.get_node("my_node")) };
-     *   },
-     *
-     *   on_reload(self) {
-     *     // restore some color (or similar)
-     *     gui.set_color(gui.get_node("my_node"), self.my_original_color);
-     *   },
-     * });
+     * const size = 4;
+     * const pos = vmath.vector3(200, 200, 0);
+     * const path = "/assets/images/logo_4x4.astc";
+     * const [data] = sys.load_resource(path);
+     * if (data !== undefined) {
+     *   const n = gui.new_box_node(pos, vmath.vector3(size, size, 0));
+     *   // size is read from the .astc buffer
+     *   // flip is not supported
+     *   gui.new_texture(path, 0, 0, "astc", data, false);
+     *   gui.set_texture(n, path);
+     * }
      * ```
      */
-    function on_reload(self: unknown): void;
+    function new_texture(texture_id: string | Hash, width: number, height: number, type: string | image.TYPE, buffer: string, flip: boolean): LuaMultiReturn<[boolean, gui.RESULT | undefined]>;
     /**
      * Tests whether a coordinate is within the bounding box of a
      * node.
@@ -1479,7 +1316,50 @@ declare global {
      * gui.play_flipbook(node, "button");
      * ```
      */
-    function play_flipbook(node: Opaque<"node">, animation: string | Hash, complete_function?: (self: unknown, node: Opaque<"node">) => void, play_properties?: gui.play_properties): void;
+    function play_flipbook(node: Opaque<"node">, animation: string | Hash, complete_function?: (self: unknown, node: Opaque<"node">) => void): void;
+    /**
+     * Play flipbook animation on a box or pie node.
+     * The current node texture must contain the animation.
+     * Use this function to set one-frame still images on the node.
+     *
+     * @param node - node to set animation for
+     * @param animation - animation id
+     * @param complete_function - optional function to call when the animation has completed
+     *
+     * `self`
+     *
+     * script_instance The current script instance.
+     *
+     * `node`
+     *
+     * node The node that is animated.
+     * @param play_properties - optional playback properties
+     * @example
+     * Set the texture of a node to a flipbook animation from an atlas:
+     * ```ts
+     * function anim_callback(self: unknown, node: unknown) {
+     *   // Take action after animation has played.
+     * }
+     *
+     * export default defineGuiScript({
+     *   init(self) {
+     *     // Create a new node and set the texture to a flipbook animation
+     *     const node = gui.get_node("button_node");
+     *     gui.set_texture(node, "gui_sprites");
+     *     gui.play_flipbook(node, "animated_button");
+     *   },
+     * });
+     * ```
+     * @example
+     * Set the texture of a node to an image from an atlas:
+     * ```ts
+     * // Create a new node and set the texture to a "button.png" from atlas
+     * const node = gui.get_node("button_node");
+     * gui.set_texture(node, "gui_sprites");
+     * gui.play_flipbook(node, "button");
+     * ```
+     */
+    function play_flipbook(node: Opaque<"node">, animation: string | Hash, complete_function: ((self: unknown, node: Opaque<"node">) => void) | undefined, play_properties: gui.play_properties): void;
     /**
      * Plays the paricle fx for a gui node
      *
@@ -1557,112 +1437,6 @@ declare global {
      * ```
      */
     function screen_to_local(node: Opaque<"node">, screen_position: Vector3 | Vector4): Vector3;
-    /**
-     * Instead of using specific setteres such as gui.set_position or gui.set_scale,
-     * you can use gui.set instead and supply the property as a string or a hash.
-     * While this function is similar to go.get and go.set, there are a few more restrictions
-     * when operating in the gui namespace. Most notably, only these named properties identifiers are supported:
-     *
-     * - `"position"`
-     * - `"rotation"`
-     * - `"euler"`
-     * - `"scale"`
-     * - `"color"`
-     * - `"outline"`
-     * - `"shadow"`
-     * - `"size"`
-     * - `"fill_angle"` (pie)
-     * - `"inner_radius"` (pie)
-     * - `"leading"` (text)
-     * - `"tracking"` (text)
-     * - `"slice9"` (slice9)
-     *
-     * The value to set must either be a vmath.vector4, vmath.vector3, vmath.quat or a single number and depends on the property name you want to set.
-     * I.e when setting the "position" property, you need to use a vmath.vector4 and when setting a single component of the property,
-     * such as "position.x", you need to use a single value.
-     * Note: When setting the rotation using the "rotation" property, you need to pass in a vmath.quat. This behaviour is different than from the gui.set_rotation function,
-     * the intention is to move new functionality closer to go namespace so that migrating between gui and go is easier. To set the rotation using degrees instead,
-     * use the "euler" property instead. The rotation and euler properties are linked, changing one of them will change the backing data of the other.
-     * Similar to go.set, you can also use gui.set for setting material constant values on a node. E.g if a material has specified a constant called `tint` in
-     * the .material file, you can use gui.set to set the value of that constant by calling `gui.set(node, "tint", vmath.vec4(1,0,0,1))`, or `gui.set(node, "matrix", vmath.matrix4())`
-     * if the constant is a matrix. Arrays are also supported by gui.set - to set an array constant, you need to pass in an options table with the 'index' key set.
-     * If the material has a constant array called 'tint_array' specified in the material, you can use `gui.set(node, "tint_array", vmath.vec4(1,0,0,1), { index = 4})` to set the fourth array element to a different value.
-     *
-     * @param node - node to set the property for, or msg.url() to the gui itself
-     * @param property - the property to set
-     * @param value - the property to set. `nil` is only supported for removing runtime texture mappings with `gui.set(msg.url(), "textures", nil, {key = ...})`.
-     * @param options - optional material-constant options. **⚠️ `index` is 1-based; passed to Defold unchanged.**
-     * @example
-     * Updates the position property on an existing node:
-     * ```ts
-     * const node = gui.get_node("my_box_node");
-     * const node_position = gui.get(node, "position") as Vector3;
-     * gui.set(node, "position.x", node_position.x + 128);
-     * ```
-     * @example
-     * Updates the rotation property on an existing node:
-     * ```ts
-     * const node = gui.get_node("my_box_node");
-     * gui.set(node, "rotation", vmath.quat_rotation_z(math.rad(45)));
-     * // this is equivalent to:
-     * gui.set(node, "euler.z", 45);
-     * // or using the entire vector:
-     * gui.set(node, "euler", vmath.vector3(0, 0, 45));
-     * // or using the set_rotation
-     * gui.set_rotation(node, vmath.vector3(0, 0, 45));
-     * ```
-     * @example
-     * Sets various material constants for a node:
-     * ```ts
-     * const node = gui.get_node("my_box_node");
-     * gui.set(node, "tint", vmath.vector4(1, 0, 0, 1));
-     * // matrix4 is also supported
-     * gui.set(node, "light_matrix", vmath.matrix4());
-     * // update a constant in an array at position 4. the array is specified in the shader as:
-     * // uniform vec4 tint_array[4]; // lua is 1 based, shader is 0 based
-     * gui.set(node, "tint_array", vmath.vector4(1, 0, 0, 1), { index: 4 });
-     * // update a matrix constant in an array at position 4. the array is specified in the shader as:
-     * // uniform mat4 light_matrix_array[4];
-     * gui.set(node, "light_matrix_array", vmath.matrix4(), { index: 4 });
-     * // update a sub-element in a constant
-     * gui.set(node, "tint.x", 1);
-     * // update a sub-element in an array constant at position 4
-     * gui.set(node, "tint_array.x", 1, { index: 4 });
-     * ```
-     * @example
-     * Set a named property
-     * ```ts
-     * export default defineGuiScript({
-     *   on_message(self, message_id, message) {
-     *     if (message_id === hash("set_font") && types.is_hash(message.font)) {
-     *       gui.set(msg.url(), "fonts", message.font, { key: "my_font_name" });
-     *       gui.set_font(gui.get_node("text"), "my_font_name");
-     *     } else if (message_id === hash("set_texture") && types.is_hash(message.texture)) {
-     *       gui.set(msg.url(), "textures", message.texture, { key: "my_texture" });
-     *       gui.set_texture(gui.get_node("box"), "my_texture");
-     *       gui.play_flipbook(gui.get_node("box"), "logo_256");
-     *     }
-     *   },
-     * });
-     * ```
-     * @example
-     * Remove a named runtime texture resource mapping:
-     * ```ts
-     * const atlas_params = {
-     *   texture: "/runtime.texturec",
-     *   animations: [{ id: "runtime", width: 1, height: 1, frames: [1] }],
-     *   geometries: [{ vertices: [0, 0, 0, 1, 1, 1, 1, 0], uvs: [0, 0, 0, 1, 1, 1, 1, 0], indices: [0, 1, 2, 0, 2, 3] }],
-     * } satisfies Parameters<typeof resource.create_atlas>[1];
-     * const atlas_id = resource.create_atlas("/runtime.texturesetc", atlas_params);
-     * gui.set(msg.url(), "textures", atlas_id, { key: "runtime_texture" });
-     * gui.set_texture(gui.get_node("box"), "runtime_texture");
-     *
-     * // Later, remove the GUI mapping before releasing the atlas resource.
-     * gui.set(msg.url(), "textures", undefined, { key: "runtime_texture" });
-     * resource.release(atlas_id);
-     * ```
-     */
-    function set(node: Opaque<"node"> | Url, property: string | Hash | gui.PROP, value: number | Vector4 | Vector3 | Quaternion | Matrix4 | Hash | undefined, options?: { index?: number; key?: string | Hash; keys?: (Hash | string)[] }): void;
     /**
      * Sets the adjust mode on a node.
      * The adjust mode defines how the node will adjust itself to screen
@@ -2081,7 +1855,52 @@ declare global {
      * });
      * ```
      */
-    function set_texture_data(texture: string | Hash, width: number, height: number, type: string | image.TYPE, buffer: string, flip?: boolean): boolean;
+    function set_texture_data(texture: string | Hash, width: number, height: number, type: string | image.TYPE, buffer: string): boolean;
+    /**
+     * Set the texture buffer data for a dynamically created texture.
+     *
+     * @param texture - texture id
+     * @param width - texture width
+     * @param height - texture height
+     * @param type - texture type
+     *
+     * - `"rgb"` or `image.TYPE_RGB` - RGB
+     * - `"rgba"` or `image.TYPE_RGBA` - RGBA
+     * - `"l"` or `image.TYPE_LUMINANCE` - LUMINANCE
+     * - `"astc"` - ASTC compressed format
+     * @param buffer - texture data
+     * @param flip - flip texture vertically
+     * @returns setting the data was successful
+     * @example
+     * ```ts
+     * export default defineGuiScript({
+     *   init(self) {
+     *     const w = 200;
+     *     const h = 300;
+     *
+     *     // Create a dynamic texture, all white.
+     *     if (gui.new_texture("dynamic_tx", w, h, "rgb", String.fromCharCode(0xff).repeat(w * h * 3))) {
+     *       // Create a box node and apply the texture to it.
+     *       const n = gui.new_box_node(vmath.vector3(200, 200, 0), vmath.vector3(w, h, 0));
+     *       gui.set_texture(n, "dynamic_tx");
+     *
+     *       // ...
+     *
+     *       // Change the data in the texture to a nice orange.
+     *       const orange = String.fromCharCode(0xff, 0x80, 0x10);
+     *       if (gui.set_texture_data("dynamic_tx", w, h, "rgb", orange.repeat(w * h))) {
+     *         // Go on and to more stuff
+     *         // ...
+     *       }
+     *     } else {
+     *       // Something went wrong
+     *       // ...
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function set_texture_data(texture: string | Hash, width: number, height: number, type: string | image.TYPE, buffer: string, flip: boolean): boolean;
     /**
      * Sets the tracking value of a text node. This value is used to
      * adjust the vertical spacing of characters in the text.
@@ -2135,56 +1954,14 @@ declare global {
      * @param node - node to stop particle fx for
      * @param options - options used when stopping the particle fx
      */
-    function stop_particlefx(node: Opaque<"node">, options?: particlefx.stop_options): void;
+    function stop_particlefx(node: Opaque<"node">): void;
     /**
-     * This is a callback-function, which is called by the engine every frame to update the state of a gui component.
-     * It can be used to perform any kind of gui related tasks, e.g. animating nodes.
-     *
-     * @param self - script instance used for storing state
-     * @param dt - the time-step of the frame update
-     * @example
-     * ```ts
-     * // This example demonstrates how to update a text node that displays game score
-     * // in a counting fashion. It is assumed that the gui component receives messages
-     * // from the game when a new score is to be shown.
-     * export default defineGuiScript({
-     *   init() {
-     *     return {
-     *       // fetch the score text node for later use (assumes it is called "score")
-     *       score_node: gui.get_node("score"),
-     *       // keep track of the current score counted up so far
-     *       current_score: 0,
-     *       // keep track of the target score we should count up to
-     *       target_score: 0,
-     *       // how fast we will update the score, in score/second
-     *       score_update_speed: 1,
-     *     };
-     *   },
-     *
-     *   update(self, dt) {
-     *     // check if target score is more than current score
-     *     if (self.current_score < self.target_score) {
-     *       // increment current score according to the speed
-     *       self.current_score = self.current_score + dt * self.score_update_speed;
-     *       // check if we went past the target score, clamp current score in that case
-     *       if (self.current_score > self.target_score) {
-     *         self.current_score = self.target_score;
-     *       }
-     *       // update the score text node
-     *       gui.set_text(self.score_node, "" + math.floor(self.current_score));
-     *     }
-     *   },
+     * Stops the particle fx for a gui node
      *
-     *   on_message(self, message_id, message) {
-     *     // check the message
-     *     if (message_id === hash("set_score") && typeof message.score === "number") {
-     *       self.target_score = message.score;
-     *     }
-     *   },
-     * });
-     * ```
+     * @param node - node to stop particle fx for
+     * @param options - options used when stopping the particle fx
      */
-    function update(self: unknown, dt: number): void;
+    function stop_particlefx(node: Opaque<"node">, options: particlefx.stop_options): void;
     interface properties {
       /**
        * The fonts used in the gui. The type of the property is hash.

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

@@ -1,5 +1,5 @@
 /** @noSelfInFile */
-import type { Hash } from "../../../src/core-types";
+import type { Hash, Url } from "../../../src/core-types";
 
 declare global {
   /**
@@ -78,7 +78,7 @@ declare global {
      * });
      * ```
      */
-    function request(url: string, method: string, callback: (self: unknown, id: Hash, response: { status: number; url: string; response?: string; headers?: LuaMap<string, string>; path?: string; error?: string; bytes_sent?: number; 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;
+    function request(url: string, method: string, callback: (self: unknown, id: Hash, response: { status: number; url: string; response?: string; headers?: LuaMap<string, string>; path?: string; error?: string; bytes_sent?: number; bytes_received?: number; bytes_total?: number; range_start?: number; range_end?: number; document_size?: number }, sender: Url) => void, headers?: LuaMap<string, string> | Record<string, string>, post_data?: string, options?: http.request_options): void;
   }
 }