@defold-typescript/types 0.38.0 → 0.40.0

package/generated/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 {
@@ -635,17 +635,23 @@ declare global {
      * @example
      * ```ts
      * // Perform operations on an open socket c:
-     * // 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());
-     * // ...
-     * try_(c.send("good bye\r\n"));
-     * c.close();
+     * const [c] = socket.connect("localhost", 80);
+     * if (c !== undefined) {
+     *   // create a try function that closes 'c' on error
+     *   const try_ = socket.newtry(() => c.close());
+     *   // do everything reassured c will be closed
+     *   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);
+     *   // ...
+     *   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.
@@ -656,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.
@@ -694,13 +703,19 @@ declare global {
      * @param retN - argument N.
      * @example
      * ```ts
+     * 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/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.
      *
@@ -193,16 +193,17 @@ declare global {
      * sound.play("#sound", { delay: 1, gain: 0.9, pan: -1.0 });
      *
      * // Using the callback argument, you can chain several sounds together:
-     * function sound_done(self, message_id, message, sender) {
+     * function sound_done(self: unknown, message_id: unknown, message: unknown, sender: unknown) {
      *   // play 'boom' sound fx when the countdown has completed
-     *   if (message_id === hash("sound_done") && message.play_id === self.countdown_id) {
+     *   const { play_id } = message as { play_id: number };
+     *   if (message_id === hash("sound_done") && play_id === (self as { countdown_id: number }).countdown_id) {
      *     sound.play("#boom", undefined, sound_done);
      *   }
      * }
      *
      * 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/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/sys.d.ts

@@ -1,5 +1,5 @@
 /** @noSelfInFile */
-import type { Opaque } from "../src/core-types";
+import type { Hash, Opaque } from "../src/core-types";
 
 declare global {
   /**
@@ -7,6 +7,7 @@ declare global {
    * error handling and debugging.
    */
   namespace sys {
+    type NetworkConnectivity = typeof sys.NETWORK_DISCONNECTED | typeof sys.NETWORK_CONNECTED_CELLULAR | typeof sys.NETWORK_CONNECTED;
     /**
      * network connected through other, non cellular, connection
      */
@@ -39,6 +40,7 @@ declare global {
      * @example
      * ```ts
      * // Deserialize a table that was previously serialized:
+     * const my_table = { score: 100, level: 3 };
      * const buffer = sys.serialize(my_table);
      * const table = sys.deserialize(buffer);
      * ```
@@ -53,10 +55,12 @@ declare global {
      * @example
      * ```ts
      * // Load data but return nil if path didn't exist
-     * 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;
@@ -94,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");
@@ -228,7 +232,7 @@ declare global {
      * }
      * ```
      */
-    function get_connectivity(): number & { readonly __brand: "sys.NETWORK_DISCONNECTED" } | number & { readonly __brand: "sys.NETWORK_CONNECTED_CELLULAR" } | number & { readonly __brand: "sys.NETWORK_CONNECTED" };
+    function get_connectivity(): sys.NetworkConnectivity;
     /**
      * Returns a table with engine information.
      *
@@ -259,12 +263,17 @@ declare global {
      * @example
      * ```ts
      * // Save data on the host
-     * 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;
@@ -443,31 +452,39 @@ declare global {
      * @example
      * ```ts
      * // Load binary data from a custom project resource and update a texture resource:
-     * function my_callback(self, request_id, result) {
-     *   if (result.status === resource.REQUEST_STATUS_FINISHED) {
-     *     resource.set_texture("/my_texture", {}, result.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, request_id, result) {
-     *   if (result.status !== sys.REQUEST_STATUS_FINISHED) {
+     * function my_callback(self: unknown, request_id: unknown, result: unknown) {
+     *   const { first_asset, second_asset } = self as { first_asset: Hash; second_asset: Hash };
+     *   if ((result as { status: number }).status !== sys.REQUEST_STATUS_FINISHED) {
      *     // uh oh! File could not be found, do something graceful
-     *   } else if (request_id === self.first_asset) {
+     *   } else if (request_id === first_asset) {
      *     // result.buffer contains data from my_level_asset.bin
-     *   } else if (request_id === self.second_asset) {
+     *   } else if (request_id === second_asset) {
      *     // result.buffer contains data from 'my_level.bin'
      *   }
      * }
      *
      * 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),
+     *     };
      *   },
      * });
      * ```
@@ -566,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`.
@@ -582,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.
      *
@@ -623,7 +640,7 @@ declare global {
      * @example
      * ```ts
      * // Install error handler that just prints the errors
-     * function my_error_handler(source, message, traceback) {
+     * function my_error_handler(source: unknown, message: unknown, traceback: unknown) {
      *   print(source); //> lua
      *   print(message); //> main/my.script:10: attempt to perform arithmetic on a string value
      *   print(traceback); //> stack traceback:

package/generated/tilemap.d.ts

@@ -55,8 +55,10 @@ declare global {
      * @returns index of the tile
      * @example
      * ```ts
-     * // get the tile under the player.
-     * const tileno = tilemap.get_tile("/level#tilemap", "foreground", self.player_x, self.player_y);
+     * function tile_under_player(self: { player_x: number; player_y: number }) {
+     *   // get the tile under the player.
+     *   const tileno = tilemap.get_tile("/level#tilemap", "foreground", self.player_x, self.player_y);
+     * }
      * ```
      */
     function get_tile(url: string | Hash | Url, layer: string | Hash, x: number, y: number): number;
@@ -74,15 +76,17 @@ declare global {
      * @returns index of the tile
      * @example
      * ```ts
-     * // get the tile under the player.
-     * const tile_info = tilemap.get_tile_info("/level#tilemap", "foreground", self.player_x, self.player_y);
-     * pprint(tile_info);
-     * // {
-     * //    index = 0,
-     * //    h_flip = false,
-     * //    v_flip = true,
-     * //    rotate_90 = false
-     * // }
+     * function tile_info_under_player(self: { player_x: number; player_y: number }) {
+     *   // get the tile under the player.
+     *   const tile_info = tilemap.get_tile_info("/level#tilemap", "foreground", self.player_x, self.player_y);
+     *   pprint(tile_info);
+     *   // {
+     *   //    index = 0,
+     *   //    h_flip = false,
+     *   //    v_flip = true,
+     *   //    rotate_90 = false
+     *   // }
+     * }
      * ```
      */
     function get_tile_info(url: string | Hash | Url, layer: string | Hash, x: number, y: number): { index: number; h_flip: boolean; v_flip: boolean; rotate_90: boolean };
@@ -103,7 +107,7 @@ declare global {
      * let count = 0;
      * for (let row_index = bottom; row_index <= bottom + rows_count - 1; row_index++) {
      *   for (let column_index = left; column_index <= left + columns_count - 1; column_index++) {
-     *     tile = tiles[row_index][column_index];
+     *     tile = tiles.get(row_index)?.get(column_index) ?? 0;
      *     count = count + 1;
      *   }
      * }
@@ -155,14 +159,16 @@ declare global {
      * @param transform_bitmask - optional flip and/or rotation should be applied to the tile
      * @example
      * ```ts
-     * // Clear the tile under the player.
-     * tilemap.set_tile("/level#tilemap", "foreground", self.player_x, self.player_y, 0);
+     * function set_tiles(self: { player_x: number; player_y: number }, x: number, y: number) {
+     *   // Clear the tile under the player.
+     *   tilemap.set_tile("/level#tilemap", "foreground", self.player_x, self.player_y, 0);
      *
-     * // Set tile with different combination of flip and rotation
-     * tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.H_FLIP + tilemap.V_FLIP + tilemap.ROTATE_90);
-     * tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.H_FLIP + tilemap.ROTATE_270);
-     * tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.V_FLIP + tilemap.H_FLIP);
-     * tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.ROTATE_180);
+     *   // Set tile with different combination of flip and rotation
+     *   tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.H_FLIP + tilemap.V_FLIP + tilemap.ROTATE_90);
+     *   tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.H_FLIP + tilemap.ROTATE_270);
+     *   tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.V_FLIP + tilemap.H_FLIP);
+     *   tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.ROTATE_180);
+     * }
      * ```
      */
     function set_tile(url: string | Hash | Url, layer: string | Hash, x: number, y: number, tile: number, transform_bitmask?: number): void;

package/generated/timer.d.ts

@@ -20,11 +20,13 @@ declare global {
      * @returns if the timer was active, false if the timer is already cancelled / complete
      * @example
      * ```ts
-     * self.handle = timer.delay(1, true, () => print("print every second"));
-     * // ...
-     * const result = timer.cancel(self.handle);
-     * if (!result) {
-     *   print("the timer is already cancelled");
+     * function cancel_ticking(self: { handle: number }) {
+     *   self.handle = timer.delay(1, true, () => print("print every second"));
+     *   // ...
+     *   const result = timer.cancel(self.handle);
+     *   if (!result) {
+     *     print("the timer is already cancelled");
+     *   }
      * }
      * ```
      */
@@ -54,16 +56,19 @@ declare global {
      * timer.delay(1, false, () => print("print in one second"));
      *
      * // Repetitive timer which canceled after 10 calls
-     * function call_every_second(self, handle, time_elapsed) {
-     *   self.counter = self.counter + 1;
-     *   print("Call #", self.counter);
-     *   if (self.counter === 10) {
-     *     timer.cancel(handle); // cancel timer after 10 calls
+     * function call_every_second(self: unknown, handle: unknown, time_elapsed: unknown) {
+     *   const state = self as { counter: number };
+     *   state.counter = state.counter + 1;
+     *   print("Call #", state.counter);
+     *   if (state.counter === 10) {
+     *     timer.cancel(handle as number); // cancel timer after 10 calls
      *   }
      * }
      *
-     * self.counter = 0;
-     * timer.delay(1, true, call_every_second);
+     * function start_counting(self: { counter: number }) {
+     *   self.counter = 0;
+     *   timer.delay(1, true, call_every_second);
+     * }
      * ```
      */
     function delay(delay: number, repeating: boolean, callback: (self: unknown, handle: unknown, time_elapsed: unknown) => void): number;
@@ -81,13 +86,15 @@ declare global {
      * boolean true = repeat timer until cancel, false = one-shot timer.
      * @example
      * ```ts
-     * self.handle = timer.delay(1, true, () => print("print every second"));
-     * // ...
-     * const result = timer.get_info(self.handle);
-     * if (!result) {
-     *   print("the timer is already cancelled or complete");
-     * } else {
-     *   pprint(result); // delay, time_remaining, repeating
+     * function report_ticking(self: { handle: number }) {
+     *   self.handle = timer.delay(1, true, () => print("print every second"));
+     *   // ...
+     *   const result = timer.get_info(self.handle);
+     *   if (!result) {
+     *     print("the timer is already cancelled or complete");
+     *   } else {
+     *     pprint(result); // delay, time_remaining, repeating
+     *   }
      * }
      * ```
      */
@@ -99,11 +106,13 @@ declare global {
      * @returns if the timer was active, false if the timer is already cancelled / complete
      * @example
      * ```ts
-     * self.handle = timer.delay(1, true, () => print("print every second or manually by timer.trigger"));
-     * // ...
-     * const result = timer.trigger(self.handle);
-     * if (!result) {
-     *   print("the timer is already cancelled or complete");
+     * function trigger_ticking(self: { handle: number }) {
+     *   self.handle = timer.delay(1, true, () => print("print every second or manually by timer.trigger"));
+     *   // ...
+     *   const result = timer.trigger(self.handle);
+     *   if (!result) {
+     *     print("the timer is already cancelled or complete");
+     *   }
      * }
      * ```
      */

package/generated/versions/defold-1.12.4/buffer.d.ts

@@ -6,6 +6,7 @@ declare global {
    * Functions for manipulating buffers and streams
    */
   namespace buffer {
+    type ValueType = typeof buffer.VALUE_TYPE_FLOAT32 | typeof buffer.VALUE_TYPE_INT16 | typeof buffer.VALUE_TYPE_INT32 | typeof buffer.VALUE_TYPE_INT64 | typeof buffer.VALUE_TYPE_INT8 | typeof buffer.VALUE_TYPE_UINT16 | typeof buffer.VALUE_TYPE_UINT32 | typeof buffer.VALUE_TYPE_UINT64 | typeof buffer.VALUE_TYPE_UINT8;
     /**
      * Float, single precision, 4 bytes
      */
@@ -56,11 +57,15 @@ declare global {
      * @example
      * ```ts
      * // How to copy elements (e.g. vertices) from one buffer to another
+     * const element_count = 64;
+     * const srcbuffer = resource.get_buffer("/src.bufferc");
+     * const dstbuffer = resource.get_buffer("/dst.bufferc");
+     *
      * // copy entire buffer
-     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, 0, srcbuffer.length);
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, 0, element_count);
      *
      * // copy last 10 elements to the front of another buffer
-     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, srcbuffer.length - 10, 10);
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, element_count - 10, 10);
      * ```
      */
     function copy_buffer(dst: Opaque<"buffer">, dstoffset: number, src: Opaque<"buffer">, srcoffset: number, count: number): void;
@@ -77,13 +82,16 @@ declare global {
      * @example
      * ```ts
      * // How to update a texture of a sprite:
+     * const srcbuffer = resource.get_buffer("/src.bufferc");
+     * const dstbuffer = resource.get_buffer("/dst.bufferc");
+     *
      * // 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
@@ -103,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.
      *
@@ -128,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.
      *
@@ -137,12 +148,14 @@ declare global {
      * @example
      * ```ts
      * // How to get a metadata entry from a buffer
+     * const buf = resource.get_buffer("/my.bufferc");
+     *
      * // retrieve a metadata entry named "somefloats" and its numeric type
      * const [values, type] = buffer.get_metadata(buf, hash("somefloats"));
      * if (values) print(`${values.length} values in 'somefloats'`);
      * ```
      */
-    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, number & { readonly __brand: "buffer.VALUE_TYPE_FLOAT32" } | number & { readonly __brand: "buffer.VALUE_TYPE_INT16" } | number & { readonly __brand: "buffer.VALUE_TYPE_INT32" } | number & { readonly __brand: "buffer.VALUE_TYPE_INT64" } | number & { readonly __brand: "buffer.VALUE_TYPE_INT8" } | number & { readonly __brand: "buffer.VALUE_TYPE_UINT16" } | number & { readonly __brand: "buffer.VALUE_TYPE_UINT32" } | number & { readonly __brand: "buffer.VALUE_TYPE_UINT64" } | number & { readonly __brand: "buffer.VALUE_TYPE_UINT8" } | undefined]>;
+    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, buffer.ValueType | undefined]>;
     /**
      * Get a specified stream from a buffer.
      *
@@ -150,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.
@@ -162,6 +175,8 @@ declare global {
      * @example
      * ```ts
      * // How to set a metadata entry on a buffer
+     * const buf = resource.get_buffer("/my.bufferc");
+     *
      * // create a new metadata entry with three floats
      * buffer.set_metadata(buf, hash("somefloats"), [1.5, 3.2, 7.9], buffer.VALUE_TYPE_FLOAT32);
      * // ...
@@ -169,7 +184,7 @@ declare global {
      * buffer.set_metadata(buf, hash("somefloats"), [-2.5, 10.0, 32.2], buffer.VALUE_TYPE_FLOAT32);
      * ```
      */
-    function set_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string, values: number[], value_type: number & { readonly __brand: "buffer.VALUE_TYPE_FLOAT32" } | number & { readonly __brand: "buffer.VALUE_TYPE_INT16" } | number & { readonly __brand: "buffer.VALUE_TYPE_INT32" } | number & { readonly __brand: "buffer.VALUE_TYPE_INT64" } | number & { readonly __brand: "buffer.VALUE_TYPE_INT8" } | number & { readonly __brand: "buffer.VALUE_TYPE_UINT16" } | number & { readonly __brand: "buffer.VALUE_TYPE_UINT32" } | number & { readonly __brand: "buffer.VALUE_TYPE_UINT64" } | number & { readonly __brand: "buffer.VALUE_TYPE_UINT8" }): void;
+    function set_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string, values: number[], value_type: buffer.ValueType): void;
   }
 }
 

package/generated/versions/defold-1.12.4/camera.d.ts

@@ -45,6 +45,7 @@ declare global {
      * @returns a table with all camera URLs
      * @example
      * ```ts
+     * const predicate = render.predicate([hash("my_tag")]);
      * for (const camera_id of camera.get_cameras()) {
      *   render.set_camera(camera_id);
      *   render.draw(predicate);
@@ -125,7 +126,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,
@@ -157,7 +158,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");
      *       }