@defold-typescript/types 0.51.0 → 0.52.0

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

@@ -183,7 +183,40 @@ declare global {
      * }
      * ```
      */
-    function get_config_int(key: string, default_value?: number): number;
+    function get_config_int(key: string): number;
+    /**
+     * Get integer config value from the game.project configuration file with optional default value
+     *
+     * @param key - key to get value for. The syntax is SECTION.KEY
+     * @param default_value - (optional) default value to return if the value does not exist
+     * @returns config value as an integer. default_value if the config key does not exist. 0 if no default value was supplied.
+     * @example
+     * Get user config value
+     * ```ts
+     * const speed = sys.get_config_int("my_game.speed", 20); // with default value
+     * ```
+     * @example
+     * ```ts
+     * const testmode = sys.get_config_int("my_game.testmode"); // without default value
+     * if (testmode !== undefined) {
+     *   // do stuff
+     * }
+     * ```
+     */
+    function get_config_int(key: string, default_value: number): number;
+    /**
+     * Get number config value from the game.project configuration file with optional default value
+     *
+     * @param key - key to get value for. The syntax is SECTION.KEY
+     * @param default_value - (optional) default value to return if the value does not exist
+     * @returns config value as an number. default_value if the config key does not exist. 0 if no default value was supplied.
+     * @example
+     * ```ts
+     * // Get user config value
+     * const speed = sys.get_config_number("my_game.speed", 20.0);
+     * ```
+     */
+    function get_config_number(key: string): number;
     /**
      * Get number config value from the game.project configuration file with optional default value
      *
@@ -196,7 +229,7 @@ declare global {
      * const speed = sys.get_config_number("my_game.speed", 20.0);
      * ```
      */
-    function get_config_number(key: string, default_value?: number): number;
+    function get_config_number(key: string, default_value: number): number;
     /**
      * Returns the current network connectivity status
      * on mobile platforms.
@@ -355,7 +388,46 @@ declare global {
      * }
      * ```
      */
-    function get_sys_info(options?: { ignore_secure?: boolean }): { device_model: string; manufacturer: string; system_name: string; system_version: string; api_version: string; language: string; device_language: string; territory: string; gmt_offset: number; device_ident: string; user_agent: string };
+    function get_sys_info(): { device_model: string; manufacturer: string; system_name: string; system_version: string; api_version: string; language: string; device_language: string; territory: string; gmt_offset: number; device_ident: string; user_agent: string };
+    /**
+     * Returns a table with system information.
+     *
+     * @param options - optional options table
+     * - ignore_secure boolean this flag ignores values might be secured by OS e.g. `device_ident`
+     * @returns table with system information in the following fields:
+     *
+     * `device_model`
+     * string Only available on iOS and Android.
+     * `manufacturer`
+     * string Only available on iOS and Android.
+     * `system_name`
+     * string The system name: "Darwin", "Linux", "Windows", "HTML5", "Android" or "iPhone OS"
+     * `system_version`
+     * string The system OS version.
+     * `api_version`
+     * string The API version on the system.
+     * `language`
+     * string Two character ISO-639 format, i.e. "en".
+     * `device_language`
+     * string Two character ISO-639 format (i.e. "sr") and, if applicable, followed by a dash (-) and an ISO 15924 script code (i.e. "sr-Cyrl" or "sr-Latn"). Reflects the device preferred language.
+     * `territory`
+     * string Two character ISO-3166 format, i.e. "US".
+     * `gmt_offset`
+     * number The current offset from GMT (Greenwich Mean Time), in minutes.
+     * `device_ident`
+     * string This value secured by OS. "identifierForVendor" on iOS. "android_id" on Android. On Android, you need to add `READ_PHONE_STATE` permission to be able to get this data. We don't use this permission in Defold.
+     * `user_agent`
+     * string The HTTP user agent, i.e. "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/602.4.8 (KHTML, like Gecko) Version/10.0.3 Safari/602.4.8"
+     * @example
+     * ```ts
+     * // How to get system information:
+     * const info = sys.get_sys_info();
+     * if (info.system_name === "HTML5") {
+     *   // We are running in a browser.
+     * }
+     * ```
+     */
+    function get_sys_info(options: { ignore_secure?: boolean }): { device_model: string; manufacturer: string; system_name: string; system_version: string; api_version: string; language: string; device_language: string; territory: string; gmt_offset: number; device_ident: string; user_agent: string };
     /**
      * If the file exists, it must have been created by `sys.save` to be loaded.
      * This function will raise a Lua error if an error occurs while loading the file.
@@ -401,7 +473,7 @@ declare global {
      * const asset_2 = sys.load_buffer("/my/absolute/path");
      * ```
      */
-    function load_buffer(path: string): Opaque<"buffer">;
+    function load_buffer(path: string): Opaque<"buffer"> & { length: LuaLengthMethod<number> };
     /**
      * The sys.load_buffer function will first try to load the resource
      * from any of the mounted resource locations and return the data if
@@ -434,7 +506,7 @@ declare global {
      * Load binary data from a custom project resource and update a texture resource:
      * ```ts
      * function my_callback(self: unknown, request_id: unknown, result: unknown) {
-     *   const { status, buf } = result as { status: number; buf: Opaque<"buffer"> };
+     *   const { status, buf } = result as { status: number; buf: ReturnType<typeof sys.load_buffer> };
      *   if (status === sys.REQUEST_STATUS_FINISHED) {
      *     resource.set_texture("/my_texture", { type: graphics.TEXTURE_TYPE_2D, width: 128, height: 128, format: graphics.TEXTURE_FORMAT_RGBA }, buf);
      *   }
@@ -519,7 +591,30 @@ declare global {
      * }
      * ```
      */
-    function open_url(url: string, attributes?: { target?: string }): boolean;
+    function open_url(url: string): boolean;
+    /**
+     * Open URL in default application, typically a browser
+     *
+     * @param url - url to open
+     * @param attributes - table with attributes
+     * `target`
+     * - string : Optional. Specifies the target attribute or the name of the window. The following values are supported:
+     * - `_self` - (default value) URL replaces the current page.
+     * - `_blank` - URL is loaded into a new window, or tab.
+     * - `_parent` - URL is loaded into the parent frame.
+     * - `_top` - URL replaces any framesets that may be loaded.
+     * - `name` - The name of the window (Note: the name does not specify the title of the new window).
+     * @returns a boolean indicating if the url could be opened or not
+     * @example
+     * ```ts
+     * // Open an URL:
+     * const success = sys.open_url("http://www.defold.com", { target: "_blank" });
+     * if (!success) {
+     *   // could not open the url...
+     * }
+     * ```
+     */
+    function open_url(url: string, attributes: { target?: string }): boolean;
     /**
      * Reboots the game engine with a specified set of arguments.
      * Arguments will be translated into command line arguments. Calling reboot

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

@@ -68,30 +68,6 @@ 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.
-     *
-     * - If the dot product is positive then the angle between the vectors is below 90 degrees.
-     * - If the dot product is zero the vectors are perpendicular (at right-angles to each other).
-     * - If the dot product is negative then the angle between the vectors is more than 90 degrees.
-     *
-     * @param v1 - first vector
-     * @param v2 - second vector
-     * @returns dot product
-     * @example
-     * ```ts
-     * const vector1 = vmath.vector3(1, 0, 0);
-     * const vector2 = vmath.vector3(0, 1, 0);
-     *
-     * if (vmath.dot(vector1, vector2) === 0) {
-     *   // The two vectors are perpendicular (at right-angles to each other)
-     *   // ...
-     * }
-     * ```
-     */
-    function dot(v1: Vector3 | Vector4, v2: Vector3 | Vector4): number;
     /**
      * The resulting matrix is the inverse of the supplied matrix.
      * For ortho-normal matrices, e.g. regular object transformation,

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

@@ -26,7 +26,7 @@ declare global {
      * @param filter - optional query filter
      * @param max_results - optional maximum result count
      */
-    function cast_ray(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_cast_hit[], b2d.tree_stats]>;
+    function cast_ray<Backend extends "v2" = "v2">(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_cast_hit[], b2d.tree_stats]>;
     /**
      * The translation is the ray displacement from `origin`. Result order is not
      * guaranteed by Box2D.
@@ -37,7 +37,7 @@ declare global {
      * @param filter - optional query filter
      * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
      */
-    function cast_ray(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_cast_hit[], b2d.tree_stats]>;
+    function cast_ray<Backend extends "v3">(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_cast_hit[], b2d.tree_stats]>;
     /**
      * Cast a ray and return the closest hit.
      *
@@ -47,7 +47,7 @@ declare global {
      * @param filter - optional query filter
      * @returns closest hit, or `nil`
      */
