@defold-typescript/types 0.39.0 → 0.40.0

package/generated/versions/defold-1.13.0/resource.d.ts

@@ -21,9 +21,11 @@ declare global {
      * Load an atlas and set it to a sprite:
      * ```ts
      * // Load an atlas and set it to a sprite:
-     * go.property("my_atlas", resource.atlas("/atlas.atlas"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_atlas: resource.atlas("/atlas.atlas") },
+     *
      *   init(self) {
      *     go.set("#sprite", "image", self.my_atlas);
      *   },
@@ -33,9 +35,11 @@ declare global {
      * Load an atlas and set it to a gui:
      * ```ts
      * // Load an atlas and set it to a gui:
-     * go.property("my_atlas", resource.atlas("/atlas.atlas"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_atlas: resource.atlas("/atlas.atlas") },
+     *
      *   init(self) {
      *     go.set("#gui", "textures", self.my_atlas, { key: "my_atlas" });
      *   },
@@ -57,9 +61,11 @@ declare global {
      * @example
      * ```ts
      * // Set a unique buffer it to a sprite:
-     * go.property("my_buffer", resource.buffer("/cube.buffer"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_buffer: resource.buffer("/cube.buffer") },
+     *
      *   init(self) {
      *     go.set("#mesh", "vertices", self.my_buffer);
      *   },
@@ -195,7 +201,7 @@ declare global {
      * });
      * ```
      */
-    function create_atlas(path: string, table: { texture?: string | Hash; animations?: { id?: string; width?: number; height?: number; frame_start?: number; frame_end?: number; playback?: Opaque<"constant">; fps?: number; flip_vertical?: boolean; flip_horizontal?: boolean }[]; geometries?: { id?: string; width?: number; height?: number; pivot_x?: number; pivot_y?: number; rotated?: boolean }[]; vertices?: number[]; uvs?: number[]; indices?: number[] }): Hash;
+    function create_atlas(path: string, table: { texture?: string | Hash; animations?: { id?: string; width?: number; height?: number; frame_start?: number; frame_end?: number; playback?: go.Playback; fps?: number; flip_vertical?: boolean; flip_horizontal?: boolean }[]; geometries?: { id?: string; width?: number; height?: number; pivot_x?: number; pivot_y?: number; rotated?: boolean }[]; vertices?: number[]; uvs?: number[]; indices?: number[] }): Hash;
     /**
      * This function creates a new buffer resource that can be used in the same way as any buffer created during build time.
      * The function requires a valid buffer created from either buffer.create or another pre-existing buffer resource.
@@ -244,9 +250,9 @@ declare global {
      *     const stream = buffer.get_stream(buffer_handle, hash("position"));
      *
      *     // transfer vertex data to buffer
-     *     for (let k = 0; k < positions.length; k++) {
-     *       stream[k] = positions[k];
-     *     }
+     *     positions.forEach((value, k) => {
+     *       stream[k] = value;
+     *     });
      *
      *     const my_buffer = resource.create_buffer("/my_buffer.bufferc", { buffer: buffer_handle });
      *     go.set("/go#mesh", "vertices", my_buffer);
@@ -288,6 +294,11 @@ declare global {
      * export default defineScript({
      *   init() {
      *     // create a new sound resource, given the initial chunk of the file
+     *     const [data] = sys.load_resource("/sounds/music_header.oggc");
+     *     if (data === undefined) {
+     *       return;
+     *     }
+     *     const filesize = 1048576;
      *     const relative_path = "/a/unique/resource/name.oggc";
      *     const hash = resource.create_sound_data(relative_path, { data, filesize, partial: true });
      *     go.set("#music", "sound", hash); // override the previous sound resource
@@ -477,8 +488,8 @@ declare global {
      *       width: 32,
      *       height: 32,
      *       depth: 32,
-     *       format: resource.TEXTURE_FORMAT_RGBA32F,
-     *       flags: resource.TEXTURE_USAGE_FLAG_STORAGE + resource.TEXTURE_USAGE_FLAG_SAMPLE,
+     *       format: graphics.TEXTURE_FORMAT_RGBA32F,
+     *       flags: graphics.TEXTURE_USAGE_FLAG_STORAGE + graphics.TEXTURE_USAGE_FLAG_SAMPLE,
      *     });
      *
      *     // pass the backing texture to the render script
@@ -708,9 +719,11 @@ declare global {
      * Load a font and set it to a label:
      * ```ts
      * // Load a font and set it to a label:
-     * go.property("my_font", resource.font("/font.font"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_font: resource.font("/font.font") },
+     *
      *   init(self) {
      *     go.set("#label", "font", self.my_font);
      *   },
@@ -720,9 +733,11 @@ declare global {
      * Load a font and set it to a gui:
      * ```ts
      * // Load a font and set it to a gui:
-     * go.property("my_font", resource.font("/font.font"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_font: resource.font("/font.font") },
+     *
      *   init(self) {
      *     go.set("#gui", "fonts", self.my_font, { key: "my_font" });
      *   },
@@ -746,7 +761,7 @@ declare global {
      * `geometries`, preserving the frame-to-geometry mapping used by the atlas.
      * See resource.set_atlas for a detailed description of each field
      */
-    function get_atlas(path: Hash | string): { texture: string | Hash; animations: { id: string; width: number; height: number; frame_start: number; frame_end: number; playback: Opaque<"constant">; fps: number; flip_vertical: boolean; flip_horizontal: boolean }[]; geometries: { vertices: number[]; uvs: number[]; indices: number[] }[] };
+    function get_atlas(path: Hash | string): { texture: string | Hash; animations: { id: string; width: number; height: number; frame_start: number; frame_end: number; playback: go.Playback; fps: number; flip_vertical: boolean; flip_horizontal: boolean }[]; geometries: { vertices: number[]; uvs: number[]; indices: number[] }[] };
     /**
      * gets the buffer from a resource
      *
@@ -757,11 +772,11 @@ declare global {
      * // How to get the data from a buffer
      * export default defineScript({
      *   init() {
-     *     const res_path = go.get("#mesh", "vertices");
+     *     const res_path = go.get<mesh.properties>()("#mesh", "vertices");
      *     const buf = resource.get_buffer(res_path);
      *     const stream_positions = buffer.get_stream(buf, "position");
      *
-     *     for (let i = 0; i < stream_positions.length; i++) {
+     *     for (let i = 0; i < stream_positions.length(); i++) {
      *       print(i, stream_positions[i]);
      *     }
      *   },
@@ -871,7 +886,7 @@ declare global {
      * ```ts
      * export default defineScript({
      *   init() {
-     *     const font = go.get("#label", "font");
+     *     const font = go.get<label.properties>()("#label", "font");
      *     const metrics = resource.get_text_metrics(font, "The quick brown fox\n jumps over the lazy dog");
      *     pprint(metrics);
      *   },
@@ -993,9 +1008,11 @@ declare global {
      * Load a material and set it to a sprite:
      * ```ts
      * // Load a material and set it to a sprite:
-     * go.property("my_material", resource.material("/material.material"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_material: resource.material("/material.material") },
+     *
      *   init(self) {
      *     go.set("#sprite", "material", self.my_material);
      *   },
@@ -1005,9 +1022,11 @@ declare global {
      * Load a material resource and update a named material with the resource:
      * ```ts
      * // Load a material resource and update a named material with the resource:
-     * go.property("my_material", resource.material("/material.material"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_material: resource.material("/material.material") },
+     *
      *   init(self) {
      *     go.set("#gui", "materials", self.my_material, { key: "my_material" });
      *   },
@@ -1036,9 +1055,11 @@ declare global {
      * @example
      * ```ts
      * // Set a render target color attachment as a model texture:
-     * go.property("my_render_target", resource.render_target("/rt.render_target"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_render_target: resource.render_target("/rt.render_target") },
+     *
      *   init(self) {
      *     const rt_info = resource.get_render_target_info(self.my_render_target);
      *     go.set("#model", "texture0", rt_info.attachments[0]!.texture!);
@@ -1057,7 +1078,7 @@ declare global {
      * // Assuming the folder "/res" is added to the project custom resources:
      * // load a texture resource and set it on a sprite
      * const buffer = resource.load("/res/new.texturec");
-     * resource.set(go.get("#sprite", "texture0"), buffer);
+     * resource.set(go.get<sprite.properties>()("#sprite", "texture0"), buffer);
      * ```
      */
     function set(path: string | Hash, buffer: Opaque<"buffer">): void;
@@ -1136,6 +1157,8 @@ declare global {
      *       frame_end: 6,
      *       playback: go.PLAYBACK_LOOP_PINGPONG,
      *       fps: 8,
+     *       flip_vertical: false,
+     *       flip_horizontal: false,
      *     };
      *     data.animations.push(my_animation);
      *     resource.set_atlas("/main/my_atlas.a.texturesetc", data);
@@ -1171,7 +1194,7 @@ declare global {
      * });
      * ```
      */
-    function set_atlas(path: Hash | string, table: { texture?: string | Hash; animations?: { id?: string; width?: number; height?: number; frame_start?: number; frame_end?: number; playback?: Opaque<"constant">; fps?: number; flip_vertical?: boolean; flip_horizontal?: boolean }[]; geometries?: { vertices?: number[]; uvs?: number[]; indices?: number[] }[]; vertices?: number[]; uvs?: number[]; indices?: number[] }): void;
+    function set_atlas(path: Hash | string, table: { texture?: string | Hash; animations?: { id?: string; width?: number; height?: number; frame_start?: number; frame_end?: number; playback?: go.Playback; fps?: number; flip_vertical?: boolean; flip_horizontal?: boolean }[]; geometries?: { vertices?: number[]; uvs?: number[]; indices?: number[] }[]; vertices?: number[]; uvs?: number[]; indices?: number[] }): void;
     /**
      * Sets the buffer of a resource. By default, setting the resource buffer will either copy the data from the incoming buffer object
      * to the buffer stored in the destination resource, or make a new buffer object if the sizes between the source buffer and the destination buffer
@@ -1198,7 +1221,7 @@ declare global {
      *
      * export default defineScript({
      *   init() {
-     *     const res_path = go.get("#mesh", "vertices");
+     *     const res_path = go.get<mesh.properties>()("#mesh", "vertices");
      *
      *     const positions = [
      *       1, -1, 0,
@@ -1318,24 +1341,25 @@ declare global {
      * ```ts
      * // How to set all pixels of an atlas
      * export default defineScript({
-     *   init(self) {
-     *     self.height = 128;
-     *     self.width = 128;
-     *     self.buffer = buffer.create(self.width * self.height, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
-     *     self.stream = buffer.get_stream(self.buffer, 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.stream[index + 0] = 0xff;
-     *         self.stream[index + 1] = 0x80;
-     *         self.stream[index + 2] = 0x10;
+     *   init() {
+     *     const height = 128;
+     *     const width = 128;
+     *     const buf = buffer.create(width * height, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
+     *     const stream = buffer.get_stream(buf, hash("rgb"));
+     *
+     *     for (let y = 0; y < height; y++) {
+     *       for (let x = 0; x < width; x++) {
+     *         const index = y * width * 3 + x * 3;
+     *         stream[index + 0] = 0xff;
+     *         stream[index + 1] = 0x80;
+     *         stream[index + 2] = 0x10;
      *       }
      *     }
      *
-     *     const resource_path = go.get("#model", "texture0");
-     *     const args = { width: self.width, height: self.height, type: graphics.TEXTURE_TYPE_2D, format: graphics.TEXTURE_FORMAT_RGB, num_mip_maps: 1 };
-     *     resource.set_texture(resource_path, args, self.buffer);
+     *     const resource_path = go.get<model.properties>()("#model", "texture0");
+     *     const args = { width, height, type: graphics.TEXTURE_TYPE_2D, format: graphics.TEXTURE_FORMAT_RGB, num_mip_maps: 1 };
+     *     resource.set_texture(resource_path, args, buf);
+     *     return { buffer: buf, stream };
      *   },
      * });
      * ```
@@ -1344,26 +1368,27 @@ declare global {
      * ```ts
      * // How to update a specific region of an atlas by using the x,y values. Assumes the already set atlas is a 128x128 texture.
      * export default defineScript({
-     *   init(self) {
-     *     self.x = 16;
-     *     self.y = 16;
-     *     self.height = 128 - self.x * 2;
-     *     self.width = 128 - self.y * 2;
-     *     self.buffer = buffer.create(self.width * self.height, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
-     *     self.stream = buffer.get_stream(self.buffer, 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.stream[index + 0] = 0xff;
-     *         self.stream[index + 1] = 0x80;
-     *         self.stream[index + 2] = 0x10;
+     *   init() {
+     *     const x = 16;
+     *     const y = 16;
+     *     const height = 128 - x * 2;
+     *     const width = 128 - y * 2;
+     *     const buf = buffer.create(width * height, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
+     *     const stream = buffer.get_stream(buf, hash("rgb"));
+     *
+     *     for (let row = 0; row < height; row++) {
+     *       for (let col = 0; col < width; col++) {
+     *         const index = row * width * 3 + col * 3;
+     *         stream[index + 0] = 0xff;
+     *         stream[index + 1] = 0x80;
+     *         stream[index + 2] = 0x10;
      *       }
      *     }
      *
-     *     const resource_path = go.get("#model", "texture0");
-     *     const args = { width: self.width, height: self.height, x: self.x, y: self.y, type: graphics.TEXTURE_TYPE_2D, format: graphics.TEXTURE_FORMAT_RGB, num_mip_maps: 1 };
-     *     resource.set_texture(resource_path, args, self.buffer);
+     *     const resource_path = go.get<model.properties>()("#model", "texture0");
+     *     const args = { width, height, x, y, type: graphics.TEXTURE_TYPE_2D, format: graphics.TEXTURE_FORMAT_RGB, num_mip_maps: 1 };
+     *     resource.set_texture(resource_path, args, buf);
+     *     return { buffer: buf, stream };
      *   },
      * });
      * ```
@@ -1371,11 +1396,13 @@ declare global {
      * Update a texture from a buffer resource
      * ```ts
      * // Update a texture from a buffer resource
-     * go.property("my_buffer", resource.buffer("/my_default_buffer.buffer"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_buffer: resource.buffer("/my_default_buffer.buffer") },
+     *
      *   init(self) {
-     *     const resource_path = go.get("#model", "texture0");
+     *     const resource_path = go.get<model.properties>()("#model", "texture0");
      *     // the "my_buffer" resource is expected to hold 128 * 128 * 3 bytes!
      *     const args = {
      *       width: 128,
@@ -1419,7 +1446,7 @@ declare global {
      *       width: 8,
      *       height: 8,
      *       depth: 8,
-     *       format: resource.TEXTURE_FORMAT_RGBA32F,
+     *       format: graphics.TEXTURE_FORMAT_RGBA32F,
      *     };
      *
      *     // This expects that the texture resource "/my_3d_texture.texturec" already exists
@@ -1476,9 +1503,11 @@ declare global {
      * @example
      * ```ts
      * // Load a texture and set it to a model:
-     * go.property("my_texture", resource.texture("/texture.png"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_texture: resource.texture("/texture.png") },
+     *
      *   init(self) {
      *     go.set("#model", "texture0", self.my_texture);
      *   },
@@ -1500,9 +1529,11 @@ declare global {
      * @example
      * ```ts
      * // Load tile source and set it to a tile map:
-     * go.property("my_tile_source", resource.tile_source("/tilesource.tilesource"));
-     *
      * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_tile_source: resource.tile_source("/tilesource.tilesource") },
+     *
      *   init(self) {
      *     go.set("#tilemap", "tile_source", self.my_tile_source);
      *   },

package/generated/versions/defold-1.13.0/socket.d.ts

@@ -17,7 +17,7 @@ declare global {
    * require "builtins.scripts.socket"
    * ```
    *
-   * LuaSocket is Copyright © 2004-2007 Diego Nehab. All rights reserved.
+   * LuaSocket is Copyright © 2004-2007 Diego Nehab. All rights reserved.
    * LuaSocket is free software, released under the MIT license (same license as the Lua core).
    */
   namespace socket {
@@ -640,15 +640,18 @@ declare global {
      *   // create a try function that closes 'c' on error
      *   const try_ = socket.newtry(() => c.close());
      *   // do everything reassured c will be closed
-     *   try_(c.send("hello there?\r\n"));
-     *   const answer = try_(c.receive());
+     *   const [sent, sendError, lastByte] = c.send("hello there?\r\n");
+     *   try_(sent, sendError, lastByte);
+     *   const [line, receiveError, partial] = c.receive();
+     *   const answer = try_(line, receiveError, partial);
      *   // ...
-     *   try_(c.send("good bye\r\n"));
+     *   const [byeSent, byeError, byeLastByte] = c.send("good bye\r\n");
+     *   try_(byeSent, byeError, byeLastByte);
      *   c.close();
      * }
      * ```
      */
-    function newtry(finalizer: () => void): (...args: unknown[]) => unknown;
+    function newtry(finalizer?: () => void): <T>(value: T | undefined, ...rest: T extends { readonly __tstlMultiReturn: unknown } ? [boxedMultiReturn: never] : unknown[]) => T;
     /**
      * Converts a function that throws exceptions into a safe function. This function only catches exceptions thrown by try functions. It does not catch normal Lua errors.
      * Beware that if your function performs some illegal operation that raises an error, the protected function will catch the error and return it as a string. This is because try functions uses errors as the mechanism to throw exceptions.
@@ -659,17 +662,20 @@ declare global {
      * ```ts
      * const dostuff = socket.protect(() => {
      *   let try_ = socket.newtry();
-     *   const c = try_(socket.connect("myserver.com", 80));
+     *   const [conn, connectError] = socket.connect("myserver.com", 80);
+     *   const c = try_(conn, connectError);
      *   try_ = socket.newtry(() => c.close());
-     *   try_(c.send("hello?\r\n"));
-     *   const answer = try_(c.receive());
+     *   const [sent, sendError, lastByte] = c.send("hello?\r\n");
+     *   try_(sent, sendError, lastByte);
+     *   const [line, receiveError, partial] = c.receive();
+     *   const answer = try_(line, receiveError, partial);
      *   c.close();
      * });
      *
      * const [n, error] = dostuff();
      * ```
      */
-    function protect(func: (...args: unknown[]) => unknown): (arg0: unknown) => void;
+    function protect(func: (...args: unknown[]) => unknown): (...args: unknown[]) => LuaMultiReturn<[unknown, string | undefined]>;
     /**
      * The function returns a list with the sockets ready for reading, a list with the sockets ready for writing and an error message. The error message is "timeout" if a timeout condition was met and nil otherwise. The returned tables are doubly keyed both by integers and also by the sockets themselves, to simplify the test if a specific socket has changed status.
      * `Recvt` and `sendt` parameters can be empty tables or `nil`. Non-socket values (or values with non-numeric indices) in these arrays will be silently ignored.
@@ -700,12 +706,16 @@ declare global {
      * const line = "250 OK";
      *
      * // Instead of doing the following with dummy variables:
-     * // get the status code and separator from SMTP server reply
-     * const [dummy1, dummy2, code, sep] = string.find(line, "^(%d%d%d)(.?)");
+     * {
+     *   // get the status code and separator from SMTP server reply
+     *   const [dummy1, dummy2, code, sep] = string.find(line, "^(%d%d%d)(.?)");
+     * }
      *
      * // You can skip a number of variables:
-     * // get the status code and separator from SMTP server reply
-     * const [code, sep] = socket.skip(2, string.find(line, "^(%d%d%d)(.?)"));
+     * {
+     *   // get the status code and separator from SMTP server reply
+     *   const [code, sep] = socket.skip(2, string.find(line, "^(%d%d%d)(.?)"));
+     * }
      * ```
      */
     function skip(d: number, ret1?: unknown, ret2?: unknown, retN?: unknown): LuaMultiReturn<[unknown, unknown, unknown]>;

package/generated/versions/defold-1.13.0/sound.d.ts

@@ -83,7 +83,7 @@ declare global {
      * square root of the mean (average) value of the squared function of
      * the instantaneous values.
      * For instance: for a sinewave signal with a peak gain of -1.94 dB (0.8 linear),
-     * the RMS is `0.8 × 1/sqrt(2)` which is about 0.566.
+     * the RMS is `0.8 × 1/sqrt(2)` which is about 0.566.
      * Note the returned value might be an approximation and in particular
      * the effective window might be larger than specified.
      *
@@ -202,8 +202,8 @@ declare global {
      * }
      *
      * export default defineScript({
-     *   init(self) {
-     *     self.countdown_id = sound.play("#countdown", undefined, sound_done);
+     *   init() {
+     *     return { countdown_id: sound.play("#countdown", undefined, sound_done) };
      *   },
      * });
      * ```

package/generated/versions/defold-1.13.0/sprite.d.ts

@@ -52,7 +52,7 @@ declare global {
      * });
      * ```
      */
-    function play_flipbook(url: string | Hash | Url, id: string | Hash, complete_function?: (self: unknown, message_id: unknown, message: unknown, sender: unknown) => void, play_properties?: { offset?: number; playback_rate?: number }): void;
+    function play_flipbook(url: string | Hash | Url, id: string | Hash, complete_function?: (self: unknown, message_id: Hash, message: { current_tile: number; id: Hash }, sender: Url) => void, play_properties?: { offset?: number; playback_rate?: number }): void;
     /**
      * Resets a shader constant for a sprite component.
      * The constant must be defined in the material assigned to the sprite.
@@ -79,6 +79,10 @@ declare global {
      * // How to flip a sprite so it faces the horizontal movement (it is assumed that
      * // the sprite component has id "sprite" and the original animation faces right):
      * export default defineScript({
+     *   init() {
+     *     return { velocity: vmath.vector3() };
+     *   },
+     *
      *   update(self, dt) {
      *     // calculate self.velocity somehow
      *     sprite.set_hflip("#sprite", self.velocity.x < 0);
@@ -100,6 +104,10 @@ declare global {
      * // assumed that the sprite component has id "sprite" and the original animation
      * // is up-right):
      * export default defineScript({
+     *   init() {
+     *     return { up_side_down: false };
+     *   },
+     *
      *   update(self, dt) {
      *     // calculate self.up_side_down somehow, then:
      *     sprite.set_vflip("#sprite", self.up_side_down);

package/generated/versions/defold-1.13.0/sys.d.ts

@@ -55,11 +55,12 @@ declare global {
      * @example
      * ```ts
      * // Load data but return nil if path didn't exist
-     * const path = "/save/game.dat";
-     * if (!sys.exists(path)) {
-     *   return undefined;
+     * function load_data(path: string) {
+     *   if (!sys.exists(path)) {
+     *     return undefined;
+     *   }
+     *   return sys.load(path); // returns {} if it failed
      * }
-     * return sys.load(path); // returns {} if it failed
      * ```
      */
     function exists(path: string): boolean;
@@ -97,7 +98,7 @@ declare global {
      * ```ts
      * // Check if twitter is installed:
      * const sysinfo = sys.get_sys_info();
-     * let twitter = {};
+     * let twitter: { installed?: boolean } = {};
      *
      * if (sysinfo.system_name === "Android") {
      *   twitter = sys.get_application_info("com.twitter.android");
@@ -262,13 +263,17 @@ declare global {
      * @example
      * ```ts
      * // Save data on the host
-     * const mytable = { score: 100, level: 3 };
-     * const host_path = sys.get_host_path("logs/test.txt");
-     * sys.save(host_path, mytable);
+     * {
+     *   const mytable = { score: 100, level: 3 };
+     *   const host_path = sys.get_host_path("logs/test.txt");
+     *   sys.save(host_path, mytable);
+     * }
      *
      * // Load data from the host
-     * const host_path = sys.get_host_path("logs/test.txt");
-     * const table = sys.load(host_path);
+     * {
+     *   const host_path = sys.get_host_path("logs/test.txt");
+     *   const table = sys.load(host_path);
+     * }
      * ```
      */
     function get_host_path(filename: string): string;
@@ -447,14 +452,16 @@ declare global {
      * @example
      * ```ts
      * // Load binary data from a custom project resource and update a texture resource:
-     * function my_callback(self: unknown, request_id: unknown, result: unknown) {
-     *   const { status, buf } = result as { status: number; buf: Opaque<"buffer"> };
-     *   if (status === resource.REQUEST_STATUS_FINISHED) {
-     *     resource.set_texture("/my_texture", {}, buf); // texture args
+     * {
+     *   function my_callback(self: unknown, request_id: unknown, result: unknown) {
+     *     const { status, buf } = result as { status: number; buf: Opaque<"buffer"> };
+     *     if (status === sys.REQUEST_STATUS_FINISHED) {
+     *       resource.set_texture("/my_texture", {}, buf); // texture args
+     *     }
      *   }
-     * }
      *
-     * const my_request = sys.load_buffer_async("/assets/my_level_data.bin", my_callback);
+     *   const my_request = sys.load_buffer_async("/assets/my_level_data.bin", my_callback);
+     * }
      *
      * // Load binary data from non-custom resource files on disk:
      * function my_callback(self: unknown, request_id: unknown, result: unknown) {
@@ -469,11 +476,15 @@ declare global {
      * }
      *
      * export default defineScript({
-     *   init(self) {
-     *     self.first_asset = hash("folder_next_to_binary/my_level_asset.bin");
-     *     self.second_asset = hash("/some_absolute_path/my_level.bin");
-     *     self.first_request = sys.load_buffer_async(self.first_asset, my_callback);
-     *     self.second_request = sys.load_buffer_async(self.second_asset, my_callback);
+     *   init() {
+     *     const first_path = "folder_next_to_binary/my_level_asset.bin";
+     *     const second_path = "/some_absolute_path/my_level.bin";
+     *     return {
+     *       first_asset: hash(first_path),
+     *       second_asset: hash(second_path),
+     *       first_request: sys.load_buffer_async(first_path, my_callback),
+     *       second_request: sys.load_buffer_async(second_path, my_callback),
+     *     };
      *   },
      * });
      * ```
@@ -572,7 +583,7 @@ declare global {
      * sys.save(my_file_path, my_table);
      * ```
      */
-    function save(filename: string, table: Record<string | number, unknown>): void;
+    function save(filename: string, table: Record<string | number, unknown> | readonly unknown[]): void;
     /**
      * The buffer can later deserialized by `sys.deserialize`.
      * This function has all the same limitations as `sys.save`.
@@ -588,7 +599,7 @@ declare global {
      * const buffer = sys.serialize(my_table);
      * ```
      */
-    function serialize(table: Record<string | number, unknown>): string;
+    function serialize(table: Record<string | number, unknown> | readonly unknown[]): string;
     /**
      * Sets the host that is used to check for network connectivity against.
      *

package/generated/versions/defold-1.13.0/vmath.d.ts

@@ -49,7 +49,7 @@ declare global {
     function conj(q1: Quaternion): Quaternion;
     /**
      * Given two linearly independent vectors P and Q, the cross product,
-     * P × Q, is a vector that is perpendicular to both P and Q and
+     * P × Q, is a vector that is perpendicular to both P and Q and
      * therefore normal to the plane containing them.
      * If the two vectors have the same direction (or have the exact
      * opposite direction from one another, i.e. are not linearly independent)
@@ -70,8 +70,8 @@ declare global {
     function cross(v1: Vector3, v2: Vector3): Vector3;
     /**
      * The returned value is a scalar defined as:
-     * `P ⋅ Q = |P| |Q| cos θ`
-     * where θ is the angle between the vectors P and Q.
+     * `P ⋅ Q = |P| |Q| cos θ`
+     * where θ is the angle between the vectors P and Q.
      *
      * - If the dot product is positive then the angle between the vectors is below 90 degrees.
      *
@@ -437,8 +437,8 @@ declare global {
     /**
      * Calculates the extent the projection of the first vector onto the second.
      * The returned value is a scalar p defined as:
-     * `p = |P| cos θ / |Q|`
-     * where θ is the angle between the vectors P and Q.
+     * `p = |P| cos θ / |Q|`
+     * where θ is the angle between the vectors P and Q.
      *
      * @param v1 - vector to be projected on the second
      * @param v2 - vector onto which the first will be projected, must not have zero length