@defold-typescript/types 0.49.0 → 0.50.0

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

@@ -0,0 +1,2212 @@
+/** @noSelfInFile */
+import type { Hash, Matrix4, Opaque, Quaternion, Url, Vector, Vector3, Vector4 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * GUI API documentation
+   */
+  namespace gui {
+    /**
+     * Rich-text layout object
+     */
+    interface layout_object {
+      /**
+       * object type, currently `link` or `sprite`
+       */
+      type: string;
+      /**
+       * the object's `id` attribute, or its generated layout object id
+       */
+      id: Hash;
+      /**
+       * zero-based UTF-32 offset in the visible text
+       */
+      text_offset: number;
+      /**
+       * visible UTF-32 text length covered by the object
+       */
+      text_length: number;
+      /**
+       * lower-left x-coordinate relative to the text node's upper-left layout origin
+       */
+      x: number;
+      /**
+       * lower-left y-coordinate relative to the text node's upper-left layout origin
+       */
+      y: number;
+      /**
+       * resolved object width
+       */
+      width: number;
+      /**
+       * resolved object height
+       */
+      height: number;
+      /**
+       * markup attributes keyed by name
+       */
+      attributes: LuaTable<string, string>;
+    }
+    type node = Opaque<"node">;
+    /**
+     * GUI flipbook playback properties
+     */
+    interface play_properties {
+      /**
+       * Normalized initial animation cursor.
+       */
+      offset?: number;
+      /**
+       * Positive animation playback rate.
+       */
+      playback_rate?: number;
+    }
+    /**
+     * Generic GUI property options
+     */
+    interface set_options {
+      /**
+       * One-based material-constant array index.
+       */
+      index?: number;
+      /**
+       * Internal property name.
+       */
+      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 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;
+    /**
+     * 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.
+     */
+    const ADJUST_FIT: number & { readonly __brand: "gui.ADJUST_FIT" };
+    /**
+     * stretch adjust mode Adjust mode is used when the screen resolution differs from the project settings. The stretch mode ensures that the node is displayed as is in the adjusted gui scene, which might scale it non-uniformally.
+     */
+    const ADJUST_STRETCH: number & { readonly __brand: "gui.ADJUST_STRETCH" };
+    /**
+     * zoom adjust mode Adjust mode is used when the screen resolution differs from the project settings. The zoom mode ensures that the node fills its entire area and might make the node exceed it.
+     */
+    const ADJUST_ZOOM: number & { readonly __brand: "gui.ADJUST_ZOOM" };
+    /**
+     * bottom y-anchor
+     */
+    const ANCHOR_BOTTOM: number & { readonly __brand: "gui.ANCHOR_BOTTOM" };
+    /**
+     * left x-anchor
+     */
+    const ANCHOR_LEFT: number & { readonly __brand: "gui.ANCHOR_LEFT" };
+    /**
+     * no anchor
+     */
+    const ANCHOR_NONE: number & { readonly __brand: "gui.ANCHOR_NONE" };
+    /**
+     * right x-anchor
+     */
+    const ANCHOR_RIGHT: number & { readonly __brand: "gui.ANCHOR_RIGHT" };
+    /**
+     * top y-anchor
+     */
+    const ANCHOR_TOP: number & { readonly __brand: "gui.ANCHOR_TOP" };
+    /**
+     * additive blending
+     */
+    const BLEND_ADD: number & { readonly __brand: "gui.BLEND_ADD" };
+    /**
+     * additive alpha blending
+     */
+    const BLEND_ADD_ALPHA: number & { readonly __brand: "gui.BLEND_ADD_ALPHA" };
+    /**
+     * alpha blending
+     */
+    const BLEND_ALPHA: number & { readonly __brand: "gui.BLEND_ALPHA" };
+    /**
+     * multiply blending
+     */
+    const BLEND_MULT: number & { readonly __brand: "gui.BLEND_MULT" };
+    /**
+     * screen blending
+     */
+    const BLEND_SCREEN: number & { readonly __brand: "gui.BLEND_SCREEN" };
+    /**
+     * clipping mode none
+     */
+    const CLIPPING_MODE_NONE: number & { readonly __brand: "gui.CLIPPING_MODE_NONE" };
+    /**
+     * clipping mode stencil
+     */
+    const CLIPPING_MODE_STENCIL: number & { readonly __brand: "gui.CLIPPING_MODE_STENCIL" };
+    /**
+     * in-back
+     */
+    const EASING_INBACK: number & { readonly __brand: "gui.EASING_INBACK" };
+    /**
+     * in-bounce
+     */
+    const EASING_INBOUNCE: number & { readonly __brand: "gui.EASING_INBOUNCE" };
+    /**
+     * in-circlic
+     */
+    const EASING_INCIRC: number & { readonly __brand: "gui.EASING_INCIRC" };
+    /**
+     * in-cubic
+     */
+    const EASING_INCUBIC: number & { readonly __brand: "gui.EASING_INCUBIC" };
+    /**
+     * in-elastic
+     */
+    const EASING_INELASTIC: number & { readonly __brand: "gui.EASING_INELASTIC" };
+    /**
+     * in-exponential
+     */
+    const EASING_INEXPO: number & { readonly __brand: "gui.EASING_INEXPO" };
+    /**
+     * in-out-back
+     */
+    const EASING_INOUTBACK: number & { readonly __brand: "gui.EASING_INOUTBACK" };
+    /**
+     * in-out-bounce
+     */
+    const EASING_INOUTBOUNCE: number & { readonly __brand: "gui.EASING_INOUTBOUNCE" };
+    /**
+     * in-out-circlic
+     */
+    const EASING_INOUTCIRC: number & { readonly __brand: "gui.EASING_INOUTCIRC" };
+    /**
+     * in-out-cubic
+     */
+    const EASING_INOUTCUBIC: number & { readonly __brand: "gui.EASING_INOUTCUBIC" };
+    /**
+     * in-out-elastic
+     */
+    const EASING_INOUTELASTIC: number & { readonly __brand: "gui.EASING_INOUTELASTIC" };
+    /**
+     * in-out-exponential
+     */
+    const EASING_INOUTEXPO: number & { readonly __brand: "gui.EASING_INOUTEXPO" };
+    /**
+     * in-out-quadratic
+     */
+    const EASING_INOUTQUAD: number & { readonly __brand: "gui.EASING_INOUTQUAD" };
+    /**
+     * in-out-quartic
+     */
+    const EASING_INOUTQUART: number & { readonly __brand: "gui.EASING_INOUTQUART" };
+    /**
+     * in-out-quintic
+     */
+    const EASING_INOUTQUINT: number & { readonly __brand: "gui.EASING_INOUTQUINT" };
+    /**
+     * in-out-sine
+     */
+    const EASING_INOUTSINE: number & { readonly __brand: "gui.EASING_INOUTSINE" };
+    /**
+     * in-quadratic
+     */
+    const EASING_INQUAD: number & { readonly __brand: "gui.EASING_INQUAD" };
+    /**
+     * in-quartic
+     */
+    const EASING_INQUART: number & { readonly __brand: "gui.EASING_INQUART" };
+    /**
+     * in-quintic
+     */
+    const EASING_INQUINT: number & { readonly __brand: "gui.EASING_INQUINT" };
+    /**
+     * in-sine
+     */
+    const EASING_INSINE: number & { readonly __brand: "gui.EASING_INSINE" };
+    /**
+     * linear interpolation
+     */
+    const EASING_LINEAR: number & { readonly __brand: "gui.EASING_LINEAR" };
+    /**
+     * out-back
+     */
+    const EASING_OUTBACK: number & { readonly __brand: "gui.EASING_OUTBACK" };
+    /**
+     * out-bounce
+     */
+    const EASING_OUTBOUNCE: number & { readonly __brand: "gui.EASING_OUTBOUNCE" };
+    /**
+     * out-circlic
+     */
+    const EASING_OUTCIRC: number & { readonly __brand: "gui.EASING_OUTCIRC" };
+    /**
+     * out-cubic
+     */
+    const EASING_OUTCUBIC: number & { readonly __brand: "gui.EASING_OUTCUBIC" };
+    /**
+     * out-elastic
+     */
+    const EASING_OUTELASTIC: number & { readonly __brand: "gui.EASING_OUTELASTIC" };
+    /**
+     * out-exponential
+     */
+    const EASING_OUTEXPO: number & { readonly __brand: "gui.EASING_OUTEXPO" };
+    /**
+     * out-in-back
+     */
+    const EASING_OUTINBACK: number & { readonly __brand: "gui.EASING_OUTINBACK" };
+    /**
+     * out-in-bounce
+     */
+    const EASING_OUTINBOUNCE: number & { readonly __brand: "gui.EASING_OUTINBOUNCE" };
+    /**
+     * out-in-circlic
+     */
+    const EASING_OUTINCIRC: number & { readonly __brand: "gui.EASING_OUTINCIRC" };
+    /**
+     * out-in-cubic
+     */
+    const EASING_OUTINCUBIC: number & { readonly __brand: "gui.EASING_OUTINCUBIC" };
+    /**
+     * out-in-elastic
+     */
+    const EASING_OUTINELASTIC: number & { readonly __brand: "gui.EASING_OUTINELASTIC" };
+    /**
+     * out-in-exponential
+     */
+    const EASING_OUTINEXPO: number & { readonly __brand: "gui.EASING_OUTINEXPO" };
+    /**
+     * out-in-quadratic
+     */
+    const EASING_OUTINQUAD: number & { readonly __brand: "gui.EASING_OUTINQUAD" };
+    /**
+     * out-in-quartic
+     */
+    const EASING_OUTINQUART: number & { readonly __brand: "gui.EASING_OUTINQUART" };
+    /**
+     * out-in-quintic
+     */
+    const EASING_OUTINQUINT: number & { readonly __brand: "gui.EASING_OUTINQUINT" };
+    /**
+     * out-in-sine
+     */
+    const EASING_OUTINSINE: number & { readonly __brand: "gui.EASING_OUTINSINE" };
+    /**
+     * out-quadratic
+     */
+    const EASING_OUTQUAD: number & { readonly __brand: "gui.EASING_OUTQUAD" };
+    /**
+     * out-quartic
+     */
+    const EASING_OUTQUART: number & { readonly __brand: "gui.EASING_OUTQUART" };
+    /**
+     * out-quintic
+     */
+    const EASING_OUTQUINT: number & { readonly __brand: "gui.EASING_OUTQUINT" };
+    /**
+     * out-sine
+     */
+    const EASING_OUTSINE: number & { readonly __brand: "gui.EASING_OUTSINE" };
+    /**
+     * default keyboard
+     */
+    const KEYBOARD_TYPE_DEFAULT: number & { readonly __brand: "gui.KEYBOARD_TYPE_DEFAULT" };
+    /**
+     * email keyboard
+     */
+    const KEYBOARD_TYPE_EMAIL: number & { readonly __brand: "gui.KEYBOARD_TYPE_EMAIL" };
+    /**
+     * number input keyboard
+     */
+    const KEYBOARD_TYPE_NUMBER_PAD: number & { readonly __brand: "gui.KEYBOARD_TYPE_NUMBER_PAD" };
+    /**
+     * password keyboard
+     */
+    const KEYBOARD_TYPE_PASSWORD: number & { readonly __brand: "gui.KEYBOARD_TYPE_PASSWORD" };
+    /**
+     * elliptical pie node bounds
+     */
+    const PIEBOUNDS_ELLIPSE: number & { readonly __brand: "gui.PIEBOUNDS_ELLIPSE" };
+    /**
+     * rectangular pie node bounds
+     */
+    const PIEBOUNDS_RECTANGLE: number & { readonly __brand: "gui.PIEBOUNDS_RECTANGLE" };
+    /**
+     * center pivot
+     */
+    const PIVOT_CENTER: number & { readonly __brand: "gui.PIVOT_CENTER" };
+    /**
+     * east pivot
+     */
+    const PIVOT_E: number & { readonly __brand: "gui.PIVOT_E" };
+    /**
+     * north pivot
+     */
+    const PIVOT_N: number & { readonly __brand: "gui.PIVOT_N" };
+    /**
+     * north-east pivot
+     */
+    const PIVOT_NE: number & { readonly __brand: "gui.PIVOT_NE" };
+    /**
+     * north-west pivot
+     */
+    const PIVOT_NW: number & { readonly __brand: "gui.PIVOT_NW" };
+    /**
+     * south pivot
+     */
+    const PIVOT_S: number & { readonly __brand: "gui.PIVOT_S" };
+    /**
+     * south-east pivot
+     */
+    const PIVOT_SE: number & { readonly __brand: "gui.PIVOT_SE" };
+    /**
+     * south-west pivot
+     */
+    const PIVOT_SW: number & { readonly __brand: "gui.PIVOT_SW" };
+    /**
+     * west pivot
+     */
+    const PIVOT_W: number & { readonly __brand: "gui.PIVOT_W" };
+    /**
+     * loop backward
+     */
+    const PLAYBACK_LOOP_BACKWARD: number & { readonly __brand: "gui.PLAYBACK_LOOP_BACKWARD" };
+    /**
+     * loop forward
+     */
+    const PLAYBACK_LOOP_FORWARD: number & { readonly __brand: "gui.PLAYBACK_LOOP_FORWARD" };
+    /**
+     * ping pong loop
+     */
+    const PLAYBACK_LOOP_PINGPONG: number & { readonly __brand: "gui.PLAYBACK_LOOP_PINGPONG" };
+    /**
+     * once backward
+     */
+    const PLAYBACK_ONCE_BACKWARD: number & { readonly __brand: "gui.PLAYBACK_ONCE_BACKWARD" };
+    /**
+     * once forward
+     */
+    const PLAYBACK_ONCE_FORWARD: number & { readonly __brand: "gui.PLAYBACK_ONCE_FORWARD" };
+    /**
+     * once forward and then backward
+     */
+    const PLAYBACK_ONCE_PINGPONG: number & { readonly __brand: "gui.PLAYBACK_ONCE_PINGPONG" };
+    /**
+     * color property
+     */
+    const PROP_COLOR: string & { readonly __brand: "gui.PROP_COLOR" };
+    /**
+     * euler property
+     */
+    const PROP_EULER: string & { readonly __brand: "gui.PROP_EULER" };
+    /**
+     * fill_angle property
+     */
+    const PROP_FILL_ANGLE: string & { readonly __brand: "gui.PROP_FILL_ANGLE" };
+    /**
+     * inner_radius property
+     */
+    const PROP_INNER_RADIUS: string & { readonly __brand: "gui.PROP_INNER_RADIUS" };
+    /**
+     * leading property
+     */
+    const PROP_LEADING: string & { readonly __brand: "gui.PROP_LEADING" };
+    /**
+     * outline color property
+     */
+    const PROP_OUTLINE: string & { readonly __brand: "gui.PROP_OUTLINE" };
+    /**
+     * position property
+     */
+    const PROP_POSITION: string & { readonly __brand: "gui.PROP_POSITION" };
+    /**
+     * rotation property
+     */
+    const PROP_ROTATION: string & { readonly __brand: "gui.PROP_ROTATION" };
+    /**
+     * scale property
+     */
+    const PROP_SCALE: string & { readonly __brand: "gui.PROP_SCALE" };
+    /**
+     * shadow color property
+     */
+    const PROP_SHADOW: string & { readonly __brand: "gui.PROP_SHADOW" };
+    /**
+     * size property
+     */
+    const PROP_SIZE: string & { readonly __brand: "gui.PROP_SIZE" };
+    /**
+     * slice9 property
+     */
+    const PROP_SLICE9: string & { readonly __brand: "gui.PROP_SLICE9" };
+    /**
+     * tracking property
+     */
+    const PROP_TRACKING: string & { readonly __brand: "gui.PROP_TRACKING" };
+    /**
+     * data error The provided data is not in the expected format or is in some other way incorrect, for instance the image data provided to gui.new_texture().
+     */
+    const RESULT_DATA_ERROR: number & { readonly __brand: "gui.RESULT_DATA_ERROR" };
+    /**
+     * out of resource The system is out of resources, for instance when trying to create a new texture using gui.new_texture().
+     */
+    const RESULT_OUT_OF_RESOURCES: number & { readonly __brand: "gui.RESULT_OUT_OF_RESOURCES" };
+    /**
+     * texture already exists The texture id already exists when trying to use gui.new_texture().
+     */
+    const RESULT_TEXTURE_ALREADY_EXISTS: number & { readonly __brand: "gui.RESULT_TEXTURE_ALREADY_EXISTS" };
+    /**
+     * both sides safe area Safe area mode that applies insets on all edges.
+     */
+    const SAFE_AREA_BOTH: number & { readonly __brand: "gui.SAFE_AREA_BOTH" };
+    /**
+     * long side safe area Safe area mode that applies insets only on the long edges.
+     */
+    const SAFE_AREA_LONG: number & { readonly __brand: "gui.SAFE_AREA_LONG" };
+    /**
+     * no safe area Safe area mode that ignores safe area insets.
+     */
+    const SAFE_AREA_NONE: number & { readonly __brand: "gui.SAFE_AREA_NONE" };
+    /**
+     * short side safe area Safe area mode that applies insets only on the short edges.
+     */
+    const SAFE_AREA_SHORT: number & { readonly __brand: "gui.SAFE_AREA_SHORT" };
+    /**
+     * automatic size mode The size of the node is determined by the currently assigned texture.
+     */
+    const SIZE_MODE_AUTO: number & { readonly __brand: "gui.SIZE_MODE_AUTO" };
+    /**
+     * manual size mode The size of the node is determined by the size set in the editor, the constructor or by gui.set_size()
+     */
+    const SIZE_MODE_MANUAL: number & { readonly __brand: "gui.SIZE_MODE_MANUAL" };
+    /**
+     * box type
+     */
+    const TYPE_BOX: number & { readonly __brand: "gui.TYPE_BOX" };
+    /**
+     * custom type
+     */
+    const TYPE_CUSTOM: number & { readonly __brand: "gui.TYPE_CUSTOM" };
+    /**
+     * particlefx type
+     */
+    const TYPE_PARTICLEFX: number & { readonly __brand: "gui.TYPE_PARTICLEFX" };
+    /**
+     * pie type
+     */
+    const TYPE_PIE: number & { readonly __brand: "gui.TYPE_PIE" };
+    /**
+     * 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.
+     *
+     * @param node - node that should have its animation canceled
+     * @param property - optional property for which the animation should be canceled
+     *
+     * - `"position"`
+     * - `"rotation"`
+     * - `"euler"`
+     * - `"scale"`
+     * - `"color"`
+     * - `"outline"`
+     * - `"shadow"`
+     * - `"size"`
+     * - `"fill_angle"` (pie)
+     * - `"inner_radius"` (pie)
+     * - `"leading"` (text)
+     * - `"tracking"` (text)
+     * - `"slice9"` (slice9)
+     * @example
+     * Start an animation of the position property of a node, then cancel parts of
+     * the animation:
+     * ```ts
+     * const node = gui.get_node("my_node");
+     * // animate to new position
+     * const pos = vmath.vector3(100, 100, 0);
+     * gui.animate(node, "position", pos, gui.EASING_LINEAR, 2);
+     * // ...
+     * // cancel animation of the x component.
+     * gui.cancel_animations(node, "position.x");
+     * ```
+     * @example
+     * Cancels all property animations on a node in a single call:
+     * ```ts
+     * const node = gui.get_node("my_node");
+     * // animate to new position and scale
+     * gui.animate(node, "position", vmath.vector3(100, 100, 0), gui.EASING_LINEAR, 5);
+     * gui.animate(node, "scale", vmath.vector3(0.5), gui.EASING_LINEAR, 5);
+     * // ...
+     * // cancel positioning and scaling at once
+     * gui.cancel_animations(node);
+     * ```
+     */
+    function cancel_animations(node: Opaque<"node">, property?: string | Hash | gui.PROP): void;
+    /**
+     * Cancels any running flipbook animation on the specified node.
+     *
+     * @param node - node cancel flipbook animation for
+     * @example
+     * ```ts
+     * const node = gui.get_node("anim_node");
+     * gui.cancel_flipbook(node);
+     * ```
+     */
+    function cancel_flipbook(node: Opaque<"node">): void;
+    /**
+     * Make a clone instance of a node. The cloned node will be identical to the
+     * original node, except the id which is generated as the string "node" plus
+     * a sequential unsigned integer value.
+     * This function does not clone the supplied node's children nodes.
+     * Use gui.clone_tree for that purpose.
+     *
+     * @param node - node to clone
+     * @returns the cloned node
+     */
+    function clone(node: Opaque<"node">): Opaque<"node">;
+    /**
+     * 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
+     * @returns a table mapping node ids to the corresponding cloned nodes
+     */
+    function clone_tree(node: Opaque<"node">): LuaTable<Hash, Opaque<"node">>;
+    /**
+     * Deletes the specified node. Any child nodes of the specified node will be
+     * recursively deleted.
+     *
+     * @param node - node to delete
+     * @example
+     * ```ts
+     * // Delete a particular node and any child nodes it might have:
+     * const node = gui.get_node("my_node");
+     * gui.delete_node(node);
+     * ```
+     */
+    function delete_node(node: Opaque<"node">): void;
+    /**
+     * Delete a dynamically created texture.
+     *
+     * @param texture - texture id
+     * @example
+     * ```ts
+     * export default defineGuiScript({
+     *   init(self) {
+     *     // Create a texture.
+     *     if (gui.new_texture("temp_tx", 10, 10, "rgb", "\0".repeat(10 * 10 * 3))) {
+     *       // Do something with the texture.
+     *       // ...
+     *
+     *       // Delete the texture
+     *       gui.delete_texture("temp_tx");
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    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
+     * resolutions that differs from the one in the project settings.
+     *
+     * @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;
+    /**
+     * gets the node alpha
+     *
+     * @param node - node from which to get alpha
+     * @returns alpha
+     */
+    function get_alpha(node: Opaque<"node">): number;
+    /**
+     * Returns the blend mode of a node.
+     * Blend mode defines how the node will be blended with the background.
+     *
+     * @param node - node from which to get the blend mode
+     * @returns blend mode
+     */
+    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.
+     *
+     * @param node - node from which to get the clipping inverted state
+     * @returns `true` or `false`
+     */
+    function get_clipping_inverted(node: Opaque<"node">): boolean;
+    /**
+     * Clipping mode defines how the node will clip it's children nodes
+     *
+     * @param node - node from which to get the clipping mode
+     * @returns clipping mode
+     *
+     * - `gui.CLIPPING_MODE_NONE`
+     * - `gui.CLIPPING_MODE_STENCIL`
+     */
+    function get_clipping_mode(node: Opaque<"node">): gui.CLIPPING_MODE;
+    /**
+     * 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.
+     *
+     * @param node - node from which to get the clipping visibility state
+     * @returns `true` or `false`
+     */
+    function get_clipping_visible(node: Opaque<"node">): boolean;
+    /**
+     * Returns the color of the supplied node. The components
+     * of the returned vector4 contains the color channel values:
+     *
+     * Component
+     * Color value
+     *
+     * x
+     * Red value
+     *
+     * y
+     * Green value
+     *
+     * z
+     * Blue value
+     *
+     * w
+     * Alpha value
+     *
+     * @param node - node to get the color from
+     * @returns node color
+     */
+    function get_color(node: Opaque<"node">): Vector4;
+    /**
+     * Returns the rotation of the supplied node.
+     * The rotation is expressed in degree Euler angles.
+     *
+     * @param node - node to get the rotation from
+     * @returns node rotation
+     */
+    function get_euler(node: Opaque<"node">): Vector3;
+    /**
+     * Returns the sector angle of a pie node.
+     *
+     * @param node - node from which to get the fill angle
+     * @returns sector angle
+     */
+    function get_fill_angle(node: Opaque<"node">): number;
+    /**
+     * Get node flipbook animation.
+     *
+     * @param node - node to get flipbook animation from
+     * @returns animation id
+     */
+    function get_flipbook(node: Opaque<"node">): Hash;
+    /**
+     * This is only useful nodes with flipbook animations. Gets the normalized cursor of the flipbook animation on a node.
+     *
+     * @param node - node to get the cursor for (node)
+     * @returns cursor value
+     */
+    function get_flipbook_cursor(node: Opaque<"node">): number;
+    /**
+     * This is only useful nodes with flipbook animations. Gets the playback rate of the flipbook animation on a node.
+     *
+     * @param node - node to set the cursor for
+     * @returns playback rate
+     */
+    function get_flipbook_playback_rate(node: Opaque<"node">): number;
+    /**
+     * This is only useful for text nodes. The font must be mapped to the gui scene in the gui editor.
+     *
+     * @param node - node from which to get the font
+     * @returns font id
+     */
+    function get_font(node: Opaque<"node">): Hash;
+    /**
+     * This is only useful for text nodes. The font must be mapped to the gui scene in the gui editor.
+     *
+     * @param font_name - font of which to get the path hash
+     * @returns path hash to resource
+     * @example
+     * ```ts
+     * // Get the text metrics for a text
+     * export default defineGuiScript({
+     *   init(self) {
+     *     const node = gui.get_node("name");
+     *     const font_name = gui.get_font(node);
+     *     const font = gui.get_font_resource(font_name);
+     *     const metrics = resource.get_text_metrics(font, "The quick brown fox\n jumps over the lazy dog");
+     *   },
+     * });
+     * ```
+     */
+    function get_font_resource(font_name: Hash | string): Hash;
+    /**
+     * Returns the scene height.
+     *
+     * @returns scene height
+     */
+    function get_height(): number;
+    /**
+     * Retrieves the id of the specified node.
+     *
+     * @param node - the node to retrieve the id from
+     * @returns the id of the node
+     * @example
+     * ```ts
+     * // Gets the id of a node:
+     * const node = gui.get_node("my_node");
+     *
+     * const id = gui.get_id(node);
+     * print(id); // => hash: [my_node]
+     * ```
+     */
+    function get_id(node: Opaque<"node">): Hash;
+    /**
+     * Retrieve the index of the specified node among its siblings.
+     * The index defines the order in which a node appear in a GUI scene.
+     * Higher index means the node is drawn on top of lower indexed nodes.
+     *
+     * @param node - the node to retrieve the id from
+     * @returns the index of the node. **0️⃣ 0-based; passed to Defold unchanged.**
+     * @example
+     * ```ts
+     * // Compare the index order of two sibling nodes:
+     * const node1 = gui.get_node("my_node_1");
+     * const node2 = gui.get_node("my_node_2");
+     *
+     * if (gui.get_index(node1) < gui.get_index(node2)) {
+     *   // node1 is drawn below node2
+     * } else {
+     *   // node2 is drawn below node1
+     * }
+     * ```
+     */
+    function get_index(node: Opaque<"node">): number;
+    /**
+     * gets the node inherit alpha state
+     *
+     * @param node - node from which to get the inherit alpha state
+     * @returns `true` or `false`
+     */
+    function get_inherit_alpha(node: Opaque<"node">): boolean;
+    /**
+     * Returns the inner radius of a pie node.
+     * The radius is defined along the x-axis.
+     *
+     * @param node - node from where to get the inner radius
+     * @returns inner radius
+     */
+    function get_inner_radius(node: Opaque<"node">): number;
+    /**
+     * The layer must be mapped to the gui scene in the gui editor.
+     *
+     * @param node - node from which to get the layer
+     * @returns layer id
+     */
+    function get_layer(node: Opaque<"node">): Hash;
+    /**
+     * gets the scene current layout
+     *
+     * @returns layout id
+     */
+    function get_layout(): Hash;
+    /**
+     * Returns the sprites and links found in the text node's current layout.
+     * Each object's `x` and `y` identify its lower-left corner relative to the
+     * text node's upper-left layout origin.
+     *
+     * @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[];
+    /**
+     * 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
+     * no display profiles are assigned), the width/height pair is 0.
+     *
+     * @returns layout_id_hash -> vmath.vector3(width, height, 0)
+     */
+    function get_layouts(): LuaTable<Hash, Vector3>;
+    /**
+     * Returns the leading value for a text node.
+     *
+     * @param node - node from where to get the leading
+     * @returns leading scaling value (default=1)
+     */
+    function get_leading(node: Opaque<"node">): number;
+    /**
+     * Returns whether a text node is in line-break mode or not.
+     * This is only useful for text nodes.
+     *
+     * @param node - node from which to get the line-break for
+     * @returns `true` or `false`
+     */
+    function get_line_break(node: Opaque<"node">): boolean;
+    /**
+     * Returns the material of a node.
+     * The material must be mapped to the gui scene in the gui editor.
+     *
+     * @param node - node to get the material for
+     * @returns material id
+     * @example
+     * ```ts
+     * // Getting the material for a node, and assign it to another node:
+     * const node1 = gui.get_node("my_node");
+     * const node2 = gui.get_node("other_node");
+     * const node1_material = gui.get_material(node1);
+     * gui.set_material(node2, node1_material);
+     * ```
+     */
+    function get_material(node: Opaque<"node">): Hash;
+    /**
+     * Retrieves the node with the specified id.
+     *
+     * @param id - id of the node to retrieve
+     * @returns a new node instance
+     * @example
+     * ```ts
+     * // Gets a node by id and change its color:
+     * const node = gui.get_node("my_node");
+     * const red = vmath.vector4(1.0, 0.0, 0.0, 1.0);
+     * gui.set_color(node, red);
+     * ```
+     */
+    function get_node(id: string | Hash): Opaque<"node">;
+    /**
+     * Returns the outer bounds mode for a pie node.
+     *
+     * @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;
+    /**
+     * Returns the outline color of the supplied node.
+     * See gui.get_color for info how vectors encode color values.
+     *
+     * @param node - node to get the outline color from
+     * @returns outline color
+     */
+    function get_outline(node: Opaque<"node">): Vector4;
+    /**
+     * Returns the parent node of the specified node.
+     * If the supplied node does not have a parent, `nil` is returned.
+     *
+     * @param node - the node from which to retrieve its parent
+     * @returns parent instance or `nil`
+     */
+    function get_parent(node: Opaque<"node">): Opaque<"node"> | undefined;
+    /**
+     * Get the paricle fx for a gui node
+     *
+     * @param node - node to get particle fx for
+     * @returns particle fx id
+     */
+    function get_particlefx(node: Opaque<"node">): Hash;
+    /**
+     * Returns the number of generated vertices around the perimeter
+     * of a pie node.
+     *
+     * @param node - pie node
+     * @returns vertex count
+     */
+    function get_perimeter_vertices(node: Opaque<"node">): number;
+    /**
+     * The pivot specifies how the node is drawn and rotated from its position.
+     *
+     * @param node - node to get pivot from
+     * @returns pivot constant
+     *
+     * - `gui.PIVOT_CENTER`
+     * - `gui.PIVOT_N`
+     * - `gui.PIVOT_NE`
+     * - `gui.PIVOT_E`
+     * - `gui.PIVOT_SE`
+     * - `gui.PIVOT_S`
+     * - `gui.PIVOT_SW`
+     * - `gui.PIVOT_W`
+     * - `gui.PIVOT_NW`
+     */
+    function get_pivot(node: Opaque<"node">): gui.PIVOT;
+    /**
+     * Returns the position of the supplied node.
+     *
+     * @param node - node to get the position from
+     * @returns node position
+     */
+    function get_position(node: Opaque<"node">): Vector3;
+    /**
+     * Returns the rotation of the supplied node.
+     * The rotation is expressed as a quaternion
+     *
+     * @param node - node to get the rotation from
+     * @returns node rotation
+     */
+    function get_rotation(node: Opaque<"node">): Quaternion;
+    /**
+     * Returns the scale of the supplied node.
+     *
+     * @param node - node to get the scale from
+     * @returns node scale
+     */
+    function get_scale(node: Opaque<"node">): Vector3;
+    /**
+     * Returns the screen position of the supplied node. This function returns the
+     * calculated transformed position of the node, taking into account any parent node
+     * transforms.
+     *
+     * @param node - node to get the screen position from
+     * @returns node screen position
+     */
+    function get_screen_position(node: Opaque<"node">): Vector3;
+    /**
+     * Returns the shadow color of the supplied node.
+     * See gui.get_color for info how vectors encode color values.
+     *
+     * @param node - node to get the shadow color from
+     * @returns node shadow color
+     */
+    function get_shadow(node: Opaque<"node">): Vector4;
+    /**
+     * Returns the size of the supplied node.
+     *
+     * @param node - node to get the size from
+     * @returns node size
+     */
+    function get_size(node: Opaque<"node">): Vector3;
+    /**
+     * Returns the size of a node.
+     * The size mode defines how the node will adjust itself in size. Automatic
+     * size mode alters the node size based on the node's content. Automatic size
+     * mode works for Box nodes and Pie nodes which will both adjust their size
+     * to match the assigned image. Particle fx and Text nodes will ignore
+     * any size mode setting.
+     *
+     * @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;
+    /**
+     * Returns the slice9 configuration values for the node.
+     *
+     * @param node - node to manipulate
+     * @returns configuration values
+     */
+    function get_slice9(node: Opaque<"node">): Vector4;
+    /**
+     * Returns the text value of a text node. This is only useful for text nodes.
+     *
+     * @param node - node from which to get the text
+     * @returns text value
+     */
+    function get_text(node: Opaque<"node">): string;
+    /**
+     * Returns the texture of a node.
+     * This is currently only useful for box or pie nodes.
+     * The texture must be mapped to the gui scene in the gui editor.
+     *
+     * @param node - node to get texture from
+     * @returns texture id
+     */
+    function get_texture(node: Opaque<"node">): Hash;
+    /**
+     * Returns the tracking value of a text node.
+     *
+     * @param node - node from where to get the tracking
+     * @returns tracking scaling number (default=0)
+     */
+    function get_tracking(node: Opaque<"node">): number;
+    /**
+     * Get a node and all its children as a Lua table.
+     *
+     * @param node - root node to get node tree from
+     * @returns a table mapping node ids to the corresponding nodes
+     */
+    function get_tree(node: Opaque<"node">): LuaTable<Hash, 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]>;
+    /**
+     * Returns `true` if a node is visible and `false` if it's not.
+     * Invisible nodes are not rendered.
+     *
+     * @param node - node to query
+     * @returns whether the node is visible or not
+     */
+    function get_visible(node: Opaque<"node">): boolean;
+    /**
+     * Returns the scene width.
+     *
+     * @returns scene width
+     */
+    function get_width(): number;
+    /**
+     * The x-anchor specifies how the node is moved when the game is run in a different resolution.
+     *
+     * @param node - node to get x-anchor from
+     * @returns anchor constant
+     *
+     * - `gui.ANCHOR_NONE`
+     * - `gui.ANCHOR_LEFT`
+     * - `gui.ANCHOR_RIGHT`
+     */
+    function get_xanchor(node: Opaque<"node">): gui.ANCHOR;
+    /**
+     * The y-anchor specifies how the node is moved when the game is run in a different resolution.
+     *
+     * @param node - node to get y-anchor from
+     * @returns anchor constant
+     *
+     * - `gui.ANCHOR_NONE`
+     * - `gui.ANCHOR_TOP`
+     * - `gui.ANCHOR_BOTTOM`
+     */
+    function get_yanchor(node: Opaque<"node">): gui.ANCHOR;
+    /**
+     * 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.
+     *
+     * @param node - node to query
+     * @param recursive - check hierarchy recursively
+     * @returns whether the node is enabled or not
+     */
+    function is_enabled(node: Opaque<"node">, recursive?: boolean): boolean;
+    /**
+     * Alters the ordering of the two supplied nodes by moving the first node
+     * above the second.
+     * If the second argument is `nil` the first node is moved to the top.
+     *
+     * @param node - to move
+     * @param reference - reference node above which the first node should be moved
+     */
+    function move_above(node: Opaque<"node">, reference: Opaque<"node"> | undefined): void;
+    /**
+     * Alters the ordering of the two supplied nodes by moving the first node
+     * below the second.
+     * If the second argument is `nil` the first node is moved to the bottom.
+     *
+     * @param node - to move
+     * @param reference - reference node below which the first node should be moved
+     */
+    function move_below(node: Opaque<"node">, reference: Opaque<"node"> | undefined): void;
+    /**
+     * Dynamically create a new box node.
+     *
+     * @param pos - node position
+     * @param size - node size
+     * @returns new box node
+     */
+    function new_box_node(pos: Vector3 | Vector4, size: Vector3): Opaque<"node">;
+    /**
+     * Dynamically create a particle fx node.
+     *
+     * @param pos - node position
+     * @param particlefx - particle fx resource name
+     * @returns new particle fx node
+     */
+    function new_particlefx_node(pos: Vector3 | Vector4, particlefx: Hash | string): Opaque<"node">;
+    /**
+     * Dynamically create a new pie node.
+     *
+     * @param pos - node position
+     * @param size - node size
+     * @returns new pie node
+     */
+    function new_pie_node(pos: Vector3 | Vector4, size: Vector3): Opaque<"node">;
+    /**
+     * Dynamically create a new text node.
+     *
+     * @param pos - node position
+     * @param text - node text
+     * @returns new text node
+     */
+    function new_text_node(pos: Vector3 | Vector4, text: string): Opaque<"node">;
+    /**
+     * 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(self) {
+     *     const w = 200;
+     *     const h = 300;
+     *
+     *     // 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 {
+     *         // ...
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     * @example
+     * How to create a texture using .astc format
+     * ```ts
+     * 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 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
+     * @example
+     * ```ts
+     * export default defineGuiScript({
+     *   init(): { my_value: number | undefined } {
+     *     return { my_value: undefined };
+     *   },
+     *
+     *   on_input(self, action_id, action) {
+     *     // check for input
+     *     if (action_id === hash("my_action")) {
+     *       // take appropriate action
+     *       self.my_value = action.value;
+     *     }
+     *     // 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
+     * ```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);
+     *   },
+     * });
+     * ```
+     */
+    function on_reload(self: unknown): void;
+    /**
+     * Tests whether a coordinate is within the bounding box of a
+     * node.
+     *
+     * @param node - node to be tested for picking
+     * @param x - x-coordinate (see on_input )
+     * @param y - y-coordinate (see on_input )
+     * @returns pick result
+     */
+    function pick_node(node: Opaque<"node">, x: number, y: number): boolean;
+    /**
+     * 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, play_properties?: gui.play_properties): void;
+    /**
+     * Plays the paricle fx for a gui node
+     *
+     * @param node - node to play particle fx for
+     * @param emitter_state_function - optional callback function that will be called when an emitter attached to this particlefx changes state.
+     * @example
+     * ```ts
+     * // How to play a particle fx when a gui node is created.
+     * // The callback receives the gui node, the hash of the id
+     * // of the emitter, and the new state of the emitter as particlefx.EMITTER_STATE_.
+     * export default defineGuiScript({
+     *   init(self) {
+     *     gui.play_particlefx(gui.get_node("particlefx"), (self, node, emitter, state) => {
+     *       if (emitter === hash("exhaust") && state === particlefx.EMITTER_STATE_POSTSPAWN) {
+     *         // exhaust is done spawning particles...
+     *       }
+     *     });
+     *   },
+     * });
+     * ```
+     */
+    function play_particlefx(node: Opaque<"node">, emitter_state_function?: (self: unknown, node: Opaque<"node"> | undefined, emitter: Hash, state: particlefx.EMITTER_STATE) => void): void;
+    /**
+     * Resets the input context of keyboard. This will clear marked text.
+     */
+    function reset_keyboard(): void;
+    /**
+     * Resets the node material to the material assigned in the gui scene.
+     *
+     * @param node - node to reset the material for
+     * @example
+     * ```ts
+     * // Resetting the material for a node:
+     * const node = gui.get_node("my_node");
+     * gui.reset_material(node);
+     * ```
+     */
+    function reset_material(node: Opaque<"node">): void;
+    /**
+     * Resets all nodes in the current GUI scene to their initial state.
+     * The reset only applies to static node loaded from the scene.
+     * Nodes that are created dynamically from script are not affected.
+     */
+    function reset_nodes(): void;
+    /**
+     * Converts a screen-space position to the local position value for the supplied node.
+     * The conversion takes the parent transform, anchors, adjust mode, and adjust reference into account.
+     *
+     * @param node - node whose local position space should be used
+     * @param screen_position - screen-space position
+     * @returns local position value for the node
+     * @example
+     * ```ts
+     * // Animate a node to the pressed pointer position:
+     * export default defineGuiScript({
+     *   init() {
+     *     msg.post(".", "acquire_input_focus");
+     *     return { marker: gui.get_node("marker") };
+     *   },
+     *
+     *   on_input(self, action_id, action) {
+     *     if (
+     *       action_id === hash("touch") &&
+     *       action.pressed &&
+     *       action.screen_x !== undefined &&
+     *       action.screen_y !== undefined
+     *     ) {
+     *       const screen_position = vmath.vector3(action.screen_x, action.screen_y, 0);
+     *       const target_position = gui.screen_to_local(self.marker, screen_position);
+     *       gui.animate(self.marker, gui.PROP_POSITION, target_position, gui.EASING_OUTQUAD, 0.2);
+     *       return true;
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    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
+     * resolutions that differs from the one in the project settings.
+     *
+     * @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;
+    /**
+     * sets the node alpha
+     *
+     * @param node - node for which to set alpha
+     * @param alpha - 0..1 alpha color
+     */
+    function set_alpha(node: Opaque<"node">, alpha: number): void;
+    /**
+     * Set the blend mode of a node.
+     * Blend mode defines how the node will be blended with the background.
+     *
+     * @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;
+    /**
+     * If node is set as an inverted clipping node, it will clip anything inside as opposed to outside.
+     *
+     * @param node - node to set clipping inverted state for
+     * @param inverted - `true` or `false`
+     */
+    function set_clipping_inverted(node: Opaque<"node">, inverted: boolean): void;
+    /**
+     * Clipping mode defines how the node will clip it's children nodes
+     *
+     * @param node - node to set clipping mode for
+     * @param clipping_mode - clipping mode to set
+     *
+     * - `gui.CLIPPING_MODE_NONE`
+     * - `gui.CLIPPING_MODE_STENCIL`
+     */
+    function set_clipping_mode(node: Opaque<"node">, clipping_mode: gui.CLIPPING_MODE): 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.
+     *
+     * @param node - node to set clipping visibility for
+     * @param visible - `true` or `false`
+     */
+    function set_clipping_visible(node: Opaque<"node">, visible: boolean): void;
+    /**
+     * Sets the color of the supplied node. The components
+     * of the supplied vector3 or vector4 should contain the color channel values:
+     *
+     * Component
+     * Color value
+     *
+     * x
+     * Red value
+     *
+     * y
+     * Green value
+     *
+     * z
+     * Blue value
+     *
+     * w vector4
+     * Alpha value
+     *
+     * @param node - node to set the color for
+     * @param color - new color
+     */
+    function set_color(node: Opaque<"node">, color: Vector3 | Vector4): void;
+    /**
+     * Sets a node to the disabled or enabled state.
+     * Disabled nodes are not rendered and animations acting on them are not evaluated.
+     *
+     * @param node - node to be enabled/disabled
+     * @param enabled - whether the node should be enabled or not
+     */
+    function set_enabled(node: Opaque<"node">, enabled: boolean): void;
+    /**
+     * Sets the rotation of the supplied node.
+     * The rotation is expressed in degree Euler angles.
+     *
+     * @param node - node to set the rotation for
+     * @param rotation - new rotation
+     */
+    function set_euler(node: Opaque<"node">, rotation: Vector3 | Vector4): void;
+    /**
+     * Set the sector angle of a pie node.
+     *
+     * @param node - node to set the fill angle for
+     * @param angle - sector angle
+     */
+    function set_fill_angle(node: Opaque<"node">, angle: number): void;
+    /**
+     * This is only useful nodes with flipbook animations. The cursor is normalized.
+     *
+     * @param node - node to set the cursor for
+     * @param cursor - cursor value
+     */
+    function set_flipbook_cursor(node: Opaque<"node">, cursor: number): void;
+    /**
+     * This is only useful nodes with flipbook animations. Sets the playback rate of the flipbook animation on a node. Must be positive.
+     *
+     * @param node - node to set the cursor for
+     * @param playback_rate - playback rate
+     */
+    function set_flipbook_playback_rate(node: Opaque<"node">, playback_rate: number): void;
+    /**
+     * This is only useful for text nodes.
+     * The font must be mapped to the gui scene in the gui editor.
+     *
+     * @param node - node for which to set the font
+     * @param font - font id
+     */
+    function set_font(node: Opaque<"node">, font: string | Hash): void;
+    /**
+     * Set the id of the specicied node to a new value.
+     * Nodes created with the gui.new_*_node() functions get
+     * an empty id. This function allows you to give dynamically
+     * created nodes an id.
+     * No checking is done on the uniqueness of supplied ids.
+     * It is up to you to make sure you use unique ids.
+     *
+     * @param node - node to set the id for
+     * @param id - id to set
+     * @example
+     * ```ts
+     * // Create a new node and set its id:
+     * const pos = vmath.vector3(100, 100, 0);
+     * const size = vmath.vector3(100, 100, 0);
+     * const node = gui.new_box_node(pos, size);
+     * gui.set_id(node, "my_new_node");
+     * ```
+     */
+    function set_id(node: Opaque<"node">, id: string | Hash): void;
+    /**
+     * sets the node inherit alpha state
+     *
+     * @param node - node from which to set the inherit alpha state
+     * @param inherit_alpha - `true` or `false`
+     */
+    function set_inherit_alpha(node: Opaque<"node">, inherit_alpha: boolean): void;
+    /**
+     * Sets the inner radius of a pie node.
+     * The radius is defined along the x-axis.
+     *
+     * @param node - node to set the inner radius for
+     * @param radius - inner radius
+     */
+    function set_inner_radius(node: Opaque<"node">, radius: number): void;
+    /**
+     * The layer must be mapped to the gui scene in the gui editor.
+     *
+     * @param node - node for which to set the layer
+     * @param layer - layer id
+     */
+    function set_layer(node: Opaque<"node">, layer: string | Hash): void;
+    /**
+     * Applies a named layout on the GUI scene. This re-applies per-layout node descriptors
+     * and, if a matching Display Profile exists, updates the scene resolution. Emits
+     * the "layout_changed" message to the scene script when the layout actually changes.
+     *
+     * @param layout - the layout id to apply
+     * @returns true if the layout exists in the scene and was applied, false otherwise
+     */
+    function set_layout(layout: string | Hash): boolean;
+    /**
+     * Sets the leading value for a text node. This value is used to
+     * scale the line spacing of text.
+     *
+     * @param node - node for which to set the leading
+     * @param leading - a scaling value for the line spacing (default=1)
+     */
+    function set_leading(node: Opaque<"node">, leading: number): void;
+    /**
+     * Sets the line-break mode on a text node.
+     * This is only useful for text nodes.
+     *
+     * @param node - node to set line-break for
+     * @param line_break - `true` or `false`
+     */
+    function set_line_break(node: Opaque<"node">, line_break: boolean): void;
+    /**
+     * Set the material on a node. The material must be mapped to the gui scene in the gui editor,
+     * and assigning a material is supported for all node types. To set the default material that
+     * is assigned to the gui scene node, use `gui.reset_material(node_id)` instead.
+     *
+     * @param node - node to set material for
+     * @param material - material id
+     * @example
+     * ```ts
+     * // Assign an existing material to a node:
+     * const node = gui.get_node("my_node");
+     * gui.set_material(node, "my_material");
+     * ```
+     */
+    function set_material(node: Opaque<"node">, material: string | Hash): void;
+    /**
+     * Sets the outer bounds mode for a pie node.
+     *
+     * @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;
+    /**
+     * Sets the outline color of the supplied node.
+     * See gui.set_color for info how vectors encode color values.
+     *
+     * @param node - node to set the outline color for
+     * @param color - new outline color
+     */
+    function set_outline(node: Opaque<"node">, color: Vector3 | Vector4): void;
+    /**
+     * Sets the parent node of the specified node.
+     *
+     * @param node - node for which to set its parent
+     * @param parent - parent node to set, pass `nil` to remove parent
+     * @param keep_scene_transform - optional flag to make the scene position being perserved
+     */
+    function set_parent(node: Opaque<"node">, parent: Opaque<"node"> | undefined, keep_scene_transform?: boolean): void;
+    /**
+     * Set the paricle fx for a gui node
+     *
+     * @param node - node to set particle fx for
+     * @param particlefx - particle fx id
+     */
+    function set_particlefx(node: Opaque<"node">, particlefx: Hash | string): void;
+    /**
+     * Sets the number of generated vertices around the perimeter of a pie node.
+     *
+     * @param node - pie node
+     * @param vertices - vertex count
+     */
+    function set_perimeter_vertices(node: Opaque<"node">, vertices: number): void;
+    /**
+     * The pivot specifies how the node is drawn and rotated from its position.
+     *
+     * @param node - node to set pivot for
+     * @param pivot - pivot constant
+     *
+     * - `gui.PIVOT_CENTER`
+     * - `gui.PIVOT_N`
+     * - `gui.PIVOT_NE`
+     * - `gui.PIVOT_E`
+     * - `gui.PIVOT_SE`
+     * - `gui.PIVOT_S`
+     * - `gui.PIVOT_SW`
+     * - `gui.PIVOT_W`
+     * - `gui.PIVOT_NW`
+     */
+    function set_pivot(node: Opaque<"node">, pivot: gui.PIVOT): void;
+    /**
+     * Sets the position of the supplied node.
+     *
+     * @param node - node to set the position for
+     * @param position - new position
+     */
+    function set_position(node: Opaque<"node">, position: Vector3 | Vector4): void;
+    /**
+     * Set the order number for the current GUI scene.
+     * The number dictates the sorting of the "gui" render predicate,
+     * in other words in which order the scene will be rendered in relation
+     * to other currently rendered GUI scenes.
+     * The number must be in the range 0 to 15.
+     *
+     * @param order - rendering order (0-15)
+     */
+    function set_render_order(order: number): void;
+    /**
+     * Sets the rotation of the supplied node.
+     * The rotation is expressed as a quaternion
+     *
+     * @param node - node to set the rotation for
+     * @param rotation - new rotation
+     */
+    function set_rotation(node: Opaque<"node">, rotation: Quaternion | Vector4 | Vector3): void;
+    /**
+     * Sets how the safe area is applied to this gui scene.
+     *
+     * @param mode - safe area mode
+     */
+    function set_safe_area_mode(mode: gui.SAFE_AREA): void;
+    /**
+     * Sets the scaling of the supplied node.
+     *
+     * @param node - node to set the scale for
+     * @param scale - new scale
+     */
+    function set_scale(node: Opaque<"node">, scale: Vector3 | Vector4): void;
+    /**
+     * Set the screen position to the supplied node
+     *
+     * @param node - node to set the screen position to
+     * @param screen_position - screen position
+     */
+    function set_screen_position(node: Opaque<"node">, screen_position: Vector3 | Vector4): void;
+    /**
+     * Sets the shadow color of the supplied node.
+     * See gui.set_color for info how vectors encode color values.
+     *
+     * @param node - node to set the shadow color for
+     * @param color - new shadow color
+     */
+    function set_shadow(node: Opaque<"node">, color: Vector3 | Vector4): void;
+    /**
+     * Sets the size of the supplied node.
+     * You can only set size on nodes with size mode set to SIZE_MODE_MANUAL
+     *
+     * @param node - node to set the size for
+     * @param size - new size
+     */
+    function set_size(node: Opaque<"node">, size: Vector3 | Vector4): void;
+    /**
+     * Sets the size mode of a node.
+     * The size mode defines how the node will adjust itself in size. Automatic
+     * size mode alters the node size based on the node's content. Automatic size
+     * mode works for Box nodes and Pie nodes which will both adjust their size
+     * to match the assigned image. Particle fx and Text nodes will ignore
+     * any size mode setting.
+     *
+     * @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;
+    /**
+     * Set the slice9 configuration values for the node.
+     *
+     * @param node - node to manipulate
+     * @param values - new values
+     */
+    function set_slice9(node: Opaque<"node">, values: Vector4): void;
+    /**
+     * Set the text value of a text node. This is only useful for text nodes.
+     *
+     * @param node - node to set text for
+     * @param text - text to set
+     */
+    function set_text(node: Opaque<"node">, text: string | number): void;
+    /**
+     * Set the texture on a box or pie node. The texture must be mapped to
+     * the gui scene in the gui editor. The function points out which texture
+     * the node should render from. If the texture is an atlas, further
+     * information is needed to select which image/animation in the atlas
+     * to render. In such cases, use `gui.play_flipbook()` in
+     * addition to this function.
+     *
+     * @param node - node to set texture for
+     * @param texture - texture id
+     * @example
+     * To set a texture (or animation) from an atlas:
+     * ```ts
+     * const node = gui.get_node("box_node");
+     * gui.set_texture(node, "my_atlas");
+     * gui.play_flipbook(node, "image");
+     * ```
+     * @example
+     * Set a dynamically created texture to a node. Note that there is only
+     * one texture image in this case so `gui.set_texture()` is
+     * sufficient.
+     * ```ts
+     * const w = 200;
+     * const h = 300;
+     * // 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] = gui.new_texture("orange_tx", w, h, "rgb", orange.repeat(w * h));
+     * if (ok) {
+     *   const node = gui.get_node("box_node");
+     *   gui.set_texture(node, "orange_tx");
+     * }
+     * ```
+     */
+    function set_texture(node: Opaque<"node">, texture: string | Hash): void;
+    /**
+     * 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.
+     *
+     * @param node - node for which to set the tracking
+     * @param tracking - a scaling number for the letter spacing (default=0)
+     */
+    function set_tracking(node: Opaque<"node">, tracking: number): void;
+    /**
+     * Set if a node should be visible or not. Only visible nodes are rendered.
+     *
+     * @param node - node to be visible or not
+     * @param visible - whether the node should be visible or not
+     */
+    function set_visible(node: Opaque<"node">, visible: boolean): void;
+    /**
+     * The x-anchor specifies how the node is moved when the game is run in a different resolution.
+     *
+     * @param node - node to set x-anchor for
+     * @param anchor - anchor constant
+     *
+     * - `gui.ANCHOR_NONE`
+     * - `gui.ANCHOR_LEFT`
+     * - `gui.ANCHOR_RIGHT`
+     */
+    function set_xanchor(node: Opaque<"node">, anchor: gui.ANCHOR): void;
+    /**
+     * The y-anchor specifies how the node is moved when the game is run in a different resolution.
+     *
+     * @param node - node to set y-anchor for
+     * @param anchor - anchor constant
+     *
+     * - `gui.ANCHOR_NONE`
+     * - `gui.ANCHOR_TOP`
+     * - `gui.ANCHOR_BOTTOM`
+     */
+    function set_yanchor(node: Opaque<"node">, anchor: gui.ANCHOR): void;
+    /**
+     * Shows the on-display touch keyboard.
+     * The specified type of keyboard is displayed if it is available on
+     * the device.
+     * This function is only available on iOS and Android. .
+     *
+     * @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;
+    /**
+     * 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;
+    /**
+     * 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));
+     *     }
+     *   },
+     *
+     *   on_message(self, message_id, message) {
+     *     // check the message
+     *     if (message_id === hash("set_score") && typeof message.score === "number") {
+     *       self.target_score = message.score;
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function update(self: unknown, dt: number): void;
+    interface properties {
+      /**
+       * The fonts used in the gui. The type of the property is hash.
+       * Key must be specified in options table.
+       */
+      fonts: Hash;
+      /**
+       * The main material (the default material assigned to a GUI) used when rendering the gui. The type of the property is hash.
+       */
+      material: Hash;
+      /**
+       * The materials used when rendering the gui. The type of the property is hash.
+       * Key must be specified in options table.
+       */
+      materials: Hash;
+      /**
+       * The textures used in the gui. The type of the property is hash.
+       * Key must be specified in options table.
+       */
+      textures: Hash;
+    }
+  }
+}
+
+export {};