-    function cast_ray_closest(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter): b2d.fixture_cast_hit | undefined;
+    function cast_ray_closest<Backend extends "v2" = "v2">(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter): b2d.fixture_cast_hit | undefined;
     /**
      * The translation is the ray displacement from `origin`.
      *
@@ -57,7 +57,7 @@ declare global {
      * @param filter - optional query filter
      * @returns closest hit, or `nil`
      */
-    function cast_ray_closest(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter): b2d.shape_cast_hit | undefined;
+    function cast_ray_closest<Backend extends "v3">(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter): b2d.shape_cast_hit | undefined;
     /**
      * Uses Box2D v2 time-of-impact for fixture child shapes that support distance proxies.
      * Grid fixture children are skipped.
@@ -68,7 +68,7 @@ declare global {
      * @param filter - optional query filter
      * @param max_results - optional maximum result count
      */
-    function cast_shape(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_cast_hit[], b2d.tree_stats]>;
+    function cast_shape<Backend extends "v2" = "v2">(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_cast_hit[], b2d.tree_stats]>;
     /**
      * The translation is the shape displacement.
      *
@@ -78,7 +78,7 @@ declare global {
      * @param filter - optional query filter
      * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
      */
-    function cast_shape(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_cast_hit[], b2d.tree_stats]>;
+    function cast_shape<Backend extends "v3">(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_cast_hit[], b2d.tree_stats]>;
     /**
      * Collide a mover capsule against the world.
      *
@@ -220,7 +220,7 @@ declare global {
      * - `fixtures` — overlapping fixtures. **⚠️ `index` is 1-based; passed to Defold unchanged.**
      * - `stats` — broad-phase query statistics
      */
-    function overlap_aabb(world: Opaque<"b2World">, aabb: b2d.aabb, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_info[], b2d.tree_stats]>;
+    function overlap_aabb<Backend extends "v2" = "v2">(world: Opaque<"b2World">, aabb: b2d.aabb, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_info[], b2d.tree_stats]>;
     /**
      * Find shapes overlapping an AABB.
      *
@@ -229,7 +229,7 @@ declare global {
      * @param filter - optional query filter
      * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
      */
-    function overlap_aabb(world: Opaque<"b2World">, aabb: b2d.aabb, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_info[], b2d.tree_stats]>;
+    function overlap_aabb<Backend extends "v3">(world: Opaque<"b2World">, aabb: b2d.aabb, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_info[], b2d.tree_stats]>;
     /**
      * Overlap a shape.
      *
@@ -241,7 +241,7 @@ declare global {
      * - `fixtures` — overlapping fixtures. **⚠️ `index` is 1-based; passed to Defold unchanged.**
      * - `stats` — broad-phase query statistics
      */
-    function overlap_shape(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_info[], b2d.tree_stats]>;
+    function overlap_shape<Backend extends "v2" = "v2">(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_info[], b2d.tree_stats]>;
     /**
      * Find shapes overlapping a shape proxy.
      *
@@ -250,7 +250,7 @@ declare global {
      * @param filter - optional query filter
      * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
      */
-    function overlap_shape(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_info[], b2d.tree_stats]>;
+    function overlap_shape<Backend extends "v3">(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_info[], b2d.tree_stats]>;
     /**
      * Rebuild the static broad-phase tree.
      *

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

@@ -6,7 +6,7 @@ declare global {
    * Functions for manipulating buffers and streams
    */
   namespace buffer {
-    type buffer_data = Opaque<"buffer">;
+    type buffer_data = Opaque<"buffer"> & { length: LuaLengthMethod<number> };
     type buffer_stream = Opaque<"bufferstream"> & { [index: number]: number; length: LuaLengthMethod<number> };
     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;
     type VALUE_TYPE = 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;
@@ -71,7 +71,7 @@ declare global {
      * 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;
+    function copy_buffer(dst: Opaque<"buffer"> & { length: LuaLengthMethod<number> }, dstoffset: number, src: Opaque<"buffer"> & { length: LuaLengthMethod<number> }, srcoffset: number, count: number): void;
     /**
      * Copy a specified amount of data from one stream to another.
      * The value type and size must match between source and destination streams.
@@ -132,15 +132,15 @@ declare global {
      * });
      * ```
      */
-    function create(element_count: number, declaration: ({ name: Hash | string; type: buffer.VALUE_TYPE; count: number })[]): Opaque<"buffer">;
+    function create(element_count: number, declaration: [({ name: Hash | string; type: buffer.VALUE_TYPE; count: number }), ...({ name: Hash | string; type: buffer.VALUE_TYPE; count: number })[]]): Opaque<"buffer"> & { length: LuaLengthMethod<number> };
     /**
-     * Get a copy of all the bytes from a specified stream as a Lua string.
+     * Get a copy of all the bytes of the buffer, every stream included, as a Lua string.
      *
      * @param buffer - the source buffer
-     * @param stream_name - the name of the stream
+     * @param stream_name - the name of the stream; the engine ignores it and returns every byte of the buffer
      * @returns the buffer data as a Lua string
      */
-    function get_bytes(buffer: Opaque<"buffer">, stream_name: Hash | string): string;
+    function get_bytes(buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> }, stream_name?: Hash | string): string;
     /**
      * Get a named metadata entry from a buffer along with its type.
      *
@@ -156,7 +156,7 @@ declare global {
      * if (values) print(`${values.length} values in 'somefloats'`);
      * ```
      */
-    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, buffer.VALUE_TYPE | undefined]>;
+    function get_metadata(buf: Opaque<"buffer"> & { length: LuaLengthMethod<number> }, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, buffer.VALUE_TYPE | undefined]>;
     /**
      * Get a specified stream from a buffer.
      *
@@ -164,7 +164,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; length: LuaLengthMethod<number> };
+    function get_stream(buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> }, 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.
@@ -185,7 +185,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: buffer.VALUE_TYPE): void;
+    function set_metadata(buf: Opaque<"buffer"> & { length: LuaLengthMethod<number> }, metadata_name: Hash | string, values: [number, ...number[]], value_type: Exclude<buffer.VALUE_TYPE, typeof buffer.VALUE_TYPE_INT64 | typeof buffer.VALUE_TYPE_UINT64>): void;
   }
 }
 

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

@@ -298,7 +298,7 @@ declare global {
      * @param object - collision object
      * @returns rigid body state
      */
-    function is_rigid_body(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    function is_rigid_body(object: Opaque<"btCollisionObject" | "btRigidBody">): object is Opaque<"btRigidBody">;
     /**
      * Test whether the object is static
      *

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

@@ -246,7 +246,16 @@ declare global {
      * @param params - local frames and options
      * @returns cone-twist constraint
      */
-    function create_cone_twist(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.cone_twist_params): bullet3d.constraint.btTypedConstraint;
+    function create_cone_twist(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.cone_twist_params & Required<Pick<bullet3d.constraint.cone_twist_params, "frame_b_position" | "frame_b_rotation">>): bullet3d.constraint.btTypedConstraint;
+    /**
+     * The world is derived from `body_a`.
+     *
+     * @param body_a - first body
+     * @param body_b - second body or world
+     * @param params - local frames and options
+     * @returns cone-twist constraint
+     */
+    function create_cone_twist(body_a: Opaque<"btRigidBody">, body_b: undefined, params: bullet3d.constraint.cone_twist_params): bullet3d.constraint.btTypedConstraint;
     /**
      * The params table requires local frame A and, for a two-body constraint,
      * local frame B. It optionally accepts `collide_connected`. The world is
@@ -259,7 +268,20 @@ declare global {
      * @param params - local frames and options
      * @returns generic 6-DOF constraint
      */
-    function create_generic_6dof(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.generic_6dof_params): bullet3d.constraint.btTypedConstraint;
+    function create_generic_6dof(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.generic_6dof_params & Required<Pick<bullet3d.constraint.generic_6dof_params, "frame_b_position" | "frame_b_rotation">>): bullet3d.constraint.btTypedConstraint;
+    /**
+     * The params table requires local frame A and, for a two-body constraint,
+     * local frame B. It optionally accepts `collide_connected`. The world is
+     * derived from `body_a`. The active 6-DOF solver ignores its legacy
+     * linear-reference-frame selector, so that field is rejected rather than
+     * silently accepted.
+     *
+     * @param body_a - first body
+     * @param body_b - second body or world
+     * @param params - local frames and options
+     * @returns generic 6-DOF constraint
+     */
+    function create_generic_6dof(body_a: Opaque<"btRigidBody">, body_b: undefined, params: bullet3d.constraint.generic_6dof_params): bullet3d.constraint.btTypedConstraint;
     /**
      * Both bodies and both local frames are required. The params table optionally
      * accepts `collide_connected`. The world is derived from `body_a`. The active
@@ -339,7 +361,44 @@ declare global {
      * });
      * ```
      */
-    function create_hinge(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.hinge_params): bullet3d.constraint.btTypedConstraint;
+    function create_hinge(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.hinge_params & Required<Pick<bullet3d.constraint.hinge_params, "frame_b_position" | "frame_b_rotation">>): bullet3d.constraint.btTypedConstraint;
+    /**
+     * The world is derived from `body_a`.
+     *
+     * @param body_a - first body
+     * @param body_b - second body or world
+     * @param params - local frames and options
+     * @returns hinge constraint
+     * @example
+     * ```ts
+     * // Create a motorized hinge with a 90-degree range:
+     * export default defineScript({
+     *   init() {
+     *     const body_a = bullet3d.get_rigid_body("/door#collisionobject");
+     *     const body_b = bullet3d.get_rigid_body("/frame#collisionobject");
+     *     let hinge: bullet3d.constraint.btTypedConstraint | undefined;
+     *     if (body_a !== undefined) {
+     *       hinge = bullet3d.constraint.create_hinge(body_a, body_b, {
+     *         frame_a_position: vmath.vector3(-0.5, 0, 0),
+     *         frame_a_rotation: vmath.quat(),
+     *         frame_b_position: vmath.vector3(0.5, 0, 0),
+     *         frame_b_rotation: vmath.quat(),
+     *       });
+     *       bullet3d.constraint.set_hinge_limits(hinge, -math.pi / 4, math.pi / 4);
+     *       bullet3d.constraint.set_hinge_motor(hinge, true, 1.5, 2.5);
+     *     }
+     *     return { hinge };
+     *   },
+     *
+     *   final(self) {
+     *     if (self.hinge !== undefined && bullet3d.constraint.is_valid(self.hinge)) {
+     *       bullet3d.constraint.destroy(self.hinge);
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function create_hinge(body_a: Opaque<"btRigidBody">, body_b: undefined, params: bullet3d.constraint.hinge_params): bullet3d.constraint.btTypedConstraint;
     /**
      * Both bodies are required. Its initial linear suspension travel is one Defold
      * unit in either direction. The world is derived from `body_a`.
@@ -383,7 +442,50 @@ declare global {
      * });
      * ```
      */
-    function create_point_to_point(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.point_to_point_params): bullet3d.constraint.btTypedConstraint;
+    function create_point_to_point(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.point_to_point_params & Required<Pick<bullet3d.constraint.point_to_point_params, "pivot_b">>): bullet3d.constraint.btTypedConstraint;
+    /**
+     * The world is derived from `body_a`; both bodies must belong to that same world.
+     *
+     * @param body_a - first body
+     * @param body_b - second body or world
+     * @param params - pivots and options
+     * @returns point-to-point constraint
+     * @example
+     * ```ts
+     * // Join two bodies at matching local pivots and explicitly destroy the
+     * // constraint when the script is finalized:
+     * export default defineScript({
+     *   init() {
+     *     const body_a = bullet3d.get_rigid_body("/body_a#collisionobject");
+     *     const body_b = bullet3d.get_rigid_body("/body_b#collisionobject");
+     *     let constraint: bullet3d.constraint.btTypedConstraint | undefined;
+     *     if (body_a !== undefined) {
+     *       constraint = bullet3d.constraint.create_point_to_point(body_a, body_b, {
+     *         pivot_a: vmath.vector3(0.5, 0, 0),
+     *         pivot_b: vmath.vector3(-0.5, 0, 0),
+     *       });
+     *     }
+     *     return { constraint };
+     *   },
+     *
+     *   final(self) {
+     *     if (self.constraint !== undefined && bullet3d.constraint.is_valid(self.constraint)) {
+     *       bullet3d.constraint.destroy(self.constraint);
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function create_point_to_point(body_a: Opaque<"btRigidBody">, body_b: undefined, params: bullet3d.constraint.point_to_point_params): bullet3d.constraint.btTypedConstraint;
+    /**
+     * The world is derived from `body_a`.
+     *
+     * @param body_a - first body
+     * @param body_b - second body or world
+     * @param params - local frames and options
+     * @returns slider constraint
+     */
+    function create_slider(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.slider_params & Required<Pick<bullet3d.constraint.slider_params, "frame_b_position" | "frame_b_rotation">>): bullet3d.constraint.btTypedConstraint;
     /**
      * The world is derived from `body_a`.
      *
@@ -392,7 +494,7 @@ declare global {
      * @param params - local frames and options
      * @returns slider constraint
      */
-    function create_slider(body_a: Opaque<"btRigidBody">, body_b: Opaque<"btRigidBody"> | undefined, params: bullet3d.constraint.slider_params): bullet3d.constraint.btTypedConstraint;
+    function create_slider(body_a: Opaque<"btRigidBody">, body_b: undefined, params: bullet3d.constraint.slider_params): bullet3d.constraint.btTypedConstraint;
     /**
      * Both bodies are required. The world is derived from `body_a`.
      *
@@ -567,7 +669,7 @@ declare global {
      * @param constraint - slider constraint
      * @param motor - `linear` or `angular`
      */
-    function get_slider_motor(constraint: bullet3d.constraint.btTypedConstraint, motor: string): LuaMultiReturn<[boolean, number, number]>;
+    function get_slider_motor(constraint: bullet3d.constraint.btTypedConstraint, motor: "linear" | "angular"): LuaMultiReturn<[boolean, number, number]>;
     /**
      * Get the current slider position
      *
@@ -781,7 +883,7 @@ declare global {
      * @param target_velocity - linear or angular target velocity
      * @param max_force - non-negative maximum linear force or angular torque
      */
-    function set_slider_motor(constraint: bullet3d.constraint.btTypedConstraint, motor: string, enabled: boolean, target_velocity: number, max_force: number): void;
+    function set_slider_motor(constraint: bullet3d.constraint.btTypedConstraint, motor: "linear" | "angular", enabled: boolean, target_velocity: number, max_force: number): void;
     /**
      * Generic spring 6-DOF constraints use a scale-independent damping factor from
      * 0 to 1, where 1 means no damping. Hinge2 constraints use a damping coefficient

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

@@ -11,7 +11,7 @@ declare global {
    */
   namespace bullet3d.shape {
     type btCollisionShape = Opaque<"btCollisionShape">;
-    type definition = { type: bullet3d.shape.SHAPE_TYPE; diameter: number; position?: Vector3; rotation?: Quaternion; target_rotation?: Quaternion } | { type: bullet3d.shape.SHAPE_TYPE; dimensions: Vector3; position?: Vector3; rotation?: Quaternion; target_rotation?: Quaternion } | { type: bullet3d.shape.SHAPE_TYPE; diameter: number; height: number; position?: Vector3; rotation?: Quaternion; target_rotation?: Quaternion } | { type: bullet3d.shape.SHAPE_TYPE; vertices: Vector3[]; position?: Vector3; rotation?: Quaternion; target_rotation?: Quaternion };
+    type definition = { type: typeof bullet3d.shape.SHAPE_TYPE_SPHERE; diameter: number; position?: Vector3; rotation?: Quaternion; target_rotation?: Quaternion } | { type: typeof bullet3d.shape.SHAPE_TYPE_BOX; dimensions: Vector3; position?: Vector3; rotation?: Quaternion; target_rotation?: Quaternion } | { type: typeof bullet3d.shape.SHAPE_TYPE_CAPSULE; diameter: number; height: number; position?: Vector3; rotation?: Quaternion; target_rotation?: Quaternion } | { type: typeof bullet3d.shape.SHAPE_TYPE_HULL; vertices: Vector3[]; position?: Vector3; rotation?: Quaternion; target_rotation?: Quaternion };
     type SHAPE_TYPE = typeof bullet3d.shape.SHAPE_TYPE_BOX | typeof bullet3d.shape.SHAPE_TYPE_CAPSULE | typeof bullet3d.shape.SHAPE_TYPE_HULL | typeof bullet3d.shape.SHAPE_TYPE_MESH | typeof bullet3d.shape.SHAPE_TYPE_SPHERE;
     /**
      * Box shape type Value `1`. Shape data contains positive vector3 `dimensions` in Defold units.
@@ -66,7 +66,7 @@ declare global {
      * @param shape - shape handle
      * @returns typed shape geometry in Defold units
      */
-    function get_shape(shape: bullet3d.shape.btCollisionShape): bullet3d.shape.definition;
+    function get_shape(shape: bullet3d.shape.btCollisionShape): bullet3d.shape.definition | { type: typeof bullet3d.shape.SHAPE_TYPE_MESH };
     /**
      * Get the normalized Defold shape type.
      *