@defold-typescript/types 0.51.0 → 0.52.0

package/generated/versions/defold-1.12.4/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 {
   /**
@@ -443,120 +443,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
-     *
-     * - `"position"`
-     * - `"rotation"`
-     * - `"euler"`
-     * - `"scale"`
-     * - `"color"`
-     * - `"outline"`
-     * - `"shadow"`
-     * - `"size"`
-     * - `"fill_angle"` (pie)
-     * - `"inner_radius"` (pie)
-     * - `"leading"` (text)
-     * - `"tracking"` (text)
-     * - `"slice9"` (slice9)
-     *
-     * The following property constants are defined equaling the corresponding property string names.
-     *
-     * - `gui.PROP_POSITION`
-     * - `gui.PROP_ROTATION`
-     * - `gui.PROP_EULER`
-     * - `gui.PROP_SCALE`
-     * - `gui.PROP_COLOR`
-     * - `gui.PROP_OUTLINE`
-     * - `gui.PROP_SHADOW`
-     * - `gui.PROP_SIZE`
-     * - `gui.PROP_FILL_ANGLE`
-     * - `gui.PROP_INNER_RADIUS`
-     * - `gui.PROP_LEADING`
-     * - `gui.PROP_TRACKING`
-     * - `gui.PROP_SLICE9`
-     * @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
-     *
-     * - `gui.PLAYBACK_ONCE_FORWARD`
-     * - `gui.PLAYBACK_ONCE_BACKWARD`
-     * - `gui.PLAYBACK_ONCE_PINGPONG`
-     * - `gui.PLAYBACK_LOOP_FORWARD`
-     * - `gui.PLAYBACK_LOOP_BACKWARD`
-     * - `gui.PLAYBACK_LOOP_PINGPONG`
-     * @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 | gui.Property | Hash, to: number | Vector3 | Vector4 | Quaternion, easing: gui.Easing | Vector, duration: number, delay?: number, complete_function?: (self: unknown, node: unknown) => 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.
      *
@@ -627,10 +513,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.
@@ -665,66 +551,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 - reference to the script state to be used for storing data
-     * @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: Opaque<"userdata">): 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` number 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.Property, 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
@@ -1143,10 +969,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
      *
@@ -1193,22 +1019,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 - reference to the script state to be used for storing data
-     * @example
-     * ```ts
-     * export default defineScript({
-     *   init() {
-     *     // set up useful data
-     *     return { my_value: 1 };
-     *   },
-     * });
-     * ```
-     */
-    function init(self: Opaque<"userdata">): 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.
@@ -1326,197 +1136,66 @@ declare global {
      * }
      * ```
      */
-    function new_texture(texture_id: string | Hash, width: number, height: number, type: string | Opaque<"constant">, buffer: string, flip?: boolean): LuaMultiReturn<[boolean, number | undefined]>;
+    function new_texture(texture_id: string | Hash, width: number, height: number, type: string | Opaque<"constant">, buffer: string): LuaMultiReturn<[boolean, number | 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.
-     * The `action` parameter is a table containing data about the input mapped to the
-     * `action_id`.
-     * For mapped actions it specifies the value of the input and if it was just pressed or released.
-     * Actions are mapped to input in an input_binding-file.
-     * Mouse movement is specifically handled and uses `nil` as its `action_id`.
-     * The `action` only contains positional parameters in this case, such as x and y of the pointer.
-     * Here is a brief description of the available table fields:
-     *
-     * Field
-     * Description
-     *
-     * `value`
-     * The amount of input given by the user. This is usually 1 for buttons and 0-1 for analogue inputs. This is not present for mouse movement and text input.
-     *
-     * `pressed`
-     * If the input was pressed this frame. This is not present for mouse movement and text input.
-     *
-     * `released`
-     * If the input was released this frame. This is not present for mouse movement and text input.
-     *
-     * `repeated`
-     * If the input was repeated this frame. This is similar to how a key on a keyboard is repeated when you hold it down. This is not present for mouse movement and text input.
-     *
-     * `x`
-     * The x value of a pointer device, if present. This is not present for gamepad, key and text input.
-     *
-     * `y`
-     * The y value of a pointer device, if present. This is not present for gamepad, key and text input.
-     *
-     * `screen_x`
-     * The screen space x value of a pointer device, if present. This is not present for gamepad, key and text input.
-     *
-     * `screen_y`
-     * The screen space y value of a pointer device, if present. This is not present for gamepad, key and text input.
-     *
-     * `dx`
-     * The change in x value of a pointer device, if present. This is not present for gamepad, key and text input.
-     *
-     * `dy`
-     * The change in y value of a pointer device, if present. This is not present for gamepad, key and text input.
-     *
-     * `screen_dx`
-     * The change in screen space x value of a pointer device, if present. This is not present for gamepad, key and text input.
-     *
-     * `screen_dy`
-     * The change in screen space y value of a pointer device, if present. This is not present for gamepad, key and text input.
-     *
-     * `gamepad`
-     * The index of the gamepad device that provided the input. See table below about gamepad input.
-     *
-     * `touch`
-     * List of touch input, one element per finger, if present. See table below about touch input
-     *
-     * `text`
-     * Text input from a (virtual) keyboard or similar.
-     *
-     * `marked_text`
-     * Sequence of entered symbols while entering a symbol combination, for example Japanese Kana.
-     *
-     * Gamepad specific fields:
-     *
-     * Field
-     * Description
-     *
-     * `gamepad`
-     * The index of the gamepad device that provided the input.
-     *
-     * `userid`
-     * Id of the user associated with the controller. Usually only relevant on consoles.
-     *
-     * `gamepad_unknown`
-     * True if the inout originated from an unknown/unmapped gamepad.
-     *
-     * `gamepad_name`
-     * Name of the gamepad
-     *
-     * `gamepad_axis`
-     * List of gamepad axis values. For raw gamepad input only.
-     *
-     * `gamepadhats`
-     * List of gamepad hat values. For raw gamepad input only.
-     *
-     * `gamepad_buttons`
-     * List of gamepad button values. For raw gamepad input only.
-     *
-     * Touch input table:
-     *
-     * Field
-     * Description
-     *
-     * `id`
-     * A number identifying the touch input during its duration.
-     *
-     * `pressed`
-     * True if the finger was pressed this frame.
-     *
-     * `released`
-     * True if the finger was released this frame.
-     *
-     * `tap_count`
-     * Number of taps, one for single, two for double-tap, etc
-     *
-     * `x`
-     * The x touch location.
-     *
-     * `y`
-     * The y touch location.
-     *
-     * `dx`
-     * The change in x value.
-     *
-     * `dy`
-     * The change in y value.
-     *
-     * `acc_x`
-     * Accelerometer x value (if present).
-     *
-     * `acc_y`
-     * Accelerometer y value (if present).
+     * Dynamically create a new texture.
      *
-     * `acc_z`
-     * Accelerometer z value (if present).
+     * @param texture_id - texture id
+     * @param width - texture width
+     * @param height - texture height
+     * @param type - texture type
      *
-     * @param self - reference to the script state to be used for storing data
-     * @param action_id - id of the received input action, as mapped in the input_binding-file
-     * @param action - a table containing the input data, see above for a description. **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
+     * - `"rgb"` - RGB
+     * - `"rgba"` - RGBA
+     * - `"l"` - 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: Opaque<"userdata">, action_id: Hash, action: { value?: number; pressed?: boolean; released?: boolean; repeated?: boolean; x?: number; y?: number; screen_x?: number; screen_y?: number; dx?: number; dy?: number; screen_dx?: number; screen_dy?: number; gamepad?: number; gamepad_axis?: Vector3; touch?: { id?: number; pressed?: boolean; released?: boolean; tap_count?: number; x?: number; y?: number; dx?: number; dy?: number; acc_x?: number; acc_y?: number; acc_z?: number }[]; text?: string }): 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 - reference to the script state to be used for storing data
-     * @param message_id - id of the received message
-     * @param message - a table containing the message data
-     */
-    function on_message(self: Opaque<"userdata">, message_id: Hash, message: Record<string | number, unknown>): 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 - reference to the script state to be used for storing data
      * @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: Opaque<"userdata">): void;
+    function new_texture(texture_id: string | Hash, width: number, height: number, type: string | Opaque<"constant">, buffer: string, flip: boolean): LuaMultiReturn<[boolean, number | undefined]>;
     /**
      * Tests whether a coordinate is within the bounding box of a
      * node.
@@ -1574,7 +1253,55 @@ declare global {
      * gui.play_flipbook(node, "button");
      * ```
      */
-    function play_flipbook(node: Opaque<"node">, animation: string | Hash, complete_function?: (self: unknown, node: unknown) => void, play_properties?: { offset?: number; playback_rate?: number }): void;
+    function play_flipbook(node: Opaque<"node">, animation: string | Hash, complete_function?: (self: unknown, node: unknown) => 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`
+     *
+     * object The current object.
+     *
+     * `node`
+     *
+     * node The node that is animated.
+     * @param play_properties - optional table with properties
+     *
+     * `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
+     * @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: unknown) => void) | undefined, play_properties: { offset?: number; playback_rate?: number }): void;
     /**
      * Plays the paricle fx for a gui node
      *
@@ -1641,100 +1368,6 @@ declare global {
      * @returns local position
      */
     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
-     * @param options - optional options table (only applicable for material constants)
-     * - `index` number index into array property (1 based)
-     * - `key` hash name of internal property
-     *
-     * **⚠️ `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");
-     *     }
-     *   },
-     * });
-     * ```
-     */
-    function set(node: Opaque<"node"> | Url, property: string | Hash | gui.Property, value: number | Vector4 | Vector3 | Quaternion | Matrix4 | Hash, 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
@@ -2174,7 +1807,52 @@ declare global {
      * });
      * ```
      */
-    function set_texture_data(texture: string | Hash, width: number, height: number, type: string | Opaque<"constant">, buffer: string, flip?: boolean): boolean;
+    function set_texture_data(texture: string | Hash, width: number, height: number, type: string | Opaque<"constant">, 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"` - RGB
+     * - `"rgba"` - RGBA
+     * - `"l"` - 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 | Opaque<"constant">, 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.
@@ -2235,56 +1913,16 @@ declare global {
      *
      * - boolean `clear`: instantly clear spawned particles
      */
-    function stop_particlefx(node: Opaque<"node">, options?: { clear?: boolean }): 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 - reference to the script state to be used for storing data
-     * @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,
-     *     };
-     *   },
+     * Stops the particle fx for a gui node
      *
-     *   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));
-     *     }
-     *   },
+     * @param node - node to stop particle fx for
+     * @param options - options when stopping the particle fx. Supported options:
      *
-     *   on_message(self, message_id, message) {
-     *     // check the message
-     *     if (message_id === hash("set_score") && typeof message.score === "number") {
-     *       self.target_score = message.score;
-     *     }
-     *   },
-     * });
-     * ```
+     * - boolean `clear`: instantly clear spawned particles
      */
-    function update(self: Opaque<"userdata">, dt: number): void;
+    function stop_particlefx(node: Opaque<"node">, options: { clear?: boolean }): void;
     interface properties {
       /**
        * The fonts used in the gui. The type of the property is hash.