@defold-typescript/types 0.51.0 → 0.53.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 {
   /**
@@ -9,7 +9,7 @@ declare global {
     /**
      * Rich-text layout object
      */
-    interface layout_object {
+    interface LayoutObject {
       /**
        * object type, currently `link` or `sprite`
        */
@@ -47,11 +47,11 @@ declare global {
        */
       attributes: LuaTable<string, string>;
     }
-    type node = Opaque<"node">;
+    type Node = Opaque<"node">;
     /**
      * GUI flipbook playback properties
      */
-    interface play_properties {
+    interface PlayProperties {
       /**
        * Normalized initial animation cursor.
        */
@@ -64,7 +64,7 @@ declare global {
     /**
      * Generic GUI property options
      */
-    interface set_options {
+    interface SetOptions {
       /**
        * One-based material-constant array index.
        */
@@ -74,34 +74,20 @@ declare global {
        */
       key?: string | Hash;
     }
-    type AdjustMode = typeof gui.ADJUST_FIT | typeof gui.ADJUST_ZOOM | typeof gui.ADJUST_STRETCH;
-    type BlendMode = typeof gui.BLEND_ALPHA | typeof gui.BLEND_ADD | typeof gui.BLEND_ADD_ALPHA | typeof gui.BLEND_MULT | typeof gui.BLEND_SCREEN;
+    type Adjust = typeof gui.ADJUST_FIT | typeof gui.ADJUST_STRETCH | typeof gui.ADJUST_ZOOM;
+    type Anchor = typeof gui.ANCHOR_BOTTOM | typeof gui.ANCHOR_LEFT | typeof gui.ANCHOR_NONE | typeof gui.ANCHOR_RIGHT | typeof gui.ANCHOR_TOP;
+    type Blend = typeof gui.BLEND_ADD | typeof gui.BLEND_ADD_ALPHA | typeof gui.BLEND_ALPHA | typeof gui.BLEND_MULT | typeof gui.BLEND_SCREEN;
     type ClippingMode = typeof gui.CLIPPING_MODE_NONE | typeof gui.CLIPPING_MODE_STENCIL;
     type Easing = typeof gui.EASING_INBACK | typeof gui.EASING_INBOUNCE | typeof gui.EASING_INCIRC | typeof gui.EASING_INCUBIC | typeof gui.EASING_INELASTIC | typeof gui.EASING_INEXPO | typeof gui.EASING_INOUTBACK | typeof gui.EASING_INOUTBOUNCE | typeof gui.EASING_INOUTCIRC | typeof gui.EASING_INOUTCUBIC | typeof gui.EASING_INOUTELASTIC | typeof gui.EASING_INOUTEXPO | typeof gui.EASING_INOUTQUAD | typeof gui.EASING_INOUTQUART | typeof gui.EASING_INOUTQUINT | typeof gui.EASING_INOUTSINE | typeof gui.EASING_INQUAD | typeof gui.EASING_INQUART | typeof gui.EASING_INQUINT | typeof gui.EASING_INSINE | typeof gui.EASING_LINEAR | typeof gui.EASING_OUTBACK | typeof gui.EASING_OUTBOUNCE | typeof gui.EASING_OUTCIRC | typeof gui.EASING_OUTCUBIC | typeof gui.EASING_OUTELASTIC | typeof gui.EASING_OUTEXPO | typeof gui.EASING_OUTINBACK | typeof gui.EASING_OUTINBOUNCE | typeof gui.EASING_OUTINCIRC | typeof gui.EASING_OUTINCUBIC | typeof gui.EASING_OUTINELASTIC | typeof gui.EASING_OUTINEXPO | typeof gui.EASING_OUTINQUAD | typeof gui.EASING_OUTINQUART | typeof gui.EASING_OUTINQUINT | typeof gui.EASING_OUTINSINE | typeof gui.EASING_OUTQUAD | typeof gui.EASING_OUTQUART | typeof gui.EASING_OUTQUINT | typeof gui.EASING_OUTSINE;
     type KeyboardType = typeof gui.KEYBOARD_TYPE_DEFAULT | typeof gui.KEYBOARD_TYPE_EMAIL | typeof gui.KEYBOARD_TYPE_NUMBER_PAD | typeof gui.KEYBOARD_TYPE_PASSWORD;
-    type NodeType = typeof gui.TYPE_BOX | typeof gui.TYPE_TEXT | typeof gui.TYPE_PIE | typeof gui.TYPE_PARTICLEFX | typeof gui.TYPE_CUSTOM;
-    type PieBounds = typeof gui.PIEBOUNDS_RECTANGLE | typeof gui.PIEBOUNDS_ELLIPSE;
-    type Pivot = typeof gui.PIVOT_CENTER | typeof gui.PIVOT_N | typeof gui.PIVOT_NE | typeof gui.PIVOT_E | typeof gui.PIVOT_SE | typeof gui.PIVOT_S | typeof gui.PIVOT_SW | typeof gui.PIVOT_W | typeof gui.PIVOT_NW;
-    type Playback = typeof gui.PLAYBACK_ONCE_FORWARD | typeof gui.PLAYBACK_ONCE_BACKWARD | typeof gui.PLAYBACK_ONCE_PINGPONG | typeof gui.PLAYBACK_LOOP_FORWARD | typeof gui.PLAYBACK_LOOP_BACKWARD | typeof gui.PLAYBACK_LOOP_PINGPONG;
-    type Property = typeof gui.PROP_POSITION | typeof gui.PROP_ROTATION | typeof gui.PROP_EULER | typeof gui.PROP_SCALE | typeof gui.PROP_COLOR | typeof gui.PROP_OUTLINE | typeof gui.PROP_SHADOW | typeof gui.PROP_SIZE | typeof gui.PROP_FILL_ANGLE | typeof gui.PROP_INNER_RADIUS | typeof gui.PROP_LEADING | typeof gui.PROP_TRACKING | typeof gui.PROP_SLICE9;
-    type SafeAreaMode = typeof gui.SAFE_AREA_NONE | typeof gui.SAFE_AREA_LONG | typeof gui.SAFE_AREA_SHORT | typeof gui.SAFE_AREA_BOTH;
-    type SizeMode = typeof gui.SIZE_MODE_MANUAL | typeof gui.SIZE_MODE_AUTO;
-    type XAnchor = typeof gui.ANCHOR_NONE | typeof gui.ANCHOR_LEFT | typeof gui.ANCHOR_RIGHT;
-    type YAnchor = typeof gui.ANCHOR_NONE | typeof gui.ANCHOR_TOP | typeof gui.ANCHOR_BOTTOM;
-    type ADJUST = typeof gui.ADJUST_FIT | typeof gui.ADJUST_STRETCH | typeof gui.ADJUST_ZOOM;
-    type ANCHOR = typeof gui.ANCHOR_BOTTOM | typeof gui.ANCHOR_LEFT | typeof gui.ANCHOR_NONE | typeof gui.ANCHOR_RIGHT | typeof gui.ANCHOR_TOP;
-    type BLEND = typeof gui.BLEND_ADD | typeof gui.BLEND_ADD_ALPHA | typeof gui.BLEND_ALPHA | typeof gui.BLEND_MULT | typeof gui.BLEND_SCREEN;
-    type CLIPPING_MODE = typeof gui.CLIPPING_MODE_NONE | typeof gui.CLIPPING_MODE_STENCIL;
-    type EASING = typeof gui.EASING_INBACK | typeof gui.EASING_INBOUNCE | typeof gui.EASING_INCIRC | typeof gui.EASING_INCUBIC | typeof gui.EASING_INELASTIC | typeof gui.EASING_INEXPO | typeof gui.EASING_INOUTBACK | typeof gui.EASING_INOUTBOUNCE | typeof gui.EASING_INOUTCIRC | typeof gui.EASING_INOUTCUBIC | typeof gui.EASING_INOUTELASTIC | typeof gui.EASING_INOUTEXPO | typeof gui.EASING_INOUTQUAD | typeof gui.EASING_INOUTQUART | typeof gui.EASING_INOUTQUINT | typeof gui.EASING_INOUTSINE | typeof gui.EASING_INQUAD | typeof gui.EASING_INQUART | typeof gui.EASING_INQUINT | typeof gui.EASING_INSINE | typeof gui.EASING_LINEAR | typeof gui.EASING_OUTBACK | typeof gui.EASING_OUTBOUNCE | typeof gui.EASING_OUTCIRC | typeof gui.EASING_OUTCUBIC | typeof gui.EASING_OUTELASTIC | typeof gui.EASING_OUTEXPO | typeof gui.EASING_OUTINBACK | typeof gui.EASING_OUTINBOUNCE | typeof gui.EASING_OUTINCIRC | typeof gui.EASING_OUTINCUBIC | typeof gui.EASING_OUTINELASTIC | typeof gui.EASING_OUTINEXPO | typeof gui.EASING_OUTINQUAD | typeof gui.EASING_OUTINQUART | typeof gui.EASING_OUTINQUINT | typeof gui.EASING_OUTINSINE | typeof gui.EASING_OUTQUAD | typeof gui.EASING_OUTQUART | typeof gui.EASING_OUTQUINT | typeof gui.EASING_OUTSINE;
-    type KEYBOARD_TYPE = typeof gui.KEYBOARD_TYPE_DEFAULT | typeof gui.KEYBOARD_TYPE_EMAIL | typeof gui.KEYBOARD_TYPE_NUMBER_PAD | typeof gui.KEYBOARD_TYPE_PASSWORD;
-    type PIEBOUNDS = typeof gui.PIEBOUNDS_ELLIPSE | typeof gui.PIEBOUNDS_RECTANGLE;
-    type PIVOT = typeof gui.PIVOT_CENTER | typeof gui.PIVOT_E | typeof gui.PIVOT_N | typeof gui.PIVOT_NE | typeof gui.PIVOT_NW | typeof gui.PIVOT_S | typeof gui.PIVOT_SE | typeof gui.PIVOT_SW | typeof gui.PIVOT_W;
-    type PLAYBACK = typeof gui.PLAYBACK_LOOP_BACKWARD | typeof gui.PLAYBACK_LOOP_FORWARD | typeof gui.PLAYBACK_LOOP_PINGPONG | typeof gui.PLAYBACK_ONCE_BACKWARD | typeof gui.PLAYBACK_ONCE_FORWARD | typeof gui.PLAYBACK_ONCE_PINGPONG;
-    type PROP = typeof gui.PROP_COLOR | typeof gui.PROP_EULER | typeof gui.PROP_FILL_ANGLE | typeof gui.PROP_INNER_RADIUS | typeof gui.PROP_LEADING | typeof gui.PROP_OUTLINE | typeof gui.PROP_POSITION | typeof gui.PROP_ROTATION | typeof gui.PROP_SCALE | typeof gui.PROP_SHADOW | typeof gui.PROP_SIZE | typeof gui.PROP_SLICE9 | typeof gui.PROP_TRACKING;
-    type RESULT = typeof gui.RESULT_DATA_ERROR | typeof gui.RESULT_OUT_OF_RESOURCES | typeof gui.RESULT_TEXTURE_ALREADY_EXISTS;
-    type SAFE_AREA = typeof gui.SAFE_AREA_BOTH | typeof gui.SAFE_AREA_LONG | typeof gui.SAFE_AREA_NONE | typeof gui.SAFE_AREA_SHORT;
-    type SIZE_MODE = typeof gui.SIZE_MODE_AUTO | typeof gui.SIZE_MODE_MANUAL;
-    type TYPE = typeof gui.TYPE_BOX | typeof gui.TYPE_CUSTOM | typeof gui.TYPE_PARTICLEFX | typeof gui.TYPE_PIE | typeof gui.TYPE_TEXT;
+    type PieBounds = typeof gui.PIEBOUNDS_ELLIPSE | typeof gui.PIEBOUNDS_RECTANGLE;
+    type Pivot = typeof gui.PIVOT_CENTER | typeof gui.PIVOT_E | typeof gui.PIVOT_N | typeof gui.PIVOT_NE | typeof gui.PIVOT_NW | typeof gui.PIVOT_S | typeof gui.PIVOT_SE | typeof gui.PIVOT_SW | typeof gui.PIVOT_W;
+    type Playback = typeof gui.PLAYBACK_LOOP_BACKWARD | typeof gui.PLAYBACK_LOOP_FORWARD | typeof gui.PLAYBACK_LOOP_PINGPONG | typeof gui.PLAYBACK_ONCE_BACKWARD | typeof gui.PLAYBACK_ONCE_FORWARD | typeof gui.PLAYBACK_ONCE_PINGPONG;
+    type Prop = typeof gui.PROP_COLOR | typeof gui.PROP_EULER | typeof gui.PROP_FILL_ANGLE | typeof gui.PROP_INNER_RADIUS | typeof gui.PROP_LEADING | typeof gui.PROP_OUTLINE | typeof gui.PROP_POSITION | typeof gui.PROP_ROTATION | typeof gui.PROP_SCALE | typeof gui.PROP_SHADOW | typeof gui.PROP_SIZE | typeof gui.PROP_SLICE9 | typeof gui.PROP_TRACKING;
+    type Result = typeof gui.RESULT_DATA_ERROR | typeof gui.RESULT_OUT_OF_RESOURCES | typeof gui.RESULT_TEXTURE_ALREADY_EXISTS;
+    type SafeArea = typeof gui.SAFE_AREA_BOTH | typeof gui.SAFE_AREA_LONG | typeof gui.SAFE_AREA_NONE | typeof gui.SAFE_AREA_SHORT;
+    type SizeMode = typeof gui.SIZE_MODE_AUTO | typeof gui.SIZE_MODE_MANUAL;
+    type Type = typeof gui.TYPE_BOX | typeof gui.TYPE_CUSTOM | typeof gui.TYPE_PARTICLEFX | typeof gui.TYPE_PIE | typeof gui.TYPE_TEXT;
     /**
      * fit adjust mode Adjust mode is used when the screen resolution differs from the project settings. The fit mode ensures that the entire node is visible in the adjusted gui scene.
      */
@@ -518,83 +504,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.
      *
@@ -638,7 +547,7 @@ declare global {
      * gui.cancel_animations(node);
      * ```
      */
-    function cancel_animations(node: Opaque<"node">, property?: string | Hash | gui.PROP): void;
+    function cancel_animations(node: Opaque<"node">, property?: string | Hash | gui.Prop): void;
     /**
      * Cancels any running flipbook animation on the specified node.
      *
@@ -665,10 +574,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 +612,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
@@ -771,7 +620,7 @@ declare global {
      * @param node - node from which to get the adjust mode (node)
      * @returns the current adjust mode
      */
-    function get_adjust_mode(node: Opaque<"node">): gui.ADJUST;
+    function get_adjust_mode(node: Opaque<"node">): gui.Adjust;
     /**
      * gets the node alpha
      *
@@ -786,7 +635,7 @@ declare global {
      * @param node - node from which to get the blend mode
      * @returns blend mode
      */
-    function get_blend_mode(node: Opaque<"node">): gui.BLEND;
+    function get_blend_mode(node: Opaque<"node">): gui.Blend;
     /**
      * If node is set as an inverted clipping node, it will clip anything inside as opposed to outside.
      *
@@ -803,7 +652,7 @@ declare global {
      * - `gui.CLIPPING_MODE_NONE`
      * - `gui.CLIPPING_MODE_STENCIL`
      */
-    function get_clipping_mode(node: Opaque<"node">): gui.CLIPPING_MODE;
+    function get_clipping_mode(node: Opaque<"node">): gui.ClippingMode;
     /**
      * If node is set as visible clipping node, it will be shown as well as clipping. Otherwise, it will only clip but not show visually.
      *
@@ -974,7 +823,7 @@ declare global {
      * @param node - text node to inspect
      * @returns layout objects in source order. **0️⃣ `text_offset` is 0-based; passed to Defold unchanged.**
      */
-    function get_layout_objects(node: Opaque<"node">): gui.layout_object[];
+    function get_layout_objects(node: Opaque<"node">): gui.LayoutObject[];
     /**
      * Returns a table mapping each layout id hash to a vector3(width, height, 0). For the default layout,
      * the current scene resolution is returned. If a layout name is not present in the Display Profiles (or when
@@ -1034,7 +883,7 @@ declare global {
      * @param node - node from where to get the outer bounds mode
      * @returns the outer bounds mode of the pie node
      */
-    function get_outer_bounds(node: Opaque<"node">): gui.PIEBOUNDS;
+    function get_outer_bounds(node: Opaque<"node">): gui.PieBounds;
     /**
      * Returns the outline color of the supplied node.
      * See gui.get_color for info how vectors encode color values.
@@ -1082,7 +931,7 @@ declare global {
      * - `gui.PIVOT_W`
      * - `gui.PIVOT_NW`
      */
-    function get_pivot(node: Opaque<"node">): gui.PIVOT;
+    function get_pivot(node: Opaque<"node">): gui.Pivot;
     /**
      * Returns the position of the supplied node.
      *
@@ -1140,7 +989,7 @@ declare global {
      * @param node - node from which to get the size mode (node)
      * @returns the current size mode
      */
-    function get_size_mode(node: Opaque<"node">): gui.SIZE_MODE;
+    function get_size_mode(node: Opaque<"node">): gui.SizeMode;
     /**
      * Returns the slice9 configuration values for the node.
      *
@@ -1174,16 +1023,16 @@ 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
      *
      * @param node - node from which to get the type
      */
-    function get_type(node: Opaque<"node">): LuaMultiReturn<[gui.TYPE, number | undefined]>;
+    function get_type(node: Opaque<"node">): LuaMultiReturn<[gui.Type, number | undefined]>;
     /**
      * Returns `true` if a node is visible and `false` if it's not.
      * Invisible nodes are not rendered.
@@ -1208,7 +1057,7 @@ declare global {
      * - `gui.ANCHOR_LEFT`
      * - `gui.ANCHOR_RIGHT`
      */
-    function get_xanchor(node: Opaque<"node">): gui.ANCHOR;
+    function get_xanchor(node: Opaque<"node">): Exclude<gui.Anchor, typeof gui.ANCHOR_BOTTOM | typeof gui.ANCHOR_TOP>;
     /**
      * The y-anchor specifies how the node is moved when the game is run in a different resolution.
      *
@@ -1219,27 +1068,11 @@ declare global {
      * - `gui.ANCHOR_TOP`
      * - `gui.ANCHOR_BOTTOM`
      */
-    function get_yanchor(node: Opaque<"node">): gui.ANCHOR;
+    function get_yanchor(node: Opaque<"node">): Exclude<gui.Anchor, typeof gui.ANCHOR_LEFT | typeof gui.ANCHOR_RIGHT>;
     /**
      * 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 +1190,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 +1302,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.PlayProperties): void;
     /**
      * Plays the paricle fx for a gui node
      *
@@ -1501,7 +1367,7 @@ declare global {
      * });
      * ```
      */
-    function play_particlefx(node: Opaque<"node">, emitter_state_function?: (self: unknown, node: Opaque<"node"> | undefined, emitter: Hash, state: particlefx.EMITTER_STATE) => void): void;
+    function play_particlefx(node: Opaque<"node">, emitter_state_function?: (self: unknown, node: Opaque<"node"> | undefined, emitter: Hash, state: particlefx.EmitterState) => void): void;
     /**
      * Resets the input context of keyboard. This will clear marked text.
      */
@@ -1557,112 +1423,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
@@ -1671,7 +1431,7 @@ declare global {
      * @param node - node to set adjust mode for
      * @param adjust_mode - adjust mode to set
      */
-    function set_adjust_mode(node: Opaque<"node">, adjust_mode: gui.ADJUST): void;
+    function set_adjust_mode(node: Opaque<"node">, adjust_mode: gui.Adjust): void;
     /**
      * sets the node alpha
      *
@@ -1686,7 +1446,7 @@ declare global {
      * @param node - node to set blend mode for
      * @param blend_mode - blend mode to set
      */
-    function set_blend_mode(node: Opaque<"node">, blend_mode: gui.BLEND): void;
+    function set_blend_mode(node: Opaque<"node">, blend_mode: gui.Blend): void;
     /**
      * If node is set as an inverted clipping node, it will clip anything inside as opposed to outside.
      *
@@ -1703,7 +1463,7 @@ declare global {
      * - `gui.CLIPPING_MODE_NONE`
      * - `gui.CLIPPING_MODE_STENCIL`
      */
-    function set_clipping_mode(node: Opaque<"node">, clipping_mode: gui.CLIPPING_MODE): void;
+    function set_clipping_mode(node: Opaque<"node">, clipping_mode: gui.ClippingMode): void;
     /**
      * If node is set as an visible clipping node, it will be shown as well as clipping. Otherwise, it will only clip but not show visually.
      *
@@ -1867,7 +1627,7 @@ declare global {
      * @param node - node for which to set the outer bounds mode
      * @param bounds_mode - the outer bounds mode of the pie node
      */
-    function set_outer_bounds(node: Opaque<"node">, bounds_mode: gui.PIEBOUNDS): void;
+    function set_outer_bounds(node: Opaque<"node">, bounds_mode: gui.PieBounds): void;
     /**
      * Sets the outline color of the supplied node.
      * See gui.set_color for info how vectors encode color values.
@@ -1914,7 +1674,7 @@ declare global {
      * - `gui.PIVOT_W`
      * - `gui.PIVOT_NW`
      */
-    function set_pivot(node: Opaque<"node">, pivot: gui.PIVOT): void;
+    function set_pivot(node: Opaque<"node">, pivot: gui.Pivot): void;
     /**
      * Sets the position of the supplied node.
      *
@@ -1945,7 +1705,7 @@ declare global {
      *
      * @param mode - safe area mode
      */
-    function set_safe_area_mode(mode: gui.SAFE_AREA): void;
+    function set_safe_area_mode(mode: gui.SafeArea): void;
     /**
      * Sets the scaling of the supplied node.
      *
@@ -1987,7 +1747,7 @@ declare global {
      * @param node - node to set size mode for
      * @param size_mode - size mode to set
      */
-    function set_size_mode(node: Opaque<"node">, size_mode: gui.SIZE_MODE): void;
+    function set_size_mode(node: Opaque<"node">, size_mode: gui.SizeMode): void;
     /**
      * Set the slice9 configuration values for the node.
      *
@@ -2081,7 +1841,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.
@@ -2107,7 +1912,7 @@ declare global {
      * - `gui.ANCHOR_LEFT`
      * - `gui.ANCHOR_RIGHT`
      */
-    function set_xanchor(node: Opaque<"node">, anchor: gui.ANCHOR): void;
+    function set_xanchor(node: Opaque<"node">, anchor: Exclude<gui.Anchor, typeof gui.ANCHOR_BOTTOM | typeof gui.ANCHOR_TOP>): void;
     /**
      * The y-anchor specifies how the node is moved when the game is run in a different resolution.
      *
@@ -2118,7 +1923,7 @@ declare global {
      * - `gui.ANCHOR_TOP`
      * - `gui.ANCHOR_BOTTOM`
      */
-    function set_yanchor(node: Opaque<"node">, anchor: gui.ANCHOR): void;
+    function set_yanchor(node: Opaque<"node">, anchor: Exclude<gui.Anchor, typeof gui.ANCHOR_LEFT | typeof gui.ANCHOR_RIGHT>): void;
     /**
      * Shows the on-display touch keyboard.
      * The specified type of keyboard is displayed if it is available on
@@ -2128,64 +1933,22 @@ declare global {
      * @param type - keyboard type
      * @param autoclose - if the keyboard should automatically close when clicking outside
      */
-    function show_keyboard(type: gui.KEYBOARD_TYPE, autoclose: boolean): void;
+    function show_keyboard(type: gui.KeyboardType, autoclose: boolean): void;
     /**
      * Stops the particle fx for a gui node
      *
      * @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;
-    interface properties {
+    function stop_particlefx(node: Opaque<"node">, options: particlefx.StopOptions): void;
+    interface Properties {
       /**
        * The fonts used in the gui. The type of the property is hash.
        * Key must be specified in options table.