@defold-typescript/types 0.40.0 → 0.42.0

package/generated/b2d_shape.d.ts

@@ -8,8 +8,10 @@ declare global {
    */
   namespace b2d.shape {
     type b2Shape = Opaque<"b2Shape">;
+    type definition = { type: b2d.shape.SHAPE_TYPE; radius: number; center?: Vector3 } | { type: b2d.shape.SHAPE_TYPE; radius: number; center1: Vector3; center2: Vector3 } | { type: b2d.shape.SHAPE_TYPE; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: b2d.shape.SHAPE_TYPE; hx: number; hy: number; center?: Vector3; angle?: number } | { type: b2d.shape.SHAPE_TYPE; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 };
+    type SHAPE_TYPE = typeof b2d.shape.SHAPE_TYPE_BOX | typeof b2d.shape.SHAPE_TYPE_CAPSULE | typeof b2d.shape.SHAPE_TYPE_CHAIN | typeof b2d.shape.SHAPE_TYPE_CIRCLE | typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_GRID | typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_SEGMENT;
     /**
-     * Uses the polygon enum value, but indicates the `hx`/`hy` box convenience format.
+     * Box shape type alias. 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" };
     /**
@@ -25,7 +27,7 @@ declare global {
      */
     const SHAPE_TYPE_CIRCLE: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_CIRCLE" };
     /**
-     * Edge shape type.
+     * Edge shape type alias. Compatibility alias for `b2d.shape.SHAPE_TYPE_SEGMENT`.
      */
     const SHAPE_TYPE_EDGE: number & { readonly __brand: "b2d.shape.SHAPE_TYPE_EDGE" };
     /**
@@ -47,6 +49,13 @@ declare global {
      * @returns true if contact events are enabled
      */
     function are_contact_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Check if contact events are enabled for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns true if contact events are enabled
+     */
     function are_contact_events_enabled(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Check if hit events are enabled for a shape.
@@ -55,6 +64,13 @@ declare global {
      * @returns true if hit events are enabled
      */
     function are_hit_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Check if hit events are enabled for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns true if hit events are enabled
+     */
     function are_hit_events_enabled(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Check if pre-solve events are enabled for a shape.
@@ -63,6 +79,13 @@ declare global {
      * @returns true if pre-solve events are enabled
      */
     function are_pre_solve_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Check if pre-solve events are enabled for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns true if pre-solve events are enabled
+     */
     function are_pre_solve_events_enabled(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Check if sensor events are enabled for a shape.
@@ -71,6 +94,13 @@ declare global {
      * @returns true if sensor events are enabled
      */
     function are_sensor_events_enabled(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Check if sensor events are enabled for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns true if sensor events are enabled
+     */
     function are_sensor_events_enabled(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Enable or disable contact events for a shape.
@@ -79,6 +109,13 @@ declare global {
      * @param enable - true to enable contact events
      */
     function enable_contact_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    /**
+     * Enable or disable contact events for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param enable - true to enable contact events
+     */
     function enable_contact_events(body: Opaque<"b2Body">, shape_index: number, enable: boolean): void;
     /**
      * Enable or disable hit events for a shape.
@@ -87,6 +124,13 @@ declare global {
      * @param enable - true to enable hit events
      */
     function enable_hit_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    /**
+     * Enable or disable hit events for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param enable - true to enable hit events
+     */
     function enable_hit_events(body: Opaque<"b2Body">, shape_index: number, enable: boolean): void;
     /**
      * Enable or disable pre-solve events for a shape.
@@ -95,6 +139,13 @@ declare global {
      * @param enable - true to enable pre-solve events
      */
     function enable_pre_solve_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    /**
+     * Enable or disable pre-solve events for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param enable - true to enable pre-solve events
+     */
     function enable_pre_solve_events(body: Opaque<"b2Body">, shape_index: number, enable: boolean): void;
     /**
      * Enable or disable sensor events for a shape.
@@ -103,6 +154,13 @@ declare global {
      * @param enable - true to enable sensor events
      */
     function enable_sensor_events(shape_id: Opaque<"b2Shape">, enable: boolean): void;
+    /**
+     * Enable or disable sensor events for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param enable - true to enable sensor events
+     */
     function enable_sensor_events(body: Opaque<"b2Body">, shape_index: number, enable: boolean): void;
     /**
      * Get the body owning a shape.
@@ -111,6 +169,13 @@ declare global {
      * @returns owning body
      */
     function get_body(shape_id: Opaque<"b2Shape">): Opaque<"b2Body">;
+    /**
+     * Get the body owning a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns owning body
+     */
     function get_body(body: Opaque<"b2Body">, shape_index: number): Opaque<"b2Body">;
     /**
      * Get the closest point on a shape.
@@ -120,6 +185,14 @@ declare global {
      * @returns closest world point on the shape
      */
     function get_closest_point(shape_id: Opaque<"b2Shape">, target: Vector3): Vector3;
+    /**
+     * Get the closest point on a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param target - world target point
+     * @returns closest world point on the shape
+     */
     function get_closest_point(body: Opaque<"b2Body">, shape_index: number, target: Vector3): Vector3;
     /**
      * Get shape contact capacity.
@@ -128,23 +201,44 @@ declare global {
      * @returns maximum contact data count
      */
     function get_contact_capacity(shape_id: Opaque<"b2Shape">): number;
+    /**
+     * Get shape contact capacity.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns maximum contact data count
+     */
     function get_contact_capacity(body: Opaque<"b2Body">, shape_index: number): 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
+     * @returns touching contacts
      */
-    function get_contact_data(shape_id: Opaque<"b2Shape">): Record<string | number, unknown>;
-    function get_contact_data(body: Opaque<"b2Body">, shape_index: number): Record<string | number, unknown>;
+    function get_contact_data(shape_id: Opaque<"b2Shape">): b2d.contact_data[];
+    /**
+     * Get touching contact data for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns touching contacts
+     */
+    function get_contact_data(body: Opaque<"b2Body">, shape_index: number): b2d.contact_data[];
     /**
      * 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`
+     * @returns shape mass data
+     */
+    function get_mass_data(shape_id: Opaque<"b2Shape">): b2d.mass_data;
+    /**
+     * Get mass data for a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns shape mass data
      */
-    function get_mass_data(shape_id: Opaque<"b2Shape">): { mass: number; center: Vector3; inertia: number };
-    function get_mass_data(body: Opaque<"b2Body">, shape_index: number): { mass: number; center: Vector3; inertia: number };
+    function get_mass_data(body: Opaque<"b2Body">, shape_index: number): b2d.mass_data;
     /**
      * Get shape material id.
      *
@@ -152,6 +246,13 @@ declare global {
      * @returns shape material id
      */
     function get_material(shape_id: Opaque<"b2Shape">): number;
+    /**
+     * Get shape material id.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns shape material id
+     */
     function get_material(body: Opaque<"b2Body">, shape_index: number): number;
     /**
      * Get sensor overlap capacity.
@@ -160,23 +261,44 @@ declare global {
      * @returns maximum sensor overlap count
      */
     function get_sensor_capacity(shape_id: Opaque<"b2Shape">): number;
+    /**
+     * Get sensor overlap capacity.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns maximum sensor overlap count
+     */
     function get_sensor_capacity(body: Opaque<"b2Body">, shape_index: number): 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
+     * @returns overlapping shapes
+     */
+    function get_sensor_overlaps(shape_id: Opaque<"b2Shape">): b2d.shape_info[];
+    /**
+     * Get sensor overlaps.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns overlapping shapes
      */
-    function get_sensor_overlaps(shape_id: Opaque<"b2Shape">): { shape_id: number }[];
-    function get_sensor_overlaps(body: Opaque<"b2Body">, shape_index: number): { shape_id: number }[];
+    function get_sensor_overlaps(body: Opaque<"b2Body">, shape_index: number): b2d.shape_info[];
     /**
      * 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 };
-    function get_shape(body: Opaque<"b2Body">, shape_index: number): { type: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 };
+    function get_shape(shape_id: Opaque<"b2Shape">): b2d.shape.definition;
+    /**
+     * Get a shape's geometry.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns shape table with numeric `type` from `b2d.shape.SHAPE_TYPE_*`
+     */
+    function get_shape(body: Opaque<"b2Body">, shape_index: number): b2d.shape.definition;
     /**
      * Get the world owning a shape.
      *
@@ -184,6 +306,13 @@ declare global {
      * @returns owning world
      */
     function get_world(shape_id: Opaque<"b2Shape">): Opaque<"b2World">;
+    /**
+     * Get the world owning a shape.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns owning world
+     */
     function get_world(body: Opaque<"b2Body">, shape_index: number): Opaque<"b2World">;
     /**
      * Validate a shape handle.
@@ -192,6 +321,13 @@ declare global {
      * @returns true if the shape handle still refers to a live Box2D shape
      */
     function is_valid(shape_id: Opaque<"b2Shape">): boolean;
+    /**
+     * Validate a shape handle.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns true if the shape handle still refers to a live Box2D shape
+     */
     function is_valid(body: Opaque<"b2Body">, shape_index: number): boolean;
     /**
      * Ray cast a shape directly.
@@ -200,10 +336,20 @@ declare global {
      * @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
+     * @returns cast result, or `nil`
+     */
+    function ray_cast(shape_id: Opaque<"b2Shape">, origin: Vector3, translation: Vector3, max_fraction?: number): b2d.shape_cast_output | undefined;
+    /**
+     * Ray cast a shape directly.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param origin - world ray origin
+     * @param translation - world ray translation
+     * @param max_fraction - optional maximum translation fraction, defaults to 1
+     * @returns cast result, or `nil`
      */
-    function ray_cast(shape_id: Opaque<"b2Shape">, origin: Vector3, translation: Vector3, max_fraction?: number): { point: Vector3; normal: Vector3; fraction: number; iterations: number };
-    function ray_cast(body: Opaque<"b2Body">, shape_index: number, origin: Vector3, translation: Vector3, max_fraction?: number): { point: Vector3; normal: Vector3; fraction: number; iterations: number };
+    function ray_cast(body: Opaque<"b2Body">, shape_index: number, origin: Vector3, translation: Vector3, max_fraction?: number): b2d.shape_cast_output | undefined;
     /**
      * Set shape material id.
      *
@@ -211,6 +357,13 @@ declare global {
      * @param material - shape material id
      */
     function set_material(shape_id: Opaque<"b2Shape">, material: number): void;
+    /**
+     * Set shape material id.
+     *
+     * @param body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param material - shape material id
+     */
     function set_material(body: Opaque<"b2Body">, shape_index: number, material: number): void;
     /**
      * This updates the shape geometry using the same table format as
@@ -225,14 +378,24 @@ declare global {
      * const body = b2d.get_body("#collisionobject");
      * if (body !== undefined) {
      *   const circle = b2d.shape.get_shape(body, 1);
-     *   circle.center = vmath.vector3(24, 0, 0);
-     *   b2d.shape.set_shape(body, 1, circle, true);
+     *   const radius = "radius" in circle ? circle.radius : undefined;
+     *   b2d.shape.set_shape(body, 1, { type: b2d.shape.SHAPE_TYPE_CIRCLE, radius: radius ?? 16, center: vmath.vector3(24, 0, 0) }, 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;
-    function set_shape(body: Opaque<"b2Body">, shape_index: number, definition: { type?: number; radius?: number; center?: Vector3; v0?: Vector3; v1?: Vector3; v2?: Vector3; v3?: Vector3; vertices?: Vector3[]; hx?: number; hy?: number; angle?: number; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, update_mass?: boolean): void;
+    function set_shape(shape_id: Opaque<"b2Shape">, definition: { 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 }, update_mass?: boolean): 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 body - The body that owns the shape.
+     * @param shape_index - The shape's position on that body, in the order `b2d.body.get_shapes` lists them. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param definition - shape table with numeric `type` from `b2d.shape.SHAPE_TYPE_*`
+     * @param update_mass - true to reset body mass from shapes
+     */
+    function set_shape(body: Opaque<"b2Body">, shape_index: number, definition: { 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 }, update_mass?: boolean): void;
   }
 }
 

package/generated/b2d_world.d.ts

@@ -7,27 +7,26 @@ declare global {
    */
   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,
+     * 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 capsule - mover capsule
      * @param translation - capsule displacement
-     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @param filter - optional query filter
      * @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;
+    function cast_mover(world: Opaque<"b2World">, capsule: b2d.mover_capsule, translation: Vector3, filter?: b2d.query_filter): number;
     /**
      * Cast a ray.
      *
-     * @param world - world from `b2d.get_world` or `b2d.body.get_world`
+     * @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 filter - optional query filter
      * @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 }]>;
+    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]>;
     /**
      * The translation is the ray displacement from `origin`. Result order is not
      * guaranteed by Box2D.
@@ -35,63 +34,61 @@ declare global {
      * @param world - world
      * @param origin - ray start position
      * @param translation - ray displacement
-     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @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?: { 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 }]>;
+    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]>;
     /**
      * Cast a ray and return the closest hit.
      *
-     * @param world - world from `b2d.get_world` or `b2d.body.get_world`
+     * @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
+     * @param filter - optional query filter
+     * @returns closest hit, 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 };
+    function cast_ray_closest(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter): b2d.fixture_cast_hit | undefined;
     /**
      * 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
+     * @param filter - optional query filter
+     * @returns closest hit, 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 } | undefined;
+    function cast_ray_closest(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.
      *
-     * @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 world - world from b2d.get_world or b2d.body.get_world
+     * @param shape - query shape
      * @param translation - world shape translation
-     * @param filter - optional query filter with `category_bits`, `mask_bits`, and optional `group_index`
+     * @param filter - optional query filter
      * @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 }]>;
+    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]>;
     /**
-     * The shape table uses the same circle, capsule, segment, polygon, and box formats
-     * as `b2d.body.create_shape`. The translation is the shape displacement.
+     * The translation is the shape displacement.
      *
      * @param world - world
-     * @param shape - shape table
+     * @param shape - cast shape
      * @param translation - shape displacement
-     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @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?: 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 }]>;
+    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]>;
     /**
-     * The capsule table has `center1`, `center2`, and `radius` fields. Plane result
-     * tables include `shape`, `normal`, `offset`, and `hit`.
+     * Collide a mover capsule against the world.
      *
      * @param world - world
-     * @param capsule - capsule table with `center1`, `center2`, and `radius`
-     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @param capsule - mover capsule
+     * @param filter - optional query filter
      * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
-     * @returns array of plane result tables
+     * @returns collision planes
      */
-    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>;
+    function collide_mover(world: Opaque<"b2World">, capsule: b2d.mover_capsule, filter?: b2d.query_filter, max_results?: number): b2d.mover_plane[];
     /**
      * Enable or disable continuous collision.
      *
@@ -121,13 +118,12 @@ declare global {
      */
     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`.
+     * Apply an explosion impulse.
      *
      * @param world - world
      * @param definition - explosion definition
      */
-    function explode(world: Opaque<"b2World">, definition: Record<string | number, unknown>): void;
+    function explode(world: Opaque<"b2World">, definition: b2d.explosion_definition): void;
     /**
      * Get the number of awake bodies.
      *
@@ -136,14 +132,12 @@ declare global {
      */
     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`.
+     * Get world counters.
      *
      * @param world - world
      * @returns world counters
      */
-    function get_counters(world: Opaque<"b2World">): Record<string | number, unknown>;
+    function get_counters(world: Opaque<"b2World">): b2d.world_counters;
     /**
      * Get world gravity.
      *
@@ -166,17 +160,12 @@ declare global {
      */
     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`.
+     * Get world profiling data.
      *
      * @param world - world
      * @returns world profiling data
      */
-    function get_profile(world: Opaque<"b2World">): Record<string | number, unknown>;
+    function get_profile(world: Opaque<"b2World">): b2d.world_profile;
     /**
      * Get the restitution threshold.
      *
@@ -223,40 +212,45 @@ declare global {
     /**
      * 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 world - world from b2d.get_world or b2d.body.get_world
+     * @param aabb - query bounds
+     * @param filter - optional query filter
      * @param max_results - optional maximum result count
+     * @returns `[fixtures, stats]`:
+     * - `fixtures` — overlapping fixtures. **⚠️ `index` is 1-based; passed to Defold unchanged.**
+     * - `stats` — broad-phase query statistics
      */
-    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 }]>;
+    function overlap_aabb(world: Opaque<"b2World">, aabb: b2d.aabb, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_info[], b2d.tree_stats]>;
     /**
-     * The AABB table has `lower` and `upper` `vector3` fields.
+     * Find shapes overlapping an AABB.
      *
      * @param world - world
-     * @param aabb - AABB table with `lower` and `upper`
-     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @param aabb - query bounds
+     * @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: { 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 }]>;
+    function overlap_aabb(world: Opaque<"b2World">, aabb: b2d.aabb, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_info[], b2d.tree_stats]>;
     /**
      * 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 world - world from b2d.get_world or b2d.body.get_world
+     * @param shape - query shape
+     * @param filter - optional query filter
      * @param max_results - optional maximum result count
+     * @returns `[fixtures, stats]`:
+     * - `fixtures` — overlapping fixtures. **⚠️ `index` is 1-based; passed to Defold unchanged.**
+     * - `stats` — broad-phase query statistics
      */
-    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 }]>;
+    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]>;
     /**
-     * The shape table uses the same circle, capsule, segment, polygon, and box formats
-     * as `b2d.body.create_shape`.
+     * Find shapes overlapping a shape proxy.
      *
      * @param world - world
-     * @param shape - shape table
-     * @param filter - optional query filter with `category_bits` and `mask_bits`
+     * @param shape - query shape
+     * @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?: 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 }]>;
+    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]>;
     /**
      * Rebuild the static broad-phase tree.
      *