@defold-typescript/types 0.39.0 → 0.40.0

package/generated/b2d_shape.d.ts

@@ -47,6 +47,7 @@ declare global {
      * @returns true if contact events are enabled
      */
     function are_contact_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    function are_contact_events_enabled(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Check if hit events are enabled for a shape.
      *
@@ -54,6 +55,7 @@ declare global {
      * @returns true if hit events are enabled
      */
     function are_hit_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    function are_hit_events_enabled(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Check if pre-solve events are enabled for a shape.
      *
@@ -61,6 +63,7 @@ declare global {
      * @returns true if pre-solve events are enabled
      */
     function are_pre_solve_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    function are_pre_solve_events_enabled(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Check if sensor events are enabled for a shape.
      *
@@ -68,6 +71,7 @@ declare global {
      * @returns true if sensor events are enabled
      */
     function are_sensor_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    function are_sensor_events_enabled(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Enable or disable contact events for a shape.
      *
@@ -75,6 +79,7 @@ declare global {
      * @param enable - true to enable contact events
      */
     function enable_contact_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    function enable_contact_events(body: Opaque<"b2Body">, shape_index: number, enable: boolean): void;
     /**
      * Enable or disable hit events for a shape.
      *
@@ -82,6 +87,7 @@ declare global {
      * @param enable - true to enable hit events
      */
     function enable_hit_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    function enable_hit_events(body: Opaque<"b2Body">, shape_index: number, enable: boolean): void;
     /**
      * Enable or disable pre-solve events for a shape.
      *
@@ -89,6 +95,7 @@ declare global {
      * @param enable - true to enable pre-solve events
      */
     function enable_pre_solve_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    function enable_pre_solve_events(body: Opaque<"b2Body">, shape_index: number, enable: boolean): void;
     /**
      * Enable or disable sensor events for a shape.
      *
@@ -96,6 +103,7 @@ declare global {
      * @param enable - true to enable sensor events
      */
     function enable_sensor_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    function enable_sensor_events(body: Opaque<"b2Body">, shape_index: number, enable: boolean): void;
     /**
      * Get the body owning a shape.
      *
@@ -103,6 +111,7 @@ declare global {
      * @returns owning body
      */
     function get_body(shape_id: Opaque<"b2Shape">): Opaque<"b2Body">;
+    function get_body(body: Opaque<"b2Body">, shape_index: number): Opaque<"b2Body">;
     /**
      * Get the closest point on a shape.
      *
@@ -111,6 +120,7 @@ declare global {
      * @returns closest world point on the shape
      */
     function get_closest_point(shape_id: Opaque<"b2Shape">, target: Vector3): Vector3;
+    function get_closest_point(body: Opaque<"b2Body">, shape_index: number, target: Vector3): Vector3;
     /**
      * Get shape contact capacity.
      *
@@ -118,6 +128,7 @@ declare global {
      * @returns maximum contact data count
      */
     function get_contact_capacity(shape_id: Opaque<"b2Shape">): number;
+    function get_contact_capacity(body: Opaque<"b2Body">, shape_index: number): number;
     /**
      * Get touching contact data for a shape.
      *
@@ -125,6 +136,7 @@ declare global {
      * @returns array of contact tables
      */
     function get_contact_data(shape_id: Opaque<"b2Shape">): Record<string | number, unknown>;
+    function get_contact_data(body: Opaque<"b2Body">, shape_index: number): Record<string | number, unknown>;
     /**
      * Get mass data for a shape.
      *
@@ -132,6 +144,7 @@ declare global {
      * @returns table with `mass`, `center`, and `inertia`
      */
     function get_mass_data(shape_id: Opaque<"b2Shape">): { mass: number; center: Vector3; inertia: number };
+    function get_mass_data(body: Opaque<"b2Body">, shape_index: number): { mass: number; center: Vector3; inertia: number };
     /**
      * Get shape material id.
      *
@@ -139,6 +152,7 @@ declare global {
      * @returns shape material id
      */
     function get_material(shape_id: Opaque<"b2Shape">): number;
+    function get_material(body: Opaque<"b2Body">, shape_index: number): number;
     /**
      * Get sensor overlap capacity.
      *
@@ -146,6 +160,7 @@ declare global {
      * @returns maximum sensor overlap count
      */
     function get_sensor_capacity(shape_id: Opaque<"b2Shape">): number;
+    function get_sensor_capacity(body: Opaque<"b2Body">, shape_index: number): number;
     /**
      * Get sensor overlaps.
      *
@@ -153,6 +168,7 @@ declare global {
      * @returns array of shape info tables
      */
     function get_sensor_overlaps(shape_id: Opaque<"b2Shape">): { shape_id: number }[];
+    function get_sensor_overlaps(body: Opaque<"b2Body">, shape_index: number): { shape_id: number }[];
     /**
      * Get a shape's geometry.
      *
@@ -160,6 +176,7 @@ declare global {
      * @returns shape table with numeric `type` from `b2d.shape.SHAPE_TYPE_*`
      */
     function get_shape(shape_id: Opaque<"b2Shape">): { type: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 };
+    function get_shape(body: Opaque<"b2Body">, shape_index: number): { type: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 };
     /**
      * Get the world owning a shape.
      *
@@ -167,6 +184,7 @@ declare global {
      * @returns owning world
      */
     function get_world(shape_id: Opaque<"b2Shape">): Opaque<"b2World">;
+    function get_world(body: Opaque<"b2Body">, shape_index: number): Opaque<"b2World">;
     /**
      * Validate a shape handle.
      *
@@ -174,6 +192,7 @@ declare global {
      * @returns true if the shape handle still refers to a live Box2D shape
      */
     function is_valid(shape_id: Opaque<"b2Shape">): boolean;
+    function is_valid(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Ray cast a shape directly.
      *
@@ -184,6 +203,7 @@ declare global {
      * @returns hit table with `point`, `normal`, `fraction`, and `iterations`, or nil
      */
     function ray_cast(shape_id: Opaque<"b2Shape">, origin: Vector3, translation: Vector3, max_fraction?: number): { point: Vector3; normal: Vector3; fraction: number; iterations: number };
+    function ray_cast(body: Opaque<"b2Body">, shape_index: number, origin: Vector3, translation: Vector3, max_fraction?: number): { point: Vector3; normal: Vector3; fraction: number; iterations: number };
     /**
      * Set shape material id.
      *
@@ -191,6 +211,7 @@ declare global {
      * @param material - shape material id
      */
     function set_material(shape_id: Opaque<"b2Shape">, material: number): void;
+    function set_material(body: Opaque<"b2Body">, shape_index: number, material: number): void;
     /**
      * This updates the shape geometry using the same table format as
      * `b2d.body.create_shape` and `b2d.shape.get_shape`. The body mass is not
@@ -210,7 +231,8 @@ declare global {
      * }
      * ```
      */
-    function set_shape(shape_id: Opaque<"b2Shape">, definition: { type?: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, update_mass: boolean): void;
+    function set_shape(shape_id: Opaque<"b2Shape">, definition: { type?: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, update_mass?: boolean): void;
+    function set_shape(body: Opaque<"b2Body">, shape_index: number, definition: { type?: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, update_mass?: boolean): void;
   }
 }
 

package/generated/buffer.d.ts

@@ -88,10 +88,10 @@ declare global {
      * // copy entire stream
      * const srcstream = buffer.get_stream(srcbuffer, hash("xyz"));
      * const dststream = buffer.get_stream(dstbuffer, hash("xyz"));
-     * buffer.copy_stream(dststream, 0, srcstream, 0, srcstream.length);
+     * buffer.copy_stream(dststream, 0, srcstream, 0, srcstream.length());
      * ```
      */
-    function copy_stream(dst: Opaque<"bufferstream"> & { [index: number]: number }, dstoffset: number, src: Opaque<"bufferstream"> & { [index: number]: number }, srcoffset: number, count: number): void;
+    function copy_stream(dst: Opaque<"bufferstream"> & { [index: number]: number; length: LuaLengthMethod<number> }, dstoffset: number, src: Opaque<"bufferstream"> & { [index: number]: number; length: LuaLengthMethod<number> }, srcoffset: number, count: number): void;
     /**
      * Create a new data buffer containing a specified set of streams. A data buffer
      * can contain one or more streams with typed data. This is useful for managing
@@ -111,24 +111,27 @@ declare global {
      * ```ts
      * // How to create and initialize a buffer
      * export default defineScript({
-     *   init(self) {
+     *   init() {
      *     const size = 128;
-     *     self.image = buffer.create(size * size, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
-     *     self.imagestream = buffer.get_stream(self.image, hash("rgb"));
-     *
-     *     for (let y = 0; y < self.height; y++) {
-     *       for (let x = 0; x < self.width; x++) {
-     *         const index = y * self.width * 3 + x * 3;
-     *         self.imagestream[index + 0] = self.r;
-     *         self.imagestream[index + 1] = self.g;
-     *         self.imagestream[index + 2] = self.b;
+     *     const [width, height] = [size, size];
+     *     const [r, g, b] = [0xff, 0x80, 0x10];
+     *     const image = buffer.create(size * size, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
+     *     const imagestream = buffer.get_stream(image, hash("rgb"));
+     *
+     *     for (let y = 0; y < height; y++) {
+     *       for (let x = 0; x < width; x++) {
+     *         const index = y * width * 3 + x * 3;
+     *         imagestream[index + 0] = r;
+     *         imagestream[index + 1] = g;
+     *         imagestream[index + 2] = b;
      *       }
      *     }
+     *     return { image, imagestream };
      *   },
      * });
      * ```
      */
-    function create(element_count: number, declaration: { name?: Hash | string; type?: Opaque<"constant">; count?: number }): Opaque<"buffer">;
+    function create(element_count: number, declaration: { name?: Hash | string; type?: buffer.ValueType; count?: number }[]): Opaque<"buffer">;
     /**
      * Get a copy of all the bytes from a specified stream as a Lua string.
      *
@@ -136,7 +139,7 @@ declare global {
      * @param stream_name - the name of the stream
      * @returns the buffer data as a Lua string
      */
-    function get_bytes(buffer: Opaque<"buffer">, stream_name: Hash): string;
+    function get_bytes(buffer: Opaque<"buffer">, stream_name: Hash | string): string;
     /**
      * Get a named metadata entry from a buffer along with its type.
      *
@@ -160,7 +163,7 @@ declare global {
      * @param stream_name - the stream name
      * @returns the data stream
      */
-    function get_stream(buffer: Opaque<"buffer">, stream_name: Hash | string): Opaque<"bufferstream"> & { [index: number]: number };
+    function get_stream(buffer: Opaque<"buffer">, stream_name: Hash | string): Opaque<"bufferstream"> & { [index: number]: number; length: LuaLengthMethod<number> };
     /**
      * Creates or updates a metadata array entry on a buffer.
      * The value type and count given when updating the entry should match those used when first creating it.

package/generated/camera.d.ts

@@ -137,7 +137,7 @@ declare global {
      * export default defineScript({
      *   on_input(self, action_id, action) {
      *     if (action_id === hash("touch")) {
-     *       if (action.pressed) {
+     *       if (action.pressed && action.screen_x !== undefined && action.screen_y !== undefined) {
      *         const perspective_camera = msg.url("#perspective_camera");
      *         const random_z = math.random(
      *           camera.get_near_z(perspective_camera) + 0.01,
@@ -169,7 +169,7 @@ declare global {
      * export default defineScript({
      *   on_input(self, action_id, action) {
      *     if (action_id === hash("touch")) {
-     *       if (action.pressed) {
+     *       if (action.pressed && action.screen_x !== undefined && action.screen_y !== undefined) {
      *         const world_position = camera.screen_xy_to_world(action.screen_x, action.screen_y);
      *         go.set_position(world_position, "/go1");
      *       }

package/generated/collectionfactory.d.ts

@@ -46,18 +46,17 @@ declare global {
      * ```ts
      * // How to spawn a collection of game objects:
      * export default defineScript({
-     *   init(self) {
+     *   init() {
      *     // Spawn a small group of enemies.
      *     const pos = vmath.vector3(100, 12.5, 0);
      *     const rot = vmath.quat_rotation_z(Math.PI / 2);
      *     const scale = 0.5;
-     *     const props = {
-     *       [hash("/enemy_leader")]: { health: 1000.0 },
-     *       [hash("/enemy_1")]: { health: 200.0 },
-     *       [hash("/enemy_2")]: { health: 400.0, color: hash("green") },
-     *     };
+     *     const props = new LuaMap<Hash, Record<string, unknown>>();
+     *     props.set(hash("/enemy_leader"), { health: 1000.0 });
+     *     props.set(hash("/enemy_1"), { health: 200.0 });
+     *     props.set(hash("/enemy_2"), { health: 400.0, color: hash("green") });
      *
-     *     self.enemy_ids = collectionfactory.create("#enemyfactory", pos, rot, props, scale);
+     *     const enemy_ids = collectionfactory.create("#enemyfactory", pos, rot, props, scale);
      *     // enemy_ids now map to the spawned instance ids:
      *     //
      *     // pprint(self.enemy_ids)
@@ -70,8 +69,11 @@ declare global {
      *     // }
      *
      *     // Send "attack" message to the leader. First look up its instance id.
-     *     const leader_id = self.enemy_ids[hash("/enemy_leader")];
-     *     msg.post(leader_id, "attack");
+     *     const leader_id = enemy_ids.get(hash("/enemy_leader"));
+     *     if (leader_id !== undefined) {
+     *       msg.post(leader_id, "attack");
+     *     }
+     *     return { enemy_ids };
      *   },
      * });
      *
@@ -81,7 +83,7 @@ declare global {
      * }
      * ```
      */
-    function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: Record<string | number, unknown>, scale?: number | Vector3): LuaMap<Hash, Hash>;
+    function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: LuaMap<Hash, Record<string | number, unknown>> | Record<string, Record<string | number, unknown>>, scale?: number | Vector3): LuaMap<Hash, Hash>;
     /**
      * This returns status of the collection factory.
      * Calling this function when the factory is not marked as dynamic loading always returns COMP_COLLECTION_FACTORY_STATUS_LOADED.

package/generated/collectionproxy.d.ts

@@ -62,7 +62,7 @@ declare global {
      * });
      * ```
      */
-    function load(url: string | Hash | Url, options: Record<string | number, unknown> | undefined, callback: (self: unknown, message_id: unknown, message: unknown, sender: unknown) => void): void;
+    function load(url: string | Hash | Url, options: Record<string | number, unknown> | undefined, callback: (self: unknown, message_id: Hash, message: Record<string | number, unknown>, sender: Url) => void): void;
     /**
      * The collection should be loaded by the collection proxy.
      * Setting the collection to "nil" will revert it back to the original collection.

package/generated/compute.d.ts

@@ -299,7 +299,7 @@ declare global {
      * compute.set_textures("/my_compute.computec", { my_texture: resource.texture() });
      * ```
      */
-    function set_textures(path: Hash | string, textures: LuaMap<string, Hash>): void;
+    function set_textures(path: Hash | string, textures: LuaMap<string, Hash> | Record<string, Hash>): void;
   }
 }
 

package/generated/go.d.ts

@@ -321,7 +321,7 @@ declare global {
      * go.delete(ids, true);
      * ```
      */
-    function _delete(id?: SceneGameObjectAddress | Hash | Url | (SceneGameObjectAddress | Hash | Url)[], recursive?: boolean): void;
+    function _delete(id?: SceneGameObjectAddress | Hash | Url | (SceneGameObjectAddress | Hash | Url)[] | boolean, recursive?: boolean): void;
     /**
      * This function can check for game objects in any collection by specifying
      * the collection name in the URL.
@@ -349,6 +349,10 @@ declare global {
      * @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 });
@@ -791,7 +795,7 @@ declare global {
      *         self.velocity = vmath.vector3();
      *       } else {
      *         // update velocity
-     *         self.velocity = vmath.vector3(action.value * self.max_speed, 0, 0);
+     *         self.velocity = vmath.vector3((action.value ?? 0) * self.max_speed, 0, 0);
      *       }
      *     }
      *   },
@@ -833,12 +837,12 @@ declare global {
      *   init() {
      *     // store the url of instance "a" for later use, by specifying undefined as socket we
      *     // automatically use our own socket
-     *     return { a_url: msg.url(undefined, go.get_id("a"), "script") };
+     *     return { a_url: msg.url(undefined, go.get_id("a"), "script"), important_value: 0 };
      *   },
      *
      *   on_message(self, message_id, message, sender) {
      *     // check message and sender
-     *     if (message_id === hash("my_data") && sender === self.a_url) {
+     *     if (message_id === hash("my_data") && sender === self.a_url && typeof message.important_value === "number") {
      *       // use the data in some way
      *       self.important_value = message.important_value;
      *     }
@@ -880,7 +884,7 @@ declare global {
      *         self.velocity = vmath.vector3();
      *       } else {
      *         // update velocity
-     *         self.velocity = vmath.vector3(action.value * self.max_speed, 0, 0);
+     *         self.velocity = vmath.vector3((action.value ?? 0) * self.max_speed, 0, 0);
      *       }
      *     }
      *   },

package/generated/graphics.d.ts

@@ -95,6 +95,58 @@ declare global {
     const FACE_TYPE_BACK: number & { readonly __brand: "graphics.FACE_TYPE_BACK" };
     const FACE_TYPE_FRONT: number & { readonly __brand: "graphics.FACE_TYPE_FRONT" };
     const FACE_TYPE_FRONT_AND_BACK: number & { readonly __brand: "graphics.FACE_TYPE_FRONT_AND_BACK" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_BONE_INDICES: number & { readonly __brand: "graphics.SEMANTIC_TYPE_BONE_INDICES" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_BONE_WEIGHTS: number & { readonly __brand: "graphics.SEMANTIC_TYPE_BONE_WEIGHTS" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_COLOR: number & { readonly __brand: "graphics.SEMANTIC_TYPE_COLOR" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_MORPH_TARGET_WEIGHTS: number & { readonly __brand: "graphics.SEMANTIC_TYPE_MORPH_TARGET_WEIGHTS" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_NONE: number & { readonly __brand: "graphics.SEMANTIC_TYPE_NONE" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_NORMAL: number & { readonly __brand: "graphics.SEMANTIC_TYPE_NORMAL" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_NORMAL_MATRIX: number & { readonly __brand: "graphics.SEMANTIC_TYPE_NORMAL_MATRIX" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_PAGE_INDEX: number & { readonly __brand: "graphics.SEMANTIC_TYPE_PAGE_INDEX" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_POSITION: number & { readonly __brand: "graphics.SEMANTIC_TYPE_POSITION" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_TANGENT: number & { readonly __brand: "graphics.SEMANTIC_TYPE_TANGENT" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_TEXCOORD: number & { readonly __brand: "graphics.SEMANTIC_TYPE_TEXCOORD" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_TEXTURE_TRANSFORM_2D: number & { readonly __brand: "graphics.SEMANTIC_TYPE_TEXTURE_TRANSFORM_2D" };
+    /**
+     * Vertex attribute semantic type, for `material.set_vertex_attributes`.
+     */
+    const SEMANTIC_TYPE_WORLD_MATRIX: number & { readonly __brand: "graphics.SEMANTIC_TYPE_WORLD_MATRIX" };
     const STATE_ALPHA_TEST: number & { readonly __brand: "graphics.STATE_ALPHA_TEST" };
     const STATE_ALPHA_TEST_SUPPORTED: number & { readonly __brand: "graphics.STATE_ALPHA_TEST_SUPPORTED" };
     const STATE_BLEND: number & { readonly __brand: "graphics.STATE_BLEND" };

package/generated/gui.d.ts

@@ -1,5 +1,5 @@
 /** @noSelfInFile */
-import type { Hash, Opaque, Quaternion, Url, Vector, Vector3, Vector4 } from "../src/core-types";
+import type { Hash, Matrix4, Opaque, Quaternion, Url, Vector, Vector3, Vector4 } from "../src/core-types";
 
 declare global {
   /**
@@ -622,15 +622,15 @@ declare global {
      * const node = gui.get_node("my_node");
      * // animate to new position
      * const pos = vmath.vector3(100, 100, 0);
-     * gui.animate(node, "position", pos, go.EASING_LINEAR, 2);
+     * gui.animate(node, "position", pos, gui.EASING_LINEAR, 2);
      * // ...
      * // cancel animation of the x component.
      * gui.cancel_animations(node, "position.x");
      *
      * // Cancels all property animations on a node in a single call:
      * // animate to new position and scale
-     * gui.animate(node, "position", vmath.vector3(100, 100, 0), go.EASING_LINEAR, 5);
-     * gui.animate(node, "scale", vmath.vector3(0.5), go.EASING_LINEAR, 5);
+     * 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);
@@ -711,6 +711,10 @@ declare global {
      * @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 });
@@ -758,7 +762,7 @@ declare global {
      * @param node - node to get the property for
      * @param property - the property to retrieve
      * @param options - optional options table (only applicable for material constants)
-     * - `index` number index into array property (1 based)
+     * - `index` number zero-based index into array property; the transpiler emits Defold's 1-based index
      * @example
      * ```ts
      * // Get properties on existing nodes:
@@ -1380,12 +1384,14 @@ declare global {
      * const size = 4;
      * const pos = vmath.vector3(200, 200, 0);
      * const path = "/assets/images/logo_4x4.astc";
-     * const buffer = sys.load_resource(path);
-     * 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", buffer, false);
-     * gui.set_texture(n, path);
+     * 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 | Opaque<"constant">, buffer: string, flip?: boolean): LuaMultiReturn<[boolean, number]>;
@@ -1530,6 +1536,10 @@ declare global {
      * @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")) {
@@ -1563,6 +1573,10 @@ declare global {
      * @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);
@@ -1707,7 +1721,12 @@ declare global {
      *   },
      *
      *   on_input(self, action_id, action) {
-     *     if (action_id === hash("touch") && action.pressed) {
+     *     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);
@@ -1765,13 +1784,13 @@ declare global {
      * @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 options table (only applicable for material constants)
-     * - `index` number index into array property (1 based)
+     * - `index` number zero-based index into array property; the transpiler emits Defold's 1-based index
      * - `key` hash name of internal property
      * @example
      * ```ts
      * // Updates the position property on an existing node:
      * const node = gui.get_node("my_box_node");
-     * const node_position = gui.get(node, "position");
+     * const node_position = gui.get(node, "position") as Vector3;
      * gui.set(node, "position.x", node_position.x + 128);
      *
      * // Updates the rotation property on an existing node:
@@ -1788,23 +1807,23 @@ declare global {
      * // 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 });
+     * // uniform vec4 tint_array[4]; // TypeScript and the shader are both 0 based
+     * gui.set(node, "tint_array", vmath.vector4(1, 0, 0, 1), { index: 3 });
      * // 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 });
+     * gui.set(node, "light_matrix_array", vmath.matrix4(), { index: 3 });
      * // 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 });
+     * gui.set(node, "tint_array.x", 1, { index: 3 });
      *
      * // Set a named property
      * export default defineGuiScript({
      *   on_message(self, message_id, message) {
-     *     if (message_id === hash("set_font")) {
+     *     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")) {
+     *     } 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");
@@ -1823,7 +1842,7 @@ declare global {
      * resource.release(atlas_id);
      * ```
      */
-    function set(node: Opaque<"node"> | Url, property: string | Hash | gui.Property, value?: number | Vector4 | Vector3 | Quaternion, options?: { index?: number; key?: Hash }): void;
+    function set(node: Opaque<"node"> | Url, property: string | Hash | gui.Property, value?: number | Vector4 | Vector3 | Quaternion | Matrix4 | Hash, options?: { index?: number; key?: string | Hash }): void;
     /**
      * Sets the adjust mode on a node.
      * The adjust mode defines how the node will adjust itself to screen
@@ -2129,7 +2148,7 @@ declare global {
      * @param node - node to set the rotation for
      * @param rotation - new rotation
      */
-    function set_rotation(node: Opaque<"node">, rotation: Quaternion | Vector4): void;
+    function set_rotation(node: Opaque<"node">, rotation: Quaternion | Vector4 | Vector3): void;
     /**
      * Sets how the safe area is applied to this gui scene.
      *
@@ -2362,15 +2381,17 @@ declare global {
      * // 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(self) {
-     *     // fetch the score text node for later use (assumes it is called "score")
-     *     self.score_node = gui.get_node("score");
-     *     // keep track of the current score counted up so far
-     *     self.current_score = 0;
-     *     // keep track of the target score we should count up to
-     *     self.target_score = 0;
-     *     // how fast we will update the score, in score/second
-     *     self.score_update_speed = 1;
+     *   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) {
@@ -2389,7 +2410,7 @@ declare global {
      *
      *   on_message(self, message_id, message) {
      *     // check the message
-     *     if (message_id === hash("set_score")) {
+     *     if (message_id === hash("set_score") && typeof message.score === "number") {
      *       self.target_score = message.score;
      *     }
      *   },

package/generated/html5.d.ts

@@ -18,7 +18,9 @@ declare global {
      * const res = html5.run("10 + 20"); // returns the string "30"
      * print(res);
      * const res_num = tonumber(res); // convert to number
-     * print(res_num - 20); // prints 10
+     * if (res_num !== undefined) {
+     *   print(res_num - 20); // prints 10
+     * }
      * ```
      */
     function run(code: string): string;