@defold-typescript/types 0.19.4 → 0.20.0

package/generated/b2d_body.d.ts

@@ -1,5 +1,5 @@
 /** @noSelfInFile */
-import type { Opaque, Vector3 } from "../src/core-types";
+import type { Hash, Opaque, Vector3 } from "../src/core-types";
 
 declare global {
   /**
@@ -54,6 +54,13 @@ declare global {
      * @param point - the world position of the point of application.
      */
     function apply_linear_impulse(body: Opaque<"b2Body">, impulse: Vector3, point: Vector3): void;
+    /**
+     * Apply a linear impulse to the center of mass.
+     *
+     * @param body - body
+     * @param impulse - world impulse vector
+     */
+    function apply_linear_impulse_to_center(body: Opaque<"b2Body">, impulse: Vector3): void;
     /**
      * Apply a torque. This affects the angular velocity
      * without affecting the linear velocity of the center of mass.
@@ -63,6 +70,137 @@ declare global {
      * @param torque - torque about the z-axis (out of the screen), usually in N-m.
      */
     function apply_torque(body: Opaque<"b2Body">, torque: number): void;
+    /**
+     * Compute the world AABB of all body shapes.
+     *
+     * @param body - body
+     * @returns table with `lower` and `upper` vector3 fields
+     */
+    function compute_aabb(body: Opaque<"b2Body">): { lower: Vector3; upper: Vector3 };
+    /**
+     * Chains are one-sided connected segments with optional ghost vertices at
+     * the ends of open chains. Ghost vertices are creation-time chain data only and
+     * cannot be added to arbitrary shapes, bodies, or joints after creation.
+     *
+     * `definition.vertices`
+     * table array of local `vector3` vertices. Open chains require at least 2 vertices. Loop chains require at least 4 vertices.
+     * `definition.loop`
+     * boolean true to create a closed loop chain.
+     * `definition.prev_vertex`
+     * vector3 optional ghost vertex before the first vertex for open chains.
+     * `definition.next_vertex`
+     * vector3 optional ghost vertex after the last vertex for open chains.
+     * `definition.friction`
+     * number optional friction.
+     * `definition.restitution`
+     * number optional restitution.
+     * `definition.material`
+     * number optional material id.
+     * `definition.filter`
+     * table optional filter with `category_bits`, `mask_bits`, and `group_index`.
+     * `definition.enable_sensor_events`
+     * boolean true to enable sensor events for chain segments.
+     *
+     * @param body - body
+     * @param definition - the chain definition
+     * @example
+     * ```ts
+     * const [chain, segments] = b2d.body.create_chain(body, {
+     *   vertices: [vmath.vector3(-64, 0, 0), vmath.vector3(0, 16, 0), vmath.vector3(64, 0, 0)],
+     *   prev_vertex: vmath.vector3(-96, 0, 0), next_vertex: vmath.vector3(96, 0, 0), friction: 0.6,
+     * });
+     * ```
+     */
+    function create_chain(body: Opaque<"b2Body">, definition: Record<string | number, unknown>): LuaMultiReturn<[Opaque<"b2Chain">, { shape_id: number }[]]>;
+    /**
+     * Creates a fixture and attach it to this body. Use this function if you need
+     * to set some fixture parameters, like friction. Otherwise you can create the
+     * fixture directly from a shape.
+     * If the density is non-zero, this function automatically updates the mass of the body.
+     * Contacts are not created until the next time step.
+     *
+     * @param body - body
+     * @param definition - fixture definition table with:
+     * `shape` = shape table, `friction` = number, `restitution` = number,
+     * `density` = number, `sensor` = boolean, and optional `filter` table.
+     * Supported shape tables are:
+     * `circle` = `{ type = b2d.shape.SHAPE_TYPE_CIRCLE, radius = number, center = vector3_or_nil }`
+     * `edge` = `{ type = b2d.shape.SHAPE_TYPE_EDGE, v1 = vector3, v2 = vector3, v0 = vector3_or_nil, v3 = vector3_or_nil }`
+     * `polygon` = `{ type = b2d.shape.SHAPE_TYPE_POLYGON, vertices = { vector3, ... } }`
+     * `box` = `{ type = b2d.shape.SHAPE_TYPE_BOX, hx = number, hy = number, center = vector3_or_nil, angle = radians_or_nil }`
+     * `chain` = `{ type = b2d.shape.SHAPE_TYPE_CHAIN, vertices = { vector3, ... }, loop = boolean_or_nil, prev_vertex = vector3_or_nil, next_vertex = vector3_or_nil }`
+     * @returns fixture info table with `index`, `type`, `sensor`, `density`, `friction`, `restitution`, and `child_count`
+     * @example
+     * ```ts
+     * const body = b2d.get_body("#collisionobject");
+     * const triangle = b2d.body.create_fixture(body, {
+     *   density: 1.0, friction: 0.3,
+     *   shape: { type: b2d.shape.SHAPE_TYPE_POLYGON, vertices: [vmath.vector3(-16, -16, 0), vmath.vector3(16, -16, 0), vmath.vector3(0, 16, 0)] },
+     * });
+     * ```
+     */
+    function create_fixture(body: Opaque<"b2Body">, definition: { 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 }; friction?: number; restitution?: number; density?: number; sensor?: boolean; filter?: { category_bits?: number; mask_bits?: number; group_index?: number } }): { index: number; type: number; sensor: boolean; density: number; friction: number; restitution: number; child_count: number };
+    /**
+     * Creates a fixture from a shape and attach it to this body.
+     * This is a convenience function. Use b2FixtureDef if you need to set parameters
+     * like friction, restitution, user data, or filtering.
+     * If the density is non-zero, this function automatically updates the mass of the body.
+     *
+     * @param body - body
+     * @param shape - the shape to be cloned.
+     * @param density - the shape density (set to zero for static bodies).
+     */
+    function create_fixture(body: Opaque<"b2Body">, shape: Opaque<"b2Shape">, density: number): void;
+    /**
+     * Creates a shape and attaches it to this body.
+     * If the density is non-zero, this function automatically updates the mass of the body.
+     * Contacts are not created until the next time step.
+     * The definition may include `density`, `friction`, `restitution`, `material`,
+     * `sensor` or `is_sensor`, `filter`, and the shape table itself. The shape table
+     * can be in `definition.shape` or directly in `definition`.
+     *
+     * @param body - body
+     * @param definition - the shape definition.
+     */
+    function create_shape(body: Opaque<"b2Body">, definition: Record<string | number, unknown>): void;
+    /**
+     * Destroy a fixture from a body.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     */
+    function destroy_fixture(body: Opaque<"b2Body">, fixture_index: number): void;
+    /**
+     * Destroy a shape. This removes the shape from the broad-phase and
+     * destroys all contacts associated with this shape. This will
+     * automatically adjust the mass of the body if the body is dynamic and the
+     * shape has positive density.
+     * All shapes attached to a body are implicitly destroyed when the body is destroyed.
+     *
+     * @param body - body
+     * @param shape_index - 1-based shape index from `b2d.body.get_shapes`
+     */
+    function destroy_shape(body: Opaque<"b2Body">, shape_index: number): void;
+    /**
+     * Print the body representation to the log output
+     *
+     * @param body - body
+     */
+    function dump(body: Opaque<"b2Body">): void;
+    /**
+     * Enable or disable contact events on all body shapes.
+     *
+     * @param body - body
+     * @param enable - true to enable contact events
+     */
+    function enable_contact_events(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Enable or disable hit events on all body shapes.
+     *
+     * @param body - body
+     * @param enable - true to enable hit events
+     */
+    function enable_hit_events(body: Opaque<"b2Body">, enable: boolean): void;
     /**
      * You can disable sleeping on this body. If you disable sleeping, the body will be woken.
      *
@@ -91,6 +229,33 @@ declare global {
      * @returns the angular velocity in radians/second.
      */
     function get_angular_velocity(body: Opaque<"b2Body">): number;
+    /**
+     * Get touching contact data for a body.
+     *
+     * @param body - body
+     * @returns array of contact tables
+     */
+    function get_contact_data(body: Opaque<"b2Body">): Record<string | number, unknown>;
+    /**
+     * Get the list of all contacts attached to this body.
+     *
+     * @param body - body
+     * @returns the first edge
+     */
+    function get_contact_list(body: Opaque<"b2Body">): Opaque<"b2ContactEdge">;
+    /**
+     * Get the fixtures attached to this body.
+     *
+     * @param body - body
+     * @returns array of fixture info tables with `index`, `type`, `sensor`, `density`, `friction`, `restitution`, and `child_count`
+     */
+    function get_fixtures(body: Opaque<"b2Body">): { index: number; type: number; sensor: boolean; density: number; friction: number; restitution: number; child_count: number }[];
+    /**
+     * Get the total force currently applied on this object
+     *
+     * @param body - body
+     */
+    function get_force(body: Opaque<"b2Body">): Vector3;
     /**
      * Get the gravity scale of the body.
      *
@@ -98,6 +263,20 @@ declare global {
      * @returns the scale
      */
     function get_gravity_scale(body: Opaque<"b2Body">): number;
+    /**
+     * Get the rotational inertia of the body about the local origin.
+     *
+     * @param body - body
+     * @returns the rotational inertia, usually in kg-m^2.
+     */
+    function get_inertia(body: Opaque<"b2Body">): number;
+    /**
+     * Get the joints attached to this body.
+     *
+     * @param body - body
+     * @returns array of `b2Joint` handles created by `b2d.joint`
+     */
+    function get_joints(body: Opaque<"b2Body">): number[];
     /**
      * Get the linear damping of the body.
      *
@@ -128,6 +307,13 @@ declare global {
      * @returns the world velocity of a point.
      */
     function get_linear_velocity_from_world_point(body: Opaque<"b2Body">, world_point: Vector3): Vector3;
+    /**
+     * Get the local position of the center of mass.
+     *
+     * @param body - body
+     * @returns Get the local position of the center of mass.
+     */
+    function get_local_center(body: Opaque<"b2Body">): Vector3;
     /**
      * Get the local position of the center of mass.
      *
@@ -158,6 +344,34 @@ declare global {
      * @returns the mass, usually in kilograms (kg).
      */
     function get_mass(body: Opaque<"b2Body">): number;
+    /**
+     * Get the mass data of the body.
+     *
+     * @param body - body
+     * @returns table with `mass`, `center` in local coordinates, and `inertia`.
+     */
+    function get_mass_data(body: Opaque<"b2Body">): { mass: number; center: Vector3; inertia: number };
+    /**
+     * Get the mass data of the body.
+     *
+     * @param body - body
+     * @returns a struct containing the mass, inertia and center of the body.
+     */
+    function get_mass_data(body: Opaque<"b2Body">): Opaque<"b2MassData">;
+    /**
+     * Get the body name.
+     *
+     * @param body - body
+     * @returns body name, or nil if no name is set
+     */
+    function get_name(body: Opaque<"b2Body">): string;
+    /**
+     * Get the next body in the world's body list.
+     *
+     * @param body - body
+     * @returns the next body
+     */
+    function get_next(body: Opaque<"b2Body">): Opaque<"b2Body">;
     /**
      * Get the world body origin position.
      *
@@ -172,6 +386,34 @@ declare global {
      * @returns the rotational inertia, usually in kg-m^2.
      */
     function get_rotational_inertia(body: Opaque<"b2Body">): number;
+    /**
+     * Get the list of all shapes attached to this body.
+     *
+     * @param body - body
+     * @returns a table of shape info entries. Each entry includes `shape_id` for use with `b2d.shape` functions.
+     */
+    function get_shapes(body: Opaque<"b2Body">): { shape_id: number }[];
+    /**
+     * Get the sleep velocity threshold.
+     *
+     * @param body - body
+     * @returns velocity threshold in Defold units per second
+     */
+    function get_sleep_threshold(body: Opaque<"b2Body">): number;
+    /**
+     * Get the body transform for the body's origin.
+     *
+     * @param body - body
+     * @returns table with `position` and `angle` in radians.
+     */
+    function get_transform(body: Opaque<"b2Body">): { position: Vector3; angle: number };
+    /**
+     * Get the body transform for the body's origin.
+     *
+     * @param body - body
+     * @returns the world position of the body's origin.
+     */
+    function get_transform(body: Opaque<"b2Body">): Opaque<"b2Transform">;
     /**
      * Get the type of this body.
      *
@@ -179,12 +421,33 @@ declare global {
      * @returns the body type
      */
     function get_type(body: Opaque<"b2Body">): (number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_STATIC_BODY" });
+    /**
+     * Get the user data pointer that was provided in the body definition.
+     *
+     * @param body - body
+     * @returns the game object id this body is connected to
+     */
+    function get_user_data(body: Opaque<"b2Body">): Hash;
     /**
      * Get the parent world of this body.
      *
      * @param body - body
      */
     function get_world(body: Opaque<"b2Body">): Opaque<"b2World">;
+    /**
+     * Get the angle in radians.
+     *
+     * @param body - body
+     * @returns the current world rotation angle in radians.
+     */
+    function get_world_center(body: Opaque<"b2Body">): number;
+    /**
+     * Get the world position of the center of mass.
+     *
+     * @param body - body
+     * @returns Get the world position of the center of mass.
+     */
+    function get_world_center(body: Opaque<"b2Body">): Vector3;
     /**
      * Get the world position of the center of mass.
      *
@@ -236,6 +499,13 @@ declare global {
      * @returns is the rotation fixed
      */
     function is_fixed_rotation(body: Opaque<"b2Body">): boolean;
+    /**
+     * Is this body allowed to sleep
+     *
+     * @param body - body
+     * @returns true if the body is allowed to sleep
+     */
+    function is_sleeping_allowed(body: Opaque<"b2Body">): boolean;
     /**
      * Is this body allowed to sleep
      *
@@ -243,6 +513,13 @@ declare global {
      * @returns true if the body is allowed to sleep
      */
     function is_sleeping_enabled(body: Opaque<"b2Body">): boolean;
+    /**
+     * Validate a body handle.
+     *
+     * @param body - body
+     * @returns true if the body handle still refers to a live Box2D body
+     */
+    function is_valid(body: Opaque<"b2Body">): boolean;
     /**
      * This resets the mass properties to the sum of the mass properties of the fixtures.
      * This normally does not need to be called unless you called SetMassData to override
@@ -325,6 +602,50 @@ declare global {
      * @param velocity - the new linear velocity of the center of mass.
      */
     function set_linear_velocity(body: Opaque<"b2Body">, velocity: Vector3): void;
+    /**
+     * Set the mass properties to override the mass properties of the fixtures.
+     *
+     * @param body - body
+     * @param data - table with `mass`, `center` in local coordinates, and `inertia`.
+     */
+    function set_mass_data(body: Opaque<"b2Body">, data: { mass?: number; center?: Vector3; inertia?: number }): void;
+    /**
+     * Set the mass properties to override the mass properties of the shapes.
+     *
+     * @param body - body
+     * @param data - the mass properties.
+     */
+    function set_mass_data(body: Opaque<"b2Body">, data: Opaque<"b2MassData">): void;
+    /**
+     * Set the body name.
+     *
+     * @param body - body
+     * @param name - body name
+     */
+    function set_name(body: Opaque<"b2Body">, name: string): void;
+    /**
+     * Set the sleep velocity threshold.
+     *
+     * @param body - body
+     * @param threshold - velocity threshold in Defold units per second
+     */
+    function set_sleep_threshold(body: Opaque<"b2Body">, threshold: number): void;
+    /**
+     * You can disable sleeping on this body. If you disable sleeping, the body will be woken.
+     *
+     * @param body - body
+     * @param enable - if false, the body will never sleep, and consume more CPU
+     */
+    function set_sleeping_allowed(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set velocity to reach a target transform.
+     *
+     * @param body - body
+     * @param position - target world position
+     * @param angle - target world angle in radians
+     * @param time_step - time step used to compute velocity
+     */
+    function set_target_transform(body: Opaque<"b2Body">, position: Vector3, angle: number, time_step: number): void;
     /**
      * Set the position of the body's origin and rotation.
      * This breaks any contacts and wakes the other bodies.
@@ -342,6 +663,13 @@ declare global {
      * @param type - the body type
      */
     function set_type(body: Opaque<"b2Body">, type: (number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_STATIC_BODY" })): void;
+    /**
+     * Set the user data. Use this to store your application specific data.
+     *
+     * @param body - body
+     * @param id - the game object id
+     */
+    function set_user_data(body: Opaque<"b2Body">, id: Hash): void;
   }
 }
 

package/generated/b2d_chain.d.ts

@@ -0,0 +1,106 @@
+/** @noSelfInFile */
+import type { Opaque } from "../src/core-types";
+
+declare global {
+  /**
+   * Functions for Box2D v3 chains. A chain owns multiple connected segment
+   * shapes, so it is represented by a separate `b2Chain` handle.
+   */
+  namespace b2d.chain {
+    type b2Chain = Opaque<"b2Chain">;
+    /**
+     * Destroying a chain removes all segment shapes owned by the chain. Destroying
+     * any segment shape through `b2d.body.destroy_shape` also destroys its parent chain.
+     *
+     * @param chain - chain
+     */
+    function destroy(chain: Opaque<"b2Chain">): void;
+    /**
+     * Returns `nil` if the shape is not a chain segment.
+     *
+     * @param shape_id - shape handle from a shape info table, or pass `body, shape_index`
+     * @returns parent chain, or `nil` if the shape is not a chain segment
+     */
+    function from_shape(shape_id: Opaque<"b2Shape">): Opaque<"b2Chain"> | unknown;
+    /**
+     * Get chain friction.
+     *
+     * @param chain - chain
+     * @returns chain friction
+     */
+    function get_friction(chain: Opaque<"b2Chain">): number;
+    /**
+     * Returns a chain geometry table with `loop`, `segment_count`, and `vertices`.
+     * Open chains also include `prev_vertex` and `next_vertex` ghost vertices.
+     *
+     * @param chain - chain
+     * @returns chain geometry table
+     */
+    function get_geometry(chain: Opaque<"b2Chain">): Record<string | number, unknown>;
+    /**
+     * Get chain material id.
+     *
+     * @param chain - chain
+     * @returns chain material id
+     */
+    function get_material(chain: Opaque<"b2Chain">): number;
+    /**
+     * Get chain restitution.
+     *
+     * @param chain - chain
+     * @returns chain restitution
+     */
+    function get_restitution(chain: Opaque<"b2Chain">): number;
+    /**
+     * Get the number of segment shapes in a chain.
+     *
+     * @param chain - chain
+     * @returns segment count
+     */
+    function get_segment_count(chain: Opaque<"b2Chain">): number;
+    /**
+     * Get the segment shapes owned by a chain.
+     *
+     * @param chain - chain
+     * @returns array of shape info tables for the chain segments. Each entry includes `shape_id`.
+     */
+    function get_segments(chain: Opaque<"b2Chain">): { shape_id: number }[];
+    /**
+     * Get the world owning a chain.
+     *
+     * @param chain - chain
+     * @returns owning world
+     */
+    function get_world(chain: Opaque<"b2Chain">): Opaque<"b2World">;
+    /**
+     * Validate a chain handle.
+     *
+     * @param chain - chain
+     * @returns true if the chain handle still refers to a live Box2D chain
+     */
+    function is_valid(chain: Opaque<"b2Chain">): boolean;
+    /**
+     * Set chain friction.
+     *
+     * @param chain - chain
+     * @param friction - chain friction
+     */
+    function set_friction(chain: Opaque<"b2Chain">, friction: number): void;
+    /**
+     * Set chain material id.
+     *
+     * @param chain - chain
+     * @param material - chain material id
+     */
+    function set_material(chain: Opaque<"b2Chain">, material: number): void;
+    /**
+     * Set chain restitution.
+     *
+     * @param chain - chain
+     * @param restitution - chain restitution
+     */
+    function set_restitution(chain: Opaque<"b2Chain">, restitution: number): void;
+  }
+}
+
+export {};

package/generated/b2d_fixture.d.ts

@@ -0,0 +1,155 @@
+/** @noSelfInFile */
+import type { Opaque, Vector3 } from "../src/core-types";
+
+declare global {
+  /**
+   * Functions for interacting with fixtures attached to Box2D bodies.
+   * Fixtures are addressed functionally by `(body, fixture_index)` rather than persistent Lua handles.
+   */
+  namespace b2d.fixture {
+    /**
+     * Get fixture AABB for a child shape.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     * @param child_index - 1-based child shape index
+     * @returns table with `lower` and `upper`
+     */
+    function get_aabb(body: Opaque<"b2Body">, fixture_index: number, child_index: number): { lower: Vector3; upper: Vector3 };
+    /**
+     * Get fixture density.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     * @returns density in kg/m^2
+     */
+    function get_density(body: Opaque<"b2Body">, fixture_index: number): number;
+    /**
+     * Get fixture filter data for a child shape.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     * @param child_index - 1-based child shape index
+     * @returns table with `category_bits`, `mask_bits`, and `group_index`
+     */
+    function get_filter_data(body: Opaque<"b2Body">, fixture_index: number, child_index: number): { category_bits: number; mask_bits: number; group_index: number };
+    /**
+     * Get fixture friction.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     */
+    function get_friction(body: Opaque<"b2Body">, fixture_index: number): number;
+    /**
+     * Get fixture restitution.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     */
+    function get_restitution(body: Opaque<"b2Body">, fixture_index: number): number;
+    /**
+     * Get the fixture shape as a functional shape table.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     * @returns shape table with numeric `type` from `b2d.shape.SHAPE_TYPE_*`,
+     * suitable for reuse in `b2d.body.create_fixture`.
+     * Circle shapes use `radius` and `center`, edge shapes use `v1`, `v2`, optional `v0`, `v3`,
+     * polygon shapes use `vertices`, and chain shapes use `vertices`, `loop`, optional `prev_vertex`, and `next_vertex`.
+     * Any angle values are in radians.
+     */
+    function get_shape(body: Opaque<"b2Body">, fixture_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 };
+    /**
+     * Get the fixture type.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     */
+    function get_type(body: Opaque<"b2Body">, fixture_index: number): number;
+    /**
+     * Check if a fixture is a sensor.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     */
+    function is_sensor(body: Opaque<"b2Body">, fixture_index: number): boolean;
+    /**
+     * Refilter a fixture.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     * @param touch_proxies - if true, touch broad-phase proxies
+     */
+    function refilter(body: Opaque<"b2Body">, fixture_index: number, touch_proxies: boolean): void;
+    /**
+     * Set fixture density.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     * @param density - density in kg/m^2
+     * @param update_mass - if true, reset body mass data after the change
+     */
+    function set_density(body: Opaque<"b2Body">, fixture_index: number, density: number, update_mass: boolean): void;
+    /**
+     * Set fixture filter data for a child shape.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     * @param child_index - 1-based child shape index
+     * @param filter - table with `category_bits`, `mask_bits`, and `group_index`
+     */
+    function set_filter_data(body: Opaque<"b2Body">, fixture_index: number, child_index: number, filter: { category_bits?: number; mask_bits?: number; group_index?: number }): void;
+    /**
+     * Set fixture friction.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     */
+    function set_friction(body: Opaque<"b2Body">, fixture_index: number, friction: number): void;
+    /**
+     * Set fixture restitution.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     */
+    function set_restitution(body: Opaque<"b2Body">, fixture_index: number, restitution: number): void;
+    /**
+     * Set sensor mode for a fixture.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     */
+    function set_sensor(body: Opaque<"b2Body">, fixture_index: number, enabled: boolean): void;
+    /**
+     * This updates the existing Box2D v2 shape using the same table format as
+     * `b2d.body.create_fixture` and `b2d.fixture.get_shape`.
+     * The shape type must match the current fixture shape type. Polygon updates must
+     * keep the same vertex count. Chain shape geometry cannot be updated in-place.
+     * The body mass is not updated unless `update_mass` is true.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     * @param shape - shape table with numeric `type` from `b2d.shape.SHAPE_TYPE_*`
+     * @param update_mass - if true, reset body mass data after the change
+     * @example
+     * ```ts
+     * const body = b2d.get_body("#collisionobject");
+     * const circle = b2d.fixture.get_shape(body, 1);
+     * circle.center = vmath.vector3(24, 0, 0);
+     * b2d.fixture.set_shape(body, 1, circle, true);
+     * b2d.fixture.set_shape(body, 2, { type: b2d.shape.SHAPE_TYPE_EDGE, v1: vmath.vector3(-32, 0, 0), v2: vmath.vector3(32, 0, 0) });
+     * ```
+     */
+    function set_shape(body: Opaque<"b2Body">, fixture_index: number, 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 }, update_mass: boolean): void;
+    /**
+     * Test a point against a fixture.
+     *
+     * @param body - body
+     * @param fixture_index - 1-based fixture index from `b2d.body.get_fixtures`
+     * @param point - point in world coordinates
+     */
+    function test_point(body: Opaque<"b2Body">, fixture_index: number, point: Vector3): boolean;
+  }
+}
+
+export {};