@defold-typescript/types 0.40.0 → 0.42.0

package/generated/buffer.d.ts

@@ -6,41 +6,44 @@ declare global {
    * Functions for manipulating buffers and streams
    */
   namespace buffer {
+    type buffer_data = Opaque<"buffer">;
+    type buffer_stream = Opaque<"bufferstream"> & { [index: number]: number; length: LuaLengthMethod<number> };
     type ValueType = typeof buffer.VALUE_TYPE_FLOAT32 | typeof buffer.VALUE_TYPE_INT16 | typeof buffer.VALUE_TYPE_INT32 | typeof buffer.VALUE_TYPE_INT64 | typeof buffer.VALUE_TYPE_INT8 | typeof buffer.VALUE_TYPE_UINT16 | typeof buffer.VALUE_TYPE_UINT32 | typeof buffer.VALUE_TYPE_UINT64 | typeof buffer.VALUE_TYPE_UINT8;
+    type VALUE_TYPE = typeof buffer.VALUE_TYPE_FLOAT32 | typeof buffer.VALUE_TYPE_INT16 | typeof buffer.VALUE_TYPE_INT32 | typeof buffer.VALUE_TYPE_INT64 | typeof buffer.VALUE_TYPE_INT8 | typeof buffer.VALUE_TYPE_UINT16 | typeof buffer.VALUE_TYPE_UINT32 | typeof buffer.VALUE_TYPE_UINT64 | typeof buffer.VALUE_TYPE_UINT8;
     /**
-     * Float, single precision, 4 bytes
+     * float32 Float, single precision, 4 bytes
      */
     const VALUE_TYPE_FLOAT32: number & { readonly __brand: "buffer.VALUE_TYPE_FLOAT32" };
     /**
-     * Signed integer, 2 bytes
+     * int16 Signed integer, 2 bytes
      */
     const VALUE_TYPE_INT16: number & { readonly __brand: "buffer.VALUE_TYPE_INT16" };
     /**
-     * Signed integer, 4 bytes
+     * int32 Signed integer, 4 bytes
      */
     const VALUE_TYPE_INT32: number & { readonly __brand: "buffer.VALUE_TYPE_INT32" };
     /**
-     * Signed integer, 8 bytes
+     * int64 Signed integer, 8 bytes
      */
     const VALUE_TYPE_INT64: number & { readonly __brand: "buffer.VALUE_TYPE_INT64" };
     /**
-     * Signed integer, 1 byte
+     * int8 Signed integer, 1 byte
      */
     const VALUE_TYPE_INT8: number & { readonly __brand: "buffer.VALUE_TYPE_INT8" };
     /**
-     * Unsigned integer, 2 bytes
+     * uint16 Unsigned integer, 2 bytes
      */
     const VALUE_TYPE_UINT16: number & { readonly __brand: "buffer.VALUE_TYPE_UINT16" };
     /**
-     * Unsigned integer, 4 bytes
+     * uint32 Unsigned integer, 4 bytes
      */
     const VALUE_TYPE_UINT32: number & { readonly __brand: "buffer.VALUE_TYPE_UINT32" };
     /**
-     * Unsigned integer, 8 bytes
+     * uint64 Unsigned integer, 8 bytes
      */
     const VALUE_TYPE_UINT64: number & { readonly __brand: "buffer.VALUE_TYPE_UINT64" };
     /**
-     * Unsigned integer, 1 byte
+     * uint8 Unsigned integer, 1 byte
      */
     const VALUE_TYPE_UINT8: number & { readonly __brand: "buffer.VALUE_TYPE_UINT8" };
     /**
@@ -102,9 +105,7 @@ declare global {
      * @param declaration - A table where each entry (table) describes a stream
      *
      * - hash | string `name`: The name of the stream
-     *
-     * - constant `type`: The data type of the stream
-     *
+     * - buffer.VALUE_TYPE `type`: The data type of the stream
      * - number `count`: The number of values each element should hold
      * @returns the new buffer
      * @example
@@ -131,7 +132,7 @@ declare global {
      * });
      * ```
      */
-    function create(element_count: number, declaration: { name?: Hash | string; type?: buffer.ValueType; count?: number }[]): Opaque<"buffer">;
+    function create(element_count: number, declaration: ({ name: Hash | string; type: buffer.VALUE_TYPE; count: number })[]): Opaque<"buffer">;
     /**
      * Get a copy of all the bytes from a specified stream as a Lua string.
      *
@@ -155,7 +156,7 @@ declare global {
      * if (values) print(`${values.length} values in 'somefloats'`);
      * ```
      */
-    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, buffer.ValueType | undefined]>;
+    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, buffer.VALUE_TYPE | undefined]>;
     /**
      * Get a specified stream from a buffer.
      *
@@ -184,7 +185,7 @@ declare global {
      * buffer.set_metadata(buf, hash("somefloats"), [-2.5, 10.0, 32.2], buffer.VALUE_TYPE_FLOAT32);
      * ```
      */
-    function set_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string, values: number[], value_type: buffer.ValueType): void;
+    function set_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string, values: number[], value_type: buffer.VALUE_TYPE): void;
   }
 }
 

package/generated/builtin-messages.d.ts

@@ -25,7 +25,10 @@ declare global {
     model_animation_done: { animation_id: Hash; playback: number };
     play_animation: { id: Hash };
     play_sound: { delay?: number; gain?: number; play_id?: number; start_time?: number; start_frame?: number };
+    proxy_error: { code: number };
     proxy_loaded: Record<string, never>;
+    proxy_loading: { progress: number };
+    proxy_ready: Record<string, never>;
     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 };
@@ -35,7 +38,7 @@ declare global {
     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_camera: { aspect_ratio: number; fov: number; near_z: number; far_z: number; orthographic_projection: number; 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 };
@@ -47,6 +50,9 @@ declare global {
     start_record: { file_name: string; frame_period: number; fps: number };
     stop_record: Record<string, never>;
     stop_sound: Record<string, never>;
+    text_object_clicked: { id: Hash; type: Hash; src: string };
+    text_object_hovered: { id: Hash; type: Hash; src: string };
+    text_object_unhovered: { id: Hash; type: Hash; src: string };
     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> };

package/generated/bullet3d.d.ts

@@ -0,0 +1,91 @@
+/** @noSelfInFile */
+import type { Hash, Opaque, Url } from "../src/core-types";
+
+declare global {
+  /**
+   * Native-style access to the Bullet 3D world and collision objects owned by
+   * Defold. World creation, destruction and stepping remain controlled by Defold.
+   * The backend name refers to three-dimensional physics.
+   *
+   * World, collision-object and rigid-body userdata are borrowed handles to
+   * Defold-owned objects. Shape userdata are borrowed logical child-slot handles
+   * attached to a collision object. Constraint userdata identify auxiliary native
+   * objects owned by this Lua API; destroy them explicitly when no longer needed.
+   * They are also destroyed automatically when a required body or world is
+   * destroyed.
+   *
+   * A collision-object, rigid-body or shape handle becomes invalid when its
+   * collision object is deleted or reloaded. A world handle remains valid across
+   * collision-object reloads, but becomes invalid when its collection and physics
+   * world are destroyed. The corresponding `is_valid()` function is safe for
+   * checking a retained handle; every other operation rejects an invalid handle.
+   */
+  namespace bullet3d {
+    type btCollisionObject = Opaque<"btCollisionObject" | "btRigidBody">;
+    type btDiscreteDynamicsWorld = Opaque<"btDiscreteDynamicsWorld">;
+    type btRigidBody = Opaque<"btRigidBody">;
+    /**
+     * Bullet version information
+     */
+    interface version_info {
+      /**
+       * full Bullet version string
+       */
+      version: string;
+      /**
+       * compact numeric Bullet version
+       */
+      number: number;
+      /**
+       * major version number
+       */
+      major: number;
+      /**
+       * minor version number
+       */
+      minor: number;
+    }
+    /**
+     * This returns both rigid bodies and ghost trigger objects.
+     * This function raises an error unless the collection uses 3D physics.
+     *
+     * @param url - collision object component URL
+     * @returns the collision object, or `nil`
+     */
+    function get_collision_object(url: string | Hash | Url): Opaque<"btCollisionObject" | "btRigidBody"> | undefined;
+    /**
+     * Trigger components are ghost objects, so this function returns `nil` for them.
+     * This function raises an error unless the collection uses 3D physics.
+     *
+     * @param url - collision object component URL
+     * @returns the rigid body handle, or `nil`
+     * @example
+     * ```ts
+     * const world = bullet3d.get_world();
+     * const body = bullet3d.get_rigid_body("#collisionobject");
+     * if (world !== undefined && body !== undefined && bullet3d.rigid_body.is_valid(body)) {
+     *   bullet3d.rigid_body.apply_central_impulse(body, vmath.vector3(0, 10, 0));
+     * }
+     *
+     * // A trigger is a collision object, not a rigid body.
+     * const trigger = bullet3d.get_collision_object("#trigger");
+     * assert(trigger !== undefined && bullet3d.get_rigid_body("#trigger") === undefined);
+     * ```
+     */
+    function get_rigid_body(url: string | Hash | Url): Opaque<"btRigidBody"> | undefined;
+    /**
+     * Get the Bullet version
+     *
+     * @returns version information
+     */
+    function get_version(): bullet3d.version_info;
+    /**
+     * This function raises an error unless the collection uses 3D physics.
+     *
+     * @returns the world, or `nil` if the collection has no physics world
+     */
+    function get_world(): bullet3d.btDiscreteDynamicsWorld | undefined;
+  }
+}
+
+export {};

package/generated/bullet3d_collision_object.d.ts

@@ -0,0 +1,433 @@
+/** @noSelfInFile */
+import type { Opaque, Quaternion, Vector3 } from "../src/core-types";
+
+declare global {
+  /**
+   * Functions shared by rigid bodies and trigger ghost objects. Defold keeps
+   * ownership of each object's user pointer, motion state, collision shape, and
+   * world membership. Logical child shapes are inspected and mutated through
+   * `bullet3d.shape`; ownership is not transferred to Lua.
+   *
+   * Positions, distances, and CCD thresholds use Defold units. Rotations,
+   * coefficients, flags, activation state, and time values use Bullet values.
+   * Floating-point and vector inputs must be finite. CCD radii and motion
+   * thresholds must also be non-negative.
+   */
+  namespace bullet3d.collision_object {
+    type ACTIVATION_STATE = typeof bullet3d.collision_object.ACTIVE_TAG | typeof bullet3d.collision_object.ISLAND_SLEEPING | typeof bullet3d.collision_object.WANTS_DEACTIVATION | typeof bullet3d.collision_object.DISABLE_DEACTIVATION | typeof bullet3d.collision_object.DISABLE_SIMULATION;
+    type COLLISION_FLAG = typeof bullet3d.collision_object.CF_DYNAMIC_OBJECT | typeof bullet3d.collision_object.CF_STATIC_OBJECT | typeof bullet3d.collision_object.CF_KINEMATIC_OBJECT | typeof bullet3d.collision_object.CF_NO_CONTACT_RESPONSE | typeof bullet3d.collision_object.CF_CUSTOM_MATERIAL_CALLBACK | typeof bullet3d.collision_object.CF_CHARACTER_OBJECT | typeof bullet3d.collision_object.CF_DISABLE_VISUALIZE_OBJECT | typeof bullet3d.collision_object.CF_DISABLE_SPU_COLLISION_PROCESSING;
+    type INTERNAL_TYPE = typeof bullet3d.collision_object.CO_COLLISION_OBJECT | typeof bullet3d.collision_object.CO_RIGID_BODY | typeof bullet3d.collision_object.CO_GHOST_OBJECT | typeof bullet3d.collision_object.CO_SOFT_BODY | typeof bullet3d.collision_object.CO_HF_FLUID;
+    /**
+     * Active simulation state.
+     */
+    const ACTIVE_TAG: number & { readonly __brand: "bullet3d.collision_object.ACTIVE_TAG" };
+    /**
+     * Character collision object flag.
+     */
+    const CF_CHARACTER_OBJECT: number & { readonly __brand: "bullet3d.collision_object.CF_CHARACTER_OBJECT" };
+    /**
+     * Custom material callback flag.
+     */
+    const CF_CUSTOM_MATERIAL_CALLBACK: number & { readonly __brand: "bullet3d.collision_object.CF_CUSTOM_MATERIAL_CALLBACK" };
+    /**
+     * Disable SPU collision processing flag.
+     */
+    const CF_DISABLE_SPU_COLLISION_PROCESSING: number & { readonly __brand: "bullet3d.collision_object.CF_DISABLE_SPU_COLLISION_PROCESSING" };
+    /**
+     * Disable debug visualization flag.
+     */
+    const CF_DISABLE_VISUALIZE_OBJECT: number & { readonly __brand: "bullet3d.collision_object.CF_DISABLE_VISUALIZE_OBJECT" };
+    /**
+     * Zero-valued default dynamic-object flag. Compare the complete collision-flags value with this constant; do not pass it to `has_collision_flag`, since zero is not a bit that can be tested.
+     */
+    const CF_DYNAMIC_OBJECT: number & { readonly __brand: "bullet3d.collision_object.CF_DYNAMIC_OBJECT" };
+    /**
+     * Kinematic collision object flag.
+     */
+    const CF_KINEMATIC_OBJECT: number & { readonly __brand: "bullet3d.collision_object.CF_KINEMATIC_OBJECT" };
+    /**
+     * Disable contact response flag.
+     */
+    const CF_NO_CONTACT_RESPONSE: number & { readonly __brand: "bullet3d.collision_object.CF_NO_CONTACT_RESPONSE" };
+    /**
+     * Static collision object flag.
+     */
+    const CF_STATIC_OBJECT: number & { readonly __brand: "bullet3d.collision_object.CF_STATIC_OBJECT" };
+    /**
+     * Generic collision object type.
+     */
+    const CO_COLLISION_OBJECT: number & { readonly __brand: "bullet3d.collision_object.CO_COLLISION_OBJECT" };
+    /**
+     * Ghost collision object type.
+     */
+    const CO_GHOST_OBJECT: number & { readonly __brand: "bullet3d.collision_object.CO_GHOST_OBJECT" };
+    /**
+     * Height-field fluid collision object type.
+     */
+    const CO_HF_FLUID: number & { readonly __brand: "bullet3d.collision_object.CO_HF_FLUID" };
+    /**
+     * Rigid body collision object type.
+     */
+    const CO_RIGID_BODY: number & { readonly __brand: "bullet3d.collision_object.CO_RIGID_BODY" };
+    /**
+     * Soft body collision object type.
+     */
+    const CO_SOFT_BODY: number & { readonly __brand: "bullet3d.collision_object.CO_SOFT_BODY" };
+    /**
+     * Disable automatic deactivation.
+     */
+    const DISABLE_DEACTIVATION: number & { readonly __brand: "bullet3d.collision_object.DISABLE_DEACTIVATION" };
+    /**
+     * Disable simulation.
+     */
+    const DISABLE_SIMULATION: number & { readonly __brand: "bullet3d.collision_object.DISABLE_SIMULATION" };
+    /**
+     * Sleeping simulation state.
+     */
+    const ISLAND_SLEEPING: number & { readonly __brand: "bullet3d.collision_object.ISLAND_SLEEPING" };
+    /**
+     * Wants-deactivation simulation state.
+     */
+    const WANTS_DEACTIVATION: number & { readonly __brand: "bullet3d.collision_object.WANTS_DEACTIVATION" };
+    /**
+     * Activate a collision object
+     *
+     * @param object - collision object
+     * @param force - force activation of a static or kinematic object; defaults to `false`
+     */
+    function activate(object: Opaque<"btCollisionObject" | "btRigidBody">, force?: boolean): void;
+    /**
+     * Force the activation state
+     *
+     * @param object - collision object
+     * @param state - activation state
+     */
+    function force_activation_state(object: Opaque<"btCollisionObject" | "btRigidBody">, state: bullet3d.collision_object.ACTIVATION_STATE): void;
+    /**
+     * Get the activation state
+     *
+     * @param object - collision object
+     * @returns activation state
+     */
+    function get_activation_state(object: Opaque<"btCollisionObject" | "btRigidBody">): bullet3d.collision_object.ACTIVATION_STATE;
+    /**
+     * Get the CCD motion threshold
+     *
+     * @param object - collision object
+     * @returns threshold in Defold units
+     */
+    function get_ccd_motion_threshold(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Get the CCD swept sphere radius
+     *
+     * @param object - collision object
+     * @returns radius in Defold units
+     */
+    function get_ccd_swept_sphere_radius(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Returns the raw unsigned 16-bit filter group that Defold assigned to the
+     * object's Bullet broadphase proxy. Use this value as `category_bits` in a
+     * `bullet3d.world` query filter. Bullet applies reciprocal filtering: the
+     * query's `mask_bits` must include this group, and the query's `category_bits`
+     * must be included in the object's filter mask.
+     *
+     * @param object - collision object in a Bullet world
+     * @returns raw unsigned 16-bit collision filter group
+     */
+    function get_collision_filter_group(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Returns the raw unsigned 16-bit filter mask that Defold assigned to the
+     * object's Bullet broadphase proxy. Use this value as `mask_bits` in a
+     * `bullet3d.world` query filter. Bullet applies reciprocal filtering: the
+     * query's `category_bits` must be included in this mask, and the query's
+     * `mask_bits` must include the object's filter group.
+     *
+     * @param object - collision object in a Bullet world
+     * @returns raw unsigned 16-bit collision filter mask
+     */
+    function get_collision_filter_mask(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Get collision flags
+     *
+     * @param object - collision object
+     * @returns bit field of `CF_*` constants
+     */
+    function get_collision_flags(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Get the contact processing threshold
+     *
+     * @param object - collision object
+     * @returns threshold in Defold units
+     */
+    function get_contact_processing_threshold(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Get deactivation time
+     *
+     * @param object - collision object
+     * @returns deactivation time
+     */
+    function get_deactivation_time(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Get friction
+     *
+     * @param object - collision object
+     * @returns friction coefficient
+     */
+    function get_friction(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Get the Bullet collision object type
+     *
+     * @param object - collision object
+     * @returns native collision object type
+     */
+    function get_internal_type(object: Opaque<"btCollisionObject" | "btRigidBody">): bullet3d.collision_object.INTERNAL_TYPE;
+    /**
+     * Get the world position
+     *
+     * @param object - collision object
+     * @returns world position in Defold units
+     */
+    function get_position(object: Opaque<"btCollisionObject" | "btRigidBody">): Vector3;
+    /**
+     * Get restitution
+     *
+     * @param object - collision object
+     * @returns restitution coefficient
+     */
+    function get_restitution(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Get the world rotation
+     *
+     * @param object - collision object
+     * @returns world rotation
+     */
+    function get_rotation(object: Opaque<"btCollisionObject" | "btRigidBody">): Quaternion;
+    /**
+     * Get one attached shape by one-based index.
+     *
+     * @param object - collision object
+     * @param shape_index - one-based shape index. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns borrowed logical shape handle
+     */
+    function get_shape(object: Opaque<"btCollisionObject" | "btRigidBody">, shape_index: number): bullet3d.shape.btCollisionShape;
+    /**
+     * Get the number of shapes attached to a collision object.
+     *
+     * @param object - collision object
+     * @returns shape count
+     */
+    function get_shape_count(object: Opaque<"btCollisionObject" | "btRigidBody">): number;
+    /**
+     * Get all attached shapes.
+     *
+     * @param object - collision object
+     * @returns array of borrowed shape handles
+     * @example
+     * ```ts
+     * // Enumerate the logical shapes attached to a collision object:
+     * export default defineScript({
+     *   init() {
+     *     const object = bullet3d.get_collision_object("#collisionobject");
+     *     if (object === undefined) return;
+     *     for (const shape of bullet3d.collision_object.get_shapes(object)) {
+     *       const index = bullet3d.shape.get_index(shape);
+     *       const data = bullet3d.shape.get_shape(shape);
+     *       print("shape", index, "type", data.type);
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function get_shapes(object: Opaque<"btCollisionObject" | "btRigidBody">): bullet3d.shape.btCollisionShape[];
+    /**
+     * Get the world transform
+     *
+     * @param object - collision object
+     */
+    function get_world_transform(object: Opaque<"btCollisionObject" | "btRigidBody">): LuaMultiReturn<[Vector3, Quaternion]>;
+    /**
+     * Test a collision flag
+     *
+     * @param object - collision object
+     * @param flag - collision flag or mask
+     * @returns `true` when all requested flag bits are set
+     */
+    function has_collision_flag(object: Opaque<"btCollisionObject" | "btRigidBody">, flag: number): boolean;
+    /**
+     * Test whether the object responds to contacts
+     *
+     * @param object - collision object
+     * @returns contact response state
+     */
+    function has_contact_response(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    /**
+     * This exposes Bullet's native `btCollisionObject::isActive` result. It is
+     * `false` for `ISLAND_SLEEPING` and `DISABLE_SIMULATION`, and `true` for the
+     * other activation states available to Defold collision objects. It is
+     * unrelated to whether the Defold component is enabled.
+     *
+     * @param object - collision object
+     * @returns active state
+     */
+    function is_active(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    /**
+     * Box2D-style name for the same simulation state returned by
+     * bullet3d.collision_object.is_active.
+     *
+     * @param object - collision object
+     * @returns `false` when sleeping or simulation is disabled
+     */
+    function is_awake(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    /**
+     * Test whether the object is a ghost trigger
+     *
+     * @param object - collision object
+     * @returns ghost object state
+     */
+    function is_ghost_object(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    /**
+     * Test whether the object is kinematic
+     *
+     * @param object - collision object
+     * @returns kinematic state
+     */
+    function is_kinematic(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    /**
+     * Test whether the object is a rigid body
+     *
+     * @param object - collision object
+     * @returns rigid body state
+     */
+    function is_rigid_body(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    /**
+     * Test whether the object is static
+     *
+     * @param object - collision object
+     * @returns static state
+     */
+    function is_static(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    /**
+     * Test whether the object is static or kinematic
+     *
+     * @param object - collision object
+     * @returns static or kinematic state
+     */
+    function is_static_or_kinematic(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    /**
+     * Test whether a collision object handle is valid
+     *
+     * @param object - collision object
+     * @returns `true` if the native object still exists
+     */
+    function is_valid(object: Opaque<"btCollisionObject" | "btRigidBody">): boolean;
+    /**
+     * Set the activation state
+     *
+     * @param object - collision object
+     * @param state - activation state
+     */
+    function set_activation_state(object: Opaque<"btCollisionObject" | "btRigidBody">, state: bullet3d.collision_object.ACTIVATION_STATE): void;
+    /**
+     * Passing `true` calls Bullet's `activate()`. Passing `false` requests the
+     * native `ISLAND_SLEEPING` state. As in Bullet, static or kinematic objects are
+     * not activated without force, and protected `DISABLE_DEACTIVATION` or
+     * `DISABLE_SIMULATION` states are not replaced by a sleeping request.
+     *
+     * @param object - collision object
+     * @param awake - requested awake state
+     */
+    function set_awake(object: Opaque<"btCollisionObject" | "btRigidBody">, awake: boolean): void;
+    /**
+     * Set the CCD motion threshold
+     *
+     * @param object - collision object
+     * @param threshold - finite non-negative threshold in Defold units
+     * @example
+     * ```ts
+     * // Enable continuous collision detection for a small, fast-moving body:
+     * export default defineScript({
+     *   init() {
+     *     const body = bullet3d.get_rigid_body("#collisionobject");
+     *     if (body === undefined) return;
+     *     bullet3d.collision_object.set_ccd_swept_sphere_radius(body, 0.25);
+     *     bullet3d.collision_object.set_ccd_motion_threshold(body, 0.5);
+     *   },
+     * });
+     * ```
+     */
+    function set_ccd_motion_threshold(object: Opaque<"btCollisionObject" | "btRigidBody">, threshold: number): void;
+    /**
+     * Set the CCD swept sphere radius
+     *
+     * @param object - collision object
+     * @param radius - finite non-negative radius in Defold units
+     */
+    function set_ccd_swept_sphere_radius(object: Opaque<"btCollisionObject" | "btRigidBody">, radius: number): void;
+    /**
+     * Set the contact processing threshold
+     *
+     * @param object - collision object
+     * @param threshold - finite threshold in Defold units
+     */
+    function set_contact_processing_threshold(object: Opaque<"btCollisionObject" | "btRigidBody">, threshold: number): void;
+    /**
+     * Set deactivation time
+     *
+     * @param object - collision object
+     * @param seconds - finite deactivation time
+     */
+    function set_deactivation_time(object: Opaque<"btCollisionObject" | "btRigidBody">, seconds: number): void;
+    /**
+     * Set friction
+     *
+     * @param object - collision object
+     * @param friction - finite friction coefficient
+     */
+    function set_friction(object: Opaque<"btCollisionObject" | "btRigidBody">, friction: number): void;
+    /**
+     * The owning game object's position is updated as well.
+     *
+     * @param object - collision object
+     * @param position - finite world position in Defold units
+     */
+    function set_position(object: Opaque<"btCollisionObject" | "btRigidBody">, position: Vector3): void;
+    /**
+     * Set restitution
+     *
+     * @param object - collision object
+     * @param restitution - finite restitution coefficient
+     */
+    function set_restitution(object: Opaque<"btCollisionObject" | "btRigidBody">, restitution: number): void;
+    /**
+     * The owning game object's rotation is updated as well.
+     *
+     * @param object - collision object
+     * @param rotation - finite, non-zero world rotation; normalized by the binding
+     */
+    function set_rotation(object: Opaque<"btCollisionObject" | "btRigidBody">, rotation: Quaternion): void;
+    /**
+     * The owning game object's position and rotation are updated as well, so the
+     * transform persists when Defold synchronizes game objects into Bullet.
+     *
+     * @param object - collision object
+     * @param position - finite world position in Defold units
+     * @param rotation - finite, non-zero world rotation; normalized by the binding
+     * @example
+     * ```ts
+     * // Move a collision object while preserving its rotation:
+     * export default defineScript({
+     *   init() {
+     *     const object = bullet3d.get_collision_object("#collisionobject");
+     *     if (object === undefined) return;
+     *     const [position, rotation] = bullet3d.collision_object.get_world_transform(object);
+     *     bullet3d.collision_object.set_world_transform(object, position.add(vmath.vector3(0, 5, 0)), rotation);
+     *     bullet3d.collision_object.activate(object, true);
+     *   },
+     * });
+     * ```
+     */
+    function set_world_transform(object: Opaque<"btCollisionObject" | "btRigidBody">, position: Vector3, rotation: Quaternion): void;
+  }
+}
+
+export {};