@defold-typescript/types 0.19.4 → 0.20.1

package/generated/b2d_shape.d.ts

@@ -0,0 +1,215 @@
+/** @noSelfInFile */
+import type { Opaque, Vector3 } from "../src/core-types";
+
+declare global {
+  /**
+   * Constants for functional shape tables used with `b2d.body.create_fixture`
+   * and returned from `b2d.fixture.get_shape`.
+   */
+  namespace b2d.shape {
+    type b2Shape = Opaque<"b2Shape">;
+    /**
+     * Uses the polygon enum value, but indicates the `hx`/`hy` box convenience format.
+     */
+    const SHAPE_TYPE_BOX: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_BOX" };
+    /**
+     * Capsule shape type.
+     */
+    const SHAPE_TYPE_CAPSULE: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_CAPSULE" };
+    /**
+     * Chain shape type.
+     */
+    const SHAPE_TYPE_CHAIN: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_CHAIN" };
+    /**
+     * Circle shape type.
+     */
+    const SHAPE_TYPE_CIRCLE: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_CIRCLE" };
+    /**
+     * Edge shape type.
+     */
+    const SHAPE_TYPE_EDGE: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_EDGE" };
+    /**
+     * Grid shape type.
+     */
+    const SHAPE_TYPE_GRID: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_GRID" };
+    /**
+     * Polygon shape type.
+     */
+    const SHAPE_TYPE_POLYGON: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_POLYGON" };
+    /**
+     * Segment shape type.
+     */
+    const SHAPE_TYPE_SEGMENT: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_SEGMENT" };
+    /**
+     * Check if contact events are enabled for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns true if contact events are enabled
+     */
+    function are_contact_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Check if hit events are enabled for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns true if hit events are enabled
+     */
+    function are_hit_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Check if pre-solve events are enabled for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns true if pre-solve events are enabled
+     */
+    function are_pre_solve_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Check if sensor events are enabled for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns true if sensor events are enabled
+     */
+    function are_sensor_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Enable or disable contact events for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @param enable - true to enable contact events
+     */
+    function enable_contact_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    /**
+     * Enable or disable hit events for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @param enable - true to enable hit events
+     */
+    function enable_hit_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    /**
+     * Enable or disable pre-solve events for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @param enable - true to enable pre-solve events
+     */
+    function enable_pre_solve_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    /**
+     * Enable or disable sensor events for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @param enable - true to enable sensor events
+     */
+    function enable_sensor_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    /**
+     * Get the body owning a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns owning body
+     */
+    function get_body(shape_id: Opaque<"b2Shape">): Opaque<"b2Body">;
+    /**
+     * Get the closest point on a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @param target - world target point
+     * @returns closest world point on the shape
+     */
+    function get_closest_point(shape_id: Opaque<"b2Shape">, target: Vector3): Vector3;
+    /**
+     * Get shape contact capacity.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns maximum contact data count
+     */
+    function get_contact_capacity(shape_id: Opaque<"b2Shape">): number;
+    /**
+     * Get touching contact data for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns array of contact tables
+     */
+    function get_contact_data(shape_id: Opaque<"b2Shape">): Record<string | number, unknown>;
+    /**
+     * Get mass data for a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns table with `mass`, `center`, and `inertia`
+     */
+    function get_mass_data(shape_id: Opaque<"b2Shape">): { mass: number; center: Vector3; inertia: number };
+    /**
+     * Get shape material id.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns shape material id
+     */
+    function get_material(shape_id: Opaque<"b2Shape">): number;
+    /**
+     * Get sensor overlap capacity.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns maximum sensor overlap count
+     */
+    function get_sensor_capacity(shape_id: Opaque<"b2Shape">): number;
+    /**
+     * Get sensor overlaps.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns array of shape info tables
+     */
+    function get_sensor_overlaps(shape_id: Opaque<"b2Shape">): { shape_id: number }[];
+    /**
+     * Get a shape's geometry.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns shape table with numeric `type` from `b2d.shape.SHAPE_TYPE_*`
+     */
+    function get_shape(shape_id: Opaque<"b2Shape">): { type: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 };
+    /**
+     * Get the world owning a shape.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns owning world
+     */
+    function get_world(shape_id: Opaque<"b2Shape">): Opaque<"b2World">;
+    /**
+     * Validate a shape handle.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns true if the shape handle still refers to a live Box2D shape
+     */
+    function is_valid(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Ray cast a shape directly.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @param origin - world ray origin
+     * @param translation - world ray translation
+     * @param max_fraction - optional maximum translation fraction, defaults to 1
+     * @returns hit table with `point`, `normal`, `fraction`, and `iterations`, or nil
+     */
+    function ray_cast(shape_id: Opaque<"b2Shape">, origin: Vector3, translation: Vector3, max_fraction: number): { point: Vector3; normal: Vector3; fraction: number; iterations: number };
+    /**
+     * Set shape material id.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @param material - shape material id
+     */
+    function set_material(shape_id: Opaque<"b2Shape">, material: number): void;
+    /**
+     * This updates the shape geometry using the same table format as
+     * `b2d.body.create_shape` and `b2d.shape.get_shape`. The body mass is not
+     * updated unless `update_mass` is true.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @param definition - shape table with numeric `type` from `b2d.shape.SHAPE_TYPE_*`
+     * @param update_mass - true to reset body mass from shapes
+     * @example
+     * ```ts
+     * const body = b2d.get_body("#collisionobject");
+     * const circle = b2d.shape.get_shape(body, 1);
+     * circle.center = vmath.vector3(24, 0, 0);
+     * b2d.shape.set_shape(body, 1, circle, true);
+     * b2d.shape.set_shape(body, 2, { type: b2d.shape.SHAPE_TYPE_SEGMENT, v1: vmath.vector3(-32, 0, 0), v2: vmath.vector3(32, 0, 0) });
+     * ```
+     */
+    function set_shape(shape_id: Opaque<"b2Shape">, definition: { type?: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, update_mass: boolean): void;
+  }
+}
+
+export {};

package/generated/b2d_world.d.ts

@@ -0,0 +1,314 @@
+/** @noSelfInFile */
+import type { Opaque, Vector3 } from "../src/core-types";
+
+declare global {
+  /**
+   * Query and cast functions for the Defold-owned Box2D v2 world.
+   */
+  namespace b2d.world {
+    /**
+     * The capsule table has `center1`, `center2`, and `radius` fields. The return
+     * value is the fraction of `translation` that can be traveled before collision,
+     * or 1 if there is no hit.
+     *
+     * @param world - world
+     * @param capsule - capsule table with `center1`, `center2`, and `radius`
+     * @param translation - capsule displacement
+     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @returns travel fraction before collision
+     */
+    function cast_mover(world: Opaque<"b2World">, capsule: { center1?: Vector3; center2?: Vector3; radius?: number }, translation: Vector3, filter?: { category_bits?: number; mask_bits?: number }): number;
+    /**
+     * Cast a ray.
+     *
+     * @param world - world from `b2d.get_world` or `b2d.body.get_world`
+     * @param origin - world ray origin
+     * @param translation - world ray translation
+     * @param filter - optional query filter with `category_bits`, `mask_bits`, and optional `group_index`
+     * @param max_results - optional maximum result count
+     */
+    function cast_ray(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter: { category_bits?: number; mask_bits?: number; group_index?: number }, max_results: number): LuaMultiReturn<[{ fixture: number; shape: number; point: Vector3; normal: Vector3; fraction: number }[], { node_visits: number; leaf_visits: number }]>;
+    /**
+     * The translation is the ray displacement from `origin`. Result order is not
+     * guaranteed by Box2D.
+     *
+     * @param world - world
+     * @param origin - ray start position
+     * @param translation - ray displacement
+     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @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?: { category_bits?: number; mask_bits?: number; group_index?: number }, max_results?: number): LuaMultiReturn<[{ fixture: number; shape: number; point: Vector3; normal: Vector3; fraction: number }[], { node_visits: number; leaf_visits: number }]>;
+    /**
+     * Cast a ray and return the closest hit.
+     *
+     * @param world - world from `b2d.get_world` or `b2d.body.get_world`
+     * @param origin - world ray origin
+     * @param translation - world ray translation
+     * @param filter - optional query filter with `category_bits`, `mask_bits`, and optional `group_index`
+     * @returns hit table with `fixture`, `shape`, `point`, `normal`, `fraction`, `node_visits`, and `leaf_visits`, or nil
+     */
+    function cast_ray_closest(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter: { category_bits?: number; mask_bits?: number; group_index?: number }): { fixture: number; shape: number; point: Vector3; normal: Vector3; fraction: number; node_visits: number; leaf_visits: number };
+    /**
+     * The translation is the ray displacement from `origin`.
+     *
+     * @param world - world
+     * @param origin - ray start position
+     * @param translation - ray displacement
+     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @returns closest cast hit table with `node_visits` and `leaf_visits`, or `nil` on miss
+     */
+    function cast_ray_closest(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: { category_bits?: number; mask_bits?: number; group_index?: number }): { fixture: number; shape: number; point: Vector3; normal: Vector3; fraction: number; node_visits: number; leaf_visits: number } | undefined;
+    /**
+     * Uses Box2D v2 time-of-impact for fixture child shapes that support distance proxies.
+     * Grid fixture children are skipped.
+     *
+     * @param world - world from `b2d.get_world` or `b2d.body.get_world`
+     * @param shape - shape table using the same format as the `shape` field in `b2d.body.create_fixture`
+     * @param translation - world shape translation
+     * @param filter - optional query filter with `category_bits`, `mask_bits`, and optional `group_index`
+     * @param max_results - optional maximum result count
+     */
+    function cast_shape(world: Opaque<"b2World">, shape: { type?: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, translation: Vector3, filter: { category_bits?: number; mask_bits?: number; group_index?: number }, max_results: number): LuaMultiReturn<[{ fixture: number; shape: number; point: Vector3; normal: Vector3; fraction: number }[], { node_visits: number; leaf_visits: number }]>;
+    /**
+     * The shape table uses the same circle, capsule, segment, polygon, and box formats
+     * as `b2d.body.create_shape`. The translation is the shape displacement.
+     *
+     * @param world - world
+     * @param shape - shape table
+     * @param translation - shape displacement
+     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
+     */
+    function cast_shape(world: Opaque<"b2World">, shape: { type?: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, translation: Vector3, filter?: { category_bits?: number; mask_bits?: number; group_index?: number }, max_results?: number): LuaMultiReturn<[{ fixture: number; shape: number; point: Vector3; normal: Vector3; fraction: number }[], { node_visits: number; leaf_visits: number }]>;
+    /**
+     * The capsule table has `center1`, `center2`, and `radius` fields. Plane result
+     * tables include `shape`, `normal`, `offset`, and `hit`.
+     *
+     * @param world - world
+     * @param capsule - capsule table with `center1`, `center2`, and `radius`
+     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
+     * @returns array of plane result tables
+     */
+    function collide_mover(world: Opaque<"b2World">, capsule: { center1?: Vector3; center2?: Vector3; radius?: number }, filter?: { category_bits?: number; mask_bits?: number }, max_results?: number): Record<string | number, unknown>;
+    /**
+     * Enable or disable continuous collision.
+     *
+     * @param world - world
+     * @param enable - true to enable continuous collision
+     */
+    function enable_continuous(world: Opaque<"b2World">, enable: boolean): void;
+    /**
+     * Enable or disable world sleeping.
+     *
+     * @param world - world
+     * @param enable - true to allow sleeping
+     */
+    function enable_sleeping(world: Opaque<"b2World">, enable: boolean): void;
+    /**
+     * Enable or disable speculative collision.
+     *
+     * @param world - world
+     * @param enable - true to enable speculative collision
+     */
+    function enable_speculative(world: Opaque<"b2World">, enable: boolean): void;
+    /**
+     * Enable or disable warm starting.
+     *
+     * @param world - world
+     * @param enable - true to enable warm starting
+     */
+    function enable_warm_starting(world: Opaque<"b2World">, enable: boolean): void;
+    /**
+     * The definition table requires `position`, `radius`, `falloff`, and
+     * `impulse_per_length`. It may also include `mask_bits`.
+     *
+     * @param world - world
+     * @param definition - explosion definition
+     */
+    function explode(world: Opaque<"b2World">, definition: Record<string | number, unknown>): void;
+    /**
+     * Get the number of awake bodies.
+     *
+     * @param world - world
+     * @returns awake body count
+     */
+    function get_awake_body_count(world: Opaque<"b2World">): number;
+    /**
+     * The returned table contains `body_count`, `shape_count`, `contact_count`,
+     * `joint_count`, `island_count`, `stack_used`, `static_tree_height`,
+     * `tree_height`, `byte_count`, `task_count`, and `color_counts`.
+     *
+     * @param world - world
+     * @returns world counters
+     */
+    function get_counters(world: Opaque<"b2World">): Record<string | number, unknown>;
+    /**
+     * Get world gravity.
+     *
+     * @param world - world
+     * @returns gravity vector
+     */
+    function get_gravity(world: Opaque<"b2World">): Vector3;
+    /**
+     * Get the hit event threshold.
+     *
+     * @param world - world
+     * @returns hit event threshold in project units per second
+     */
+    function get_hit_event_threshold(world: Opaque<"b2World">): number;
+    /**
+     * Get the maximum linear speed.
+     *
+     * @param world - world
+     * @returns maximum linear speed in project units per second
+     */
+    function get_maximum_linear_speed(world: Opaque<"b2World">): number;
+    /**
+     * The returned table contains Box2D timing fields including `step`, `pairs`,
+     * `collide`, `solve`, `merge_islands`, `prepare_stages`, `solve_constraints`,
+     * `prepare_constraints`, `integrate_velocities`, `warm_start`,
+     * `solve_impulses`, `integrate_positions`, `relax_impulses`,
+     * `apply_restitution`, `store_impulses`, `split_islands`, `transforms`,
+     * `hit_events`, `refit`, `bullets`, `sleep_islands`, and `sensors`.
+     *
+     * @param world - world
+     * @returns world profiling data
+     */
+    function get_profile(world: Opaque<"b2World">): Record<string | number, unknown>;
+    /**
+     * Get the restitution threshold.
+     *
+     * @param world - world
+     * @returns restitution threshold in project units per second
+     */
+    function get_restitution_threshold(world: Opaque<"b2World">): number;
+    /**
+     * Get whether continuous collision is enabled.
+     *
+     * @param world - world
+     * @returns true if continuous collision is enabled
+     */
+    function is_continuous_enabled(world: Opaque<"b2World">): boolean;
+    /**
+     * The world is locked during callbacks and some simulation phases. Functions
+     * marked as locked during callbacks cannot be called while this returns true.
+     *
+     * @param world - world
+     * @returns true if the world is locked
+     */
+    function is_locked(world: Opaque<"b2World">): boolean;
+    /**
+     * Get whether world sleeping is enabled.
+     *
+     * @param world - world
+     * @returns true if sleeping is enabled
+     */
+    function is_sleeping_enabled(world: Opaque<"b2World">): boolean;
+    /**
+     * Check whether a world handle is valid.
+     *
+     * @param world - world
+     * @returns true if the world handle is valid
+     */
+    function is_valid(world: Opaque<"b2World">): boolean;
+    /**
+     * Get whether warm starting is enabled.
+     *
+     * @param world - world
+     * @returns true if warm starting is enabled
+     */
+    function is_warm_starting_enabled(world: Opaque<"b2World">): boolean;
+    /**
+     * Overlap an AABB.
+     *
+     * @param world - world from `b2d.get_world` or `b2d.body.get_world`
+     * @param aabb - table with `lower` and `upper` vector3 fields
+     * @param filter - optional query filter with `category_bits`, `mask_bits`, and optional `group_index`
+     * @param max_results - optional maximum result count
+     */
+    function overlap_aabb(world: Opaque<"b2World">, aabb: { lower?: Vector3; upper?: Vector3 }, filter: { category_bits?: number; mask_bits?: number; group_index?: number }, max_results: number): LuaMultiReturn<[{ index: number; type: number; sensor: boolean; density: number; friction: number; restitution: number; child_count: number }[], { node_visits: number; leaf_visits: number }]>;
+    /**
+     * The AABB table has `lower` and `upper` `vector3` fields.
+     *
+     * @param world - world
+     * @param aabb - AABB table with `lower` and `upper`
+     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
+     */
+    function overlap_aabb(world: Opaque<"b2World">, aabb: { lower?: Vector3; upper?: Vector3 }, filter?: { category_bits?: number; mask_bits?: number; group_index?: number }, max_results?: number): LuaMultiReturn<[{ shape_id: number }[], { node_visits: number; leaf_visits: number }]>;
+    /**
+     * Overlap a shape.
+     *
+     * @param world - world from `b2d.get_world` or `b2d.body.get_world`
+     * @param shape - shape table using the same format as the `shape` field in `b2d.body.create_fixture`
+     * @param filter - optional query filter with `category_bits`, `mask_bits`, and optional `group_index`
+     * @param max_results - optional maximum result count
+     */
+    function overlap_shape(world: Opaque<"b2World">, shape: { type?: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, filter: { category_bits?: number; mask_bits?: number; group_index?: number }, max_results: number): LuaMultiReturn<[{ index: number; type: number; sensor: boolean; density: number; friction: number; restitution: number; child_count: number }[], { node_visits: number; leaf_visits: number }]>;
+    /**
+     * The shape table uses the same circle, capsule, segment, polygon, and box formats
+     * as `b2d.body.create_shape`.
+     *
+     * @param world - world
+     * @param shape - shape table
+     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
+     */
+    function overlap_shape(world: Opaque<"b2World">, shape: { type?: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, filter?: { category_bits?: number; mask_bits?: number; group_index?: number }, max_results?: number): LuaMultiReturn<[{ shape_id: number }[], { node_visits: number; leaf_visits: number }]>;
+    /**
+     * Rebuild the static broad-phase tree.
+     *
+     * @param world - world
+     */
+    function rebuild_static_tree(world: Opaque<"b2World">): void;
+    /**
+     * Set contact solver tuning.
+     *
+     * @param world - world
+     * @param hertz - contact stiffness frequency in hertz
+     * @param damping_ratio - contact damping ratio
+     * @param pushout - pushout velocity in project units per second
+     */
+    function set_contact_tuning(world: Opaque<"b2World">, hertz: number, damping_ratio: number, pushout: number): void;
+    /**
+     * Set world gravity.
+     *
+     * @param world - world
+     * @param gravity - gravity vector
+     */
+    function set_gravity(world: Opaque<"b2World">, gravity: Vector3): void;
+    /**
+     * Set the hit event threshold.
+     *
+     * @param world - world
+     * @param threshold - hit event threshold in project units per second
+     */
+    function set_hit_event_threshold(world: Opaque<"b2World">, threshold: number): void;
+    /**
+     * Set joint solver tuning.
+     *
+     * @param world - world
+     * @param hertz - joint stiffness frequency in hertz
+     * @param damping_ratio - joint damping ratio
+     */
+    function set_joint_tuning(world: Opaque<"b2World">, hertz: number, damping_ratio: number): void;
+    /**
+     * Set the maximum linear speed.
+     *
+     * @param world - world
+     * @param speed - maximum linear speed in project units per second
+     */
+    function set_maximum_linear_speed(world: Opaque<"b2World">, speed: number): void;
+    /**
+     * Collisions below this relative speed use inelastic collision response.
+     *
+     * @param world - world
+     * @param threshold - restitution threshold in project units per second
+     */
+    function set_restitution_threshold(world: Opaque<"b2World">, threshold: number): void;
+  }
+}
+
+export {};

package/generated/buffer.d.ts

@@ -142,7 +142,7 @@ declare global {
      * if (values) print(`${values.length} values in 'somefloats'`);
      * ```
      */
-    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | unknown, Opaque<"constant"> | unknown]>;
+    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, Opaque<"constant"> | undefined]>;
     /**
      * Get a specified stream from a buffer.
      *

package/generated/builtin-messages.d.ts

@@ -2,17 +2,22 @@ import type { Hash, Matrix4, Vector3, Vector4 } from "../src/core-types";
 
 declare global {
   interface BuiltinMessages {
+    /** @deprecated since 1.13.0 */
+    acquire_camera_focus: Record<string, never>;
     acquire_input_focus: Record<string, never>;
     animation_done: { current_tile: number; id: Hash };
     apply_force: { force: Vector3; position: Vector3 };
     async_load: Record<string, never>;
     clear_color: { color: Vector4 };
+    collision_event: { a: Record<string | number, unknown>; b: Record<string | number, unknown> };
     collision_response: { other_id: Hash; other_position: Vector3; other_group: Hash; own_group: Hash };
+    contact_point_event: { applied_impulse: number; distance: number; a: Record<string | number, unknown>; b: Record<string | number, unknown> };
     contact_point_response: { position: Vector3; normal: Vector3; relative_velocity: Vector3; distance: number; applied_impulse: number; life_time: number; mass: number; other_mass: number; other_id: Hash; other_position: Vector3; other_group: Hash; own_group: Hash };
     disable: Record<string, never>;
     draw_debug_text: { position: Vector3; text: string; color: Vector4 };
     draw_line: { start_point: Vector3; end_point: Vector3; color: Vector4 };
     enable: Record<string, never>;
+    exit: { code: number };
     final: Record<string, never>;
     init: Record<string, never>;
     layout_changed: { id: Hash; previous_id: Hash };
@@ -24,14 +29,27 @@ declare global {
     proxy_unloaded: Record<string, never>;
     ray_cast_missed: { group: Hash; request_id: number };
     ray_cast_response: { fraction: number; position: Vector3; normal: Vector3; id: Hash; group: Hash; request_id: number };
+    reboot: { arg1: string; arg2: string; arg3: string; arg4: string; arg5: string; arg6: string };
+    /** @deprecated since 1.13.0 */
+    release_camera_focus: Record<string, never>;
     release_input_focus: Record<string, never>;
+    resize: { height: number; width: number };
+    resume_rendering: Record<string, never>;
+    set_camera: { aspect_ratio: number; fov: number; near_z: number; far_z: number; orthographic_projection: boolean; orthographic_zoom: number; orthographic_mode: number };
     set_gain: { gain: number };
     set_parent: { parent_id?: Hash; keep_world_transform?: 0 | 1 };
     set_time_step: { factor: number; mode: number };
+    set_update_frequency: { frequency: number };
     set_view_projection: { id: Hash; view: Matrix4; projection: Matrix4 };
+    set_vsync: { swap_interval: number };
     sound_done: { play_id: number };
     sound_stopped: { play_id: number };
+    start_record: { file_name: string; frame_period: number; fps: number };
+    stop_record: Record<string, never>;
     stop_sound: Record<string, never>;
+    toggle_physics_debug: Record<string, never>;
+    toggle_profile: Record<string, never>;
+    trigger_event: { enter: boolean; a: Record<string | number, unknown>; b: Record<string | number, unknown> };
     trigger_response: { other_id: Hash; enter: boolean; other_group: Hash; own_group: Hash };
     unload: Record<string, never>;
     window_resized: { height: number; width: number };