goudengine 0.0.828 → 0.0.830

package/dist/web/generated/types/engine.g.d.ts

@@ -1,3 +1,4 @@
+import type { PhysicsBackend2D } from './input.g.js';
 /** 2D floating-point vector */
 export interface IVec2 {
     x: number;
@@ -38,6 +39,22 @@ export interface IContact {
     normalY: number;
     penetration: number;
 }
+/** Detailed payload for a 2D physics raycast hit */
+export interface IPhysicsRaycastHit2D {
+    bodyHandle: number;
+    colliderHandle: number;
+    pointX: number;
+    pointY: number;
+    normalX: number;
+    normalY: number;
+    distance: number;
+}
+/** 2D collision event payload from the physics event queue */
+export interface IPhysicsCollisionEvent2D {
+    bodyA: number;
+    bodyB: number;
+    kind: number;
+}
 /** Frame timing statistics from the debug overlay rolling window */
 export interface IFpsStats {
     currentFps: number;
@@ -46,6 +63,107 @@ export interface IFpsStats {
     avgFps: number;
     frameTimeMs: number;
 }
+/** Pre-init debugger runtime configuration for desktop contexts. */
+export interface IDebuggerConfig {
+    enabled: boolean;
+    publishLocalAttach: boolean;
+    routeLabel: string;
+}
+/** Pre-init configuration for headless context creation. */
+export interface IContextConfig {
+    debugger: IDebuggerConfig;
+}
+/** Tracked current and peak bytes for one debugger memory category. */
+export interface IMemoryCategoryStats {
+    currentBytes: number;
+    peakBytes: number;
+}
+/** Debugger-owned aggregate memory summary for one route. */
+export interface IMemorySummary {
+    rendering: IMemoryCategoryStats;
+    assets: IMemoryCategoryStats;
+    ecs: IMemoryCategoryStats;
+    ui: IMemoryCategoryStats;
+    audio: IMemoryCategoryStats;
+    network: IMemoryCategoryStats;
+    debugger: IMemoryCategoryStats;
+    other: IMemoryCategoryStats;
+    totalCurrentBytes: number;
+    totalPeakBytes: number;
+}
+/** Debugger frame capture artifact envelope returned directly by SDK calls. */
+export interface IDebuggerCapture {
+    imagePng: Uint8Array;
+    metadataJson: string;
+    snapshotJson: string;
+    metricsTraceJson: string;
+}
+/** Debugger replay recording artifact envelope returned directly by SDK calls. */
+export interface IDebuggerReplayArtifact {
+    manifestJson: string;
+    data: Uint8Array;
+}
+/** Aggregate network statistics for a network handle */
+export interface INetworkStats {
+    bytesSent: number;
+    bytesReceived: number;
+    packetsSent: number;
+    packetsReceived: number;
+    packetsLost: number;
+    rttMs: number;
+    sendBandwidthBytesPerSec: number;
+    receiveBandwidthBytesPerSec: number;
+    packetLossPercent: number;
+    jitterMs: number;
+}
+/** Debug-only network simulation settings for a network handle */
+export interface INetworkSimulationConfig {
+    oneWayLatencyMs: number;
+    jitterMs: number;
+    packetLossPercent: number;
+}
+/** Peer-preserving connection result returned by networkConnectWithPeer */
+export interface INetworkConnectResult {
+    handle: number;
+    peerId: number;
+}
+/** Inbound network payload with the sender peer ID preserved */
+export interface INetworkPacket {
+    peerId: number;
+    data: Uint8Array;
+}
+/** Capabilities reported by the active render provider */
+export interface IRenderCapabilities {
+    maxTextureUnits: number;
+    maxTextureSize: number;
+    supportsInstancing: boolean;
+    supportsCompute: boolean;
+    supportsMsaa: boolean;
+}
+/** Capabilities reported by the active physics provider */
+export interface IPhysicsCapabilities {
+    supportsContinuousCollision: boolean;
+    supportsJoints: boolean;
+    maxBodies: number;
+}
+/** Capabilities reported by the active audio provider */
+export interface IAudioCapabilities {
+    supportsSpatial: boolean;
+    maxChannels: number;
+}
+/** Capabilities reported by the active input provider */
+export interface IInputCapabilities {
+    supportsGamepad: boolean;
+    supportsTouch: boolean;
+    maxGamepads: number;
+}
+/** Capabilities reported by the active network provider */
+export interface INetworkCapabilities {
+    supportsHosting: boolean;
+    maxConnections: number;
+    maxChannels: number;
+    maxMessageSize: number;
+}
 /** Opaque handle to an ECS entity */
 export interface IEntity {
     readonly index: number;
@@ -81,6 +199,42 @@ export interface ISpriteData {
     customSizeY: number;
     hasCustomSize: boolean;
 }
+/** C-safe UI style payload for node-level visual overrides. */
+export interface IUiStyle {
+    backgroundColor?: IColor;
+    foregroundColor?: IColor;
+    borderColor?: IColor;
+    borderWidth?: number;
+    fontFamily?: string;
+    fontSize?: number;
+    texturePath?: string;
+    widgetSpacing?: number;
+}
+export type UiNodeId = number | bigint;
+/** UI event payload returned by deterministic polling APIs. */
+export interface IUiEvent {
+    eventKind: number;
+    nodeId: UiNodeId;
+    previousNodeId: UiNodeId;
+    currentNodeId: UiNodeId;
+}
+export type PreloadAssetKind = 'texture' | 'font';
+export interface IPreloadAssetRequest {
+    path: string;
+    kind?: PreloadAssetKind;
+}
+export interface IPreloadProgress {
+    loaded: number;
+    total: number;
+    progress: number;
+    path: string;
+    kind: PreloadAssetKind;
+    handle: number;
+}
+export interface IPreloadOptions {
+    onProgress?: (update: IPreloadProgress) => void;
+}
+export type PreloadAssetInput = string | IPreloadAssetRequest;
 /** Main game engine instance. Creates a window, manages rendering, input, and ECS. */
 export interface IGoudGame {
     /** Seconds elapsed since last frame */
@@ -113,6 +267,12 @@ export interface IGoudGame {
     loadTexture(path: string): Promise<number>;
     /** Destroys a previously loaded texture */
     destroyTexture(handle: number): void;
+    /** Loads a font from a file path and returns its handle */
+    loadFont(path: string): Promise<number>;
+    /** Destroys a previously loaded font */
+    destroyFont(handle: number): boolean;
+    /** Draws text using a loaded font */
+    drawText(fontHandle: number, text: string, x: number, y: number, fontSize?: number, alignment?: number, maxWidth?: number, lineSpacing?: number, direction?: number, color?: IColor): boolean;
     /** Draws a textured sprite */
     drawSprite(texture: number, x: number, y: number, width: number, height: number, rotation?: number, color?: IColor): void;
     /** Draws a colored rectangle */
@@ -179,6 +339,16 @@ export interface IGoudGame {
     spawnBatch(count: number): IEntity[];
     /** Despawns multiple entities at once */
     despawnBatch(entities: IEntity[]): number;
+    /** Starts animation playback for an entity */
+    play(entity: IEntity): number;
+    /** Stops animation playback for an entity */
+    stop(entity: IEntity): number;
+    /** Sets the active animation state for an entity */
+    setState(entity: IEntity, stateName: string): number;
+    /** Sets a boolean animation parameter for an entity */
+    setParameterBool(entity: IEntity, name: string, value: boolean): number;
+    /** Sets a float animation parameter for an entity */
+    setParameterFloat(entity: IEntity, name: string, value: number): number;
     /** Creates a 3D cube */
     createCube(textureId: number, width: number, height: number, depth: number): number;
     /** Creates a 3D plane */
@@ -239,6 +409,48 @@ export interface IGoudGame {
     setFpsUpdateInterval(interval: number): void;
     /** Sets the screen corner where the FPS overlay is displayed */
     setFpsOverlayCorner(corner: number): void;
+    /** Returns the latest debugger snapshot JSON for this route. */
+    getDebuggerSnapshotJson(): string;
+    /** Returns the current process-wide debugger manifest JSON. */
+    getDebuggerManifestJson(): string;
+    /** Pauses or resumes the route-scoped debugger runtime. */
+    setDebuggerPaused(paused: boolean): void;
+    /** Consumes debugger-controlled frame or tick step budget for this route. */
+    stepDebugger(kind: number, count: number): void;
+    /** Sets the debugger-owned time-scale multiplier for this route. */
+    setDebuggerTimeScale(scale: number): void;
+    /** Enables or disables runtime-owned debug draw for this route. */
+    setDebuggerDebugDrawEnabled(enabled: boolean): void;
+    /** Queues one normalized keyboard event through the debugger control plane. */
+    injectDebuggerKeyEvent(key: number, pressed: boolean): void;
+    /** Queues one normalized mouse-button event through the debugger control plane. */
+    injectDebuggerMouseButton(button: number, pressed: boolean): void;
+    /** Queues one normalized mouse-position event through the debugger control plane. */
+    injectDebuggerMousePosition(position: IVec2): void;
+    /** Queues one normalized scroll event through the debugger control plane. */
+    injectDebuggerScroll(delta: IVec2): void;
+    /** Enables or disables per-system debugger profiling for this route. */
+    setDebuggerProfilingEnabled(enabled: boolean): void;
+    /** Selects one entity for expanded debugger inspector output. */
+    setDebuggerSelectedEntity(entityId: number): void;
+    /** Clears the selected debugger inspector entity for this route. */
+    clearDebuggerSelectedEntity(): void;
+    /** Returns debugger-owned aggregate memory statistics for this route. */
+    getMemorySummary(): IMemorySummary;
+    /** Captures the current frame plus debugger-owned metadata attachments for this route. */
+    captureDebuggerFrame(): IDebuggerCapture;
+    /** Starts debugger-owned normalized input recording for this route. */
+    startDebuggerRecording(): void;
+    /** Stops debugger-owned recording and returns the exported replay artifact. */
+    stopDebuggerRecording(): IDebuggerReplayArtifact;
+    /** Starts debugger-owned replay using previously exported recording bytes. */
+    startDebuggerReplay(recording: Uint8Array): void;
+    /** Stops any active debugger-owned replay session for this route. */
+    stopDebuggerReplay(): void;
+    /** Returns the current debugger replay status JSON for this route. */
+    getDebuggerReplayStatusJson(): string;
+    /** Returns the current debugger metrics-trace JSON for this route. */
+    getDebuggerMetricsTraceJson(): string;
     /** Maps an action name to a key */
     mapActionKey(action: string, key: number): boolean;
     /** Returns true if the action is currently pressed */
@@ -265,6 +477,169 @@ export interface IGoudGame {
     distance(x1: number, y1: number, x2: number, y2: number): number;
     /** Squared distance between two points */
     distanceSquared(x1: number, y1: number, x2: number, y2: number): number;
+    /** Casts a filtered ray and returns the full hit payload, or null when no hit is found (FFI: goud_physics_raycast_ex) */
+    physicsRaycastEx(originX: number, originY: number, dirX: number, dirY: number, maxDist: number, layerMask: number): IPhysicsRaycastHit2D | null;
+    /** Returns the number of queued physics collision events available to read (FFI: goud_physics_collision_events_count) */
+    physicsCollisionEventsCount(): number;
+    /** Reads one queued physics collision event by index, or null when the index is out of range (FFI: goud_physics_collision_events_read) */
+    physicsCollisionEventsRead(index: number): IPhysicsCollisionEvent2D | null;
+    /** Registers or clears a physics collision callback function pointer. C# callers must keep the callback delegate alive for the full registration lifetime. Python and TypeScript wrappers support clear-only (`callbackPtr = 0`, `userData = 0`) for safety. (FFI: goud_physics_set_collision_callback) */
+    physicsSetCollisionCallback(callbackPtr: number, userData: number): number;
+    /** Queries the render provider's capabilities */
+    getRenderCapabilities(): IRenderCapabilities;
+    /** Queries the physics provider's capabilities */
+    getPhysicsCapabilities(): IPhysicsCapabilities;
+    /** Queries the audio provider's capabilities */
+    getAudioCapabilities(): IAudioCapabilities;
+    /** Queries the input provider's capabilities */
+    getInputCapabilities(): IInputCapabilities;
+    /** Queries the network provider's capabilities. Throws if no network provider is installed. */
+    getNetworkCapabilities(): INetworkCapabilities;
+    /** Starts hosting on the given port with the selected transport protocol. */
+    networkHost(protocol: number, port: number): number;
+    /** Connects to a remote host with the selected transport protocol. */
+    networkConnect(protocol: number, address: string, port: number): number;
+    /** Connects to a remote host with the selected transport protocol and preserves the provider-assigned peer ID. */
+    networkConnectWithPeer(protocol: number, address: string, port: number): INetworkConnectResult;
+    /** Disconnects a network host or connection handle. */
+    networkDisconnect(handle: number): number;
+    /** Sends raw bytes to the given peer over a network handle and channel. */
+    networkSend(handle: number, peerId: number, data: Uint8Array, channel: number): number;
+    /** Receives the next buffered payload produced by networkPoll. */
+    networkReceive(handle: number): Uint8Array;
+    /** Receives the next buffered payload produced by networkPoll and preserves the sender peer ID. */
+    networkReceivePacket(handle: number): INetworkPacket | null;
+    /** Polls the network handle and buffers inbound messages for retrieval. */
+    networkPoll(handle: number): number;
+    /** Returns aggregate network statistics for a network handle. */
+    getNetworkStats(handle: number): INetworkStats;
+    /** Returns the number of connected peers for a network handle. */
+    networkPeerCount(handle: number): number;
+    /** Applies debug-only latency, jitter, and packet-loss simulation to a network handle. */
+    setNetworkSimulation(handle: number, config: INetworkSimulationConfig): number;
+    /** Clears debug-only network simulation settings from a network handle. */
+    clearNetworkSimulation(handle: number): number;
+    /** Overrides the active network handle displayed by the native debug overlay for this context. */
+    setNetworkOverlayHandle(handle: number): number;
+    /** Clears the explicit network-overlay handle override for this context. */
+    clearNetworkOverlayHandle(): number;
+    /** Plays audio from raw bytes on the default channel */
+    audioPlay(data: Uint8Array): number;
+    /** Plays audio from raw bytes on the given channel */
+    audioPlayOnChannel(data: Uint8Array, channel: number): number;
+    /** Plays audio with explicit volume, speed, looping, and channel settings */
+    audioPlayWithSettings(data: Uint8Array, volume: number, speed: number, looping: boolean, channel: number): number;
+    /** Stops a playing audio player */
+    audioStop(playerId: number): number;
+    /** Pauses a playing audio player */
+    audioPause(playerId: number): number;
+    /** Resumes a paused audio player */
+    audioResume(playerId: number): number;
+    /** Stops all active audio players */
+    audioStopAll(): number;
+    /** Sets the global audio volume */
+    audioSetGlobalVolume(volume: number): number;
+    /** Gets the global audio volume */
+    audioGetGlobalVolume(): number;
+    /** Sets the volume for a specific channel */
+    audioSetChannelVolume(channel: number, volume: number): number;
+    /** Gets the volume for a specific channel */
+    audioGetChannelVolume(channel: number): number;
+    /** Returns non-zero when the player is still playing */
+    audioIsPlaying(playerId: number): number;
+    /** Returns the number of active audio players */
+    audioActiveCount(): number;
+    /** Cleans up finished audio players */
+    audioCleanupFinished(): number;
+    /** Plays audio with 3D spatial attenuation */
+    audioPlaySpatial3d(data: Uint8Array, sourceX: number, sourceY: number, sourceZ: number, listenerX: number, listenerY: number, listenerZ: number, maxDistance: number, rolloff: number): number;
+    /** Updates 3D spatial attenuation for an active player */
+    audioUpdateSpatial3d(playerId: number, sourceX: number, sourceY: number, sourceZ: number, listenerX: number, listenerY: number, listenerZ: number, maxDistance: number, rolloff: number): number;
+    /** Sets the 3D listener position */
+    audioSetListenerPosition3d(x: number, y: number, z: number): number;
+    /** Sets the 3D source position for an active player */
+    audioSetSourcePosition3d(playerId: number, x: number, y: number, z: number, maxDistance: number, rolloff: number): number;
+    /** Sets the volume for an active player */
+    audioSetPlayerVolume(playerId: number, volume: number): number;
+    /** Sets the playback speed for an active player */
+    audioSetPlayerSpeed(playerId: number, speed: number): number;
+    /** Applies an immediate crossfade mix between two active players */
+    audioCrossfade(fromPlayerId: number, toPlayerId: number, mix: number): number;
+    /** Starts a timed crossfade from one player to a new audio asset */
+    audioCrossfadeTo(fromPlayerId: number, data: Uint8Array, durationSec: number, channel: number): number;
+    /** Mixes a secondary audio asset with a primary player */
+    audioMixWith(primaryPlayerId: number, data: Uint8Array, secondaryVolume: number, secondaryChannel: number): number;
+    /** Advances all active timed crossfades */
+    audioUpdateCrossfades(deltaSec: number): number;
+    /** Returns the number of active timed crossfades */
+    audioActiveCrossfadeCount(): number;
+    /** Activates audio playback on platforms that require user gesture initialization */
+    audioActivate(): number;
+    /** Checks if the hot-swap keyboard shortcut (F5) was pressed and cycles the render provider to null. Debug builds only. Returns true if a swap occurred. */
+    checkHotSwapShortcut(): boolean;
+    /** Preloads textures/fonts before `run()` starts and reports coarse per-asset progress. */
+    preload(assets: PreloadAssetInput[], options?: IPreloadOptions): Promise<Record<string, number>>;
+    animationLayerStackCreate(entity: IEntity): number;
+    animationLayerAdd(entity: IEntity, name: string, blendMode: number): number;
+    animationLayerSetWeight(entity: IEntity, layerIndex: number, weight: number): number;
+    animationLayerPlay(entity: IEntity, layerIndex: number): number;
+    animationLayerSetClip(entity: IEntity, layerIndex: number, frameCount: number, frameDuration: number, mode: number): number;
+    animationLayerAddFrame(entity: IEntity, layerIndex: number, x: number, y: number, w: number, h: number): number;
+    animationLayerReset(entity: IEntity, layerIndex: number): number;
+    animationClipAddEvent(entity: IEntity, frameIndex: number, name: string, payloadType: number, payloadInt: number, payloadFloat: number, payloadString?: string | null): number;
+    animationEventsCount(): number;
+    animationEventsRead(index: number): IAnimationEventData;
+}
+/** Headless engine context exposing low-level networking APIs for Node-only tests. */
+export interface IGoudContext {
+    destroy(): boolean;
+    isValid(): boolean;
+    getNetworkCapabilities(): INetworkCapabilities;
+    networkHost(protocol: number, port: number): number;
+    networkConnect(protocol: number, address: string, port: number): number;
+    networkConnectWithPeer(protocol: number, address: string, port: number): INetworkConnectResult;
+    networkDisconnect(handle: number): number;
+    networkSend(handle: number, peerId: number, data: Uint8Array, channel: number): number;
+    networkReceive(handle: number): Uint8Array;
+    networkReceivePacket(handle: number): INetworkPacket | null;
+    networkPoll(handle: number): number;
+    getNetworkStats(handle: number): INetworkStats;
+    networkPeerCount(handle: number): number;
+    setNetworkSimulation(handle: number, config: INetworkSimulationConfig): number;
+    clearNetworkSimulation(handle: number): number;
+    setNetworkOverlayHandle(handle: number): number;
+    clearNetworkOverlayHandle(): number;
+    getDebuggerSnapshotJson(): string;
+    getDebuggerManifestJson(): string;
+    setDebuggerPaused(paused: boolean): void;
+    stepDebugger(kind: number, count: number): void;
+    setDebuggerTimeScale(scale: number): void;
+    setDebuggerDebugDrawEnabled(enabled: boolean): void;
+    injectDebuggerKeyEvent(key: number, pressed: boolean): void;
+    injectDebuggerMouseButton(button: number, pressed: boolean): void;
+    injectDebuggerMousePosition(position: IVec2): void;
+    injectDebuggerScroll(delta: IVec2): void;
+    setDebuggerProfilingEnabled(enabled: boolean): void;
+    setDebuggerSelectedEntity(entityId: number): void;
+    clearDebuggerSelectedEntity(): void;
+    getMemorySummary(): IMemorySummary;
+    captureDebuggerFrame(): IDebuggerCapture;
+    startDebuggerRecording(): void;
+    stopDebuggerRecording(): IDebuggerReplayArtifact;
+    startDebuggerReplay(recording: Uint8Array): void;
+    stopDebuggerReplay(): void;
+    getDebuggerReplayStatusJson(): string;
+    getDebuggerMetricsTraceJson(): string;
+}
+/** Data for a fired animation event */
+export interface IAnimationEventData {
+    entity: number;
+    name: string;
+    frameIndex: number;
+    payloadType: number;
+    payloadInt: number;
+    payloadFloat: number;
+    payloadString: string;
 }
 /** Builder for configuring and creating a GoudGame instance with provider selection. */
 export interface IEngineConfig {
@@ -280,9 +655,175 @@ export interface IEngineConfig {
     setTargetFps(fps: number): IEngineConfig;
     /** Enables or disables the FPS debug overlay */
     setFpsOverlay(enabled: boolean): IEngineConfig;
+    /** Enables or disables physics debug visualization */
+    setPhysicsDebug(enabled: boolean): IEngineConfig;
+    /** Selects the 2D physics backend used by the built game */
+    setPhysicsBackend2D(backend: PhysicsBackend2D): IEngineConfig;
+    /** Configures debugger runtime startup for the created game. */
+    setDebugger(debuggerConfig: IDebuggerConfig): IEngineConfig;
     /** Consumes the config and creates a windowed GoudGame instance */
     build(): IGoudGame;
     /** Frees the config without building */
     destroy(): void;
 }
+/** 2D physics simulation powered by Rapier2D */
+export interface IPhysicsWorld2D {
+    /** Creates a 2D physics world with given gravity */
+    create(gravityX: number, gravityY: number): number;
+    /** Creates a 2D physics world with explicit backend selection */
+    createWithBackend(gravityX: number, gravityY: number, backend: PhysicsBackend2D): number;
+    /** Destroys the 2D physics world */
+    destroy(): number;
+    /** Sets the gravity vector */
+    setGravity(x: number, y: number): number;
+    /** Adds a rigid body and returns its handle */
+    addRigidBody(bodyType: number, x: number, y: number, gravityScale: number): number;
+    /** Adds a rigid body with explicit CCD control and returns its handle (FFI: goud_physics_add_rigid_body_ex) */
+    addRigidBodyEx(bodyType: number, x: number, y: number, gravityScale: number, ccdEnabled: boolean): number;
+    /** Adds a collider to a rigid body */
+    addCollider(bodyHandle: number, shapeType: number, width: number, height: number, radius: number, friction: number, restitution: number): number;
+    /** Adds a collider with sensor and collision-layer configuration (FFI: goud_physics_add_collider_ex) */
+    addColliderEx(bodyHandle: number, shapeType: number, width: number, height: number, radius: number, friction: number, restitution: number, isSensor: boolean, layer: number, mask: number): number;
+    /** Removes a rigid body from the simulation */
+    removeBody(handle: number): number;
+    /** Creates a joint between two bodies and returns its handle (FFI: goud_physics_create_joint) */
+    createJoint(bodyA: number, bodyB: number, kind: number, anchorAx: number, anchorAy: number, anchorBx: number, anchorBy: number, axisX: number, axisY: number, hasLimits: boolean, limitMin: number, limitMax: number, hasMotor: boolean, motorTargetVelocity: number, motorMaxForce: number): number;
+    /** Removes a joint from the simulation (FFI: goud_physics_remove_joint) */
+    removeJoint(handle: number): number;
+    /** Steps the physics simulation */
+    step(dt: number): number;
+    /** Gets the position of a rigid body */
+    getPosition(handle: number): IVec2;
+    /** Gets the velocity of a rigid body */
+    getVelocity(handle: number): IVec2;
+    /** Sets the velocity of a rigid body */
+    setVelocity(handle: number, vx: number, vy: number): number;
+    /** Applies a force to a rigid body */
+    applyForce(handle: number, fx: number, fy: number): number;
+    /** Applies an impulse to a rigid body */
+    applyImpulse(handle: number, ix: number, iy: number): number;
+    /** Casts a ray and returns the hit point */
+    raycast(originX: number, originY: number, dirX: number, dirY: number, maxDist: number): IVec2;
+    /** Casts a ray and returns the full raycast hit payload (FFI: goud_physics_raycast_ex) */
+    raycastEx(originX: number, originY: number, dirX: number, dirY: number, maxDist: number, layerMask: number): IPhysicsRaycastHit2D;
+    /** Returns the number of queued collision events available to read (FFI: goud_physics_collision_events_count) */
+    collisionEventsCount(): number;
+    /** Reads one queued collision event by index; kind is 0 = Enter, 1 = Stay, 2 = Exit (FFI: goud_physics_collision_events_read) */
+    collisionEventsRead(index: number): IPhysicsCollisionEvent2D;
+    /** Backward-compatible alias for collisionEventsCount (FFI: goud_physics_collision_event_count) */
+    collisionEventCount(): number;
+    /** Backward-compatible alias for collisionEventsRead (FFI: goud_physics_collision_event_read) */
+    collisionEventRead(index: number): IPhysicsCollisionEvent2D;
+    /** Registers or clears a collision callback function pointer. Keep callback storage alive for the full registration lifetime. In safety-restricted wrappers (Python/TypeScript), pass 0 for callbackPtr and userData to clear. (FFI: goud_physics_set_collision_callback) */
+    setCollisionCallback(callbackPtr: number, userData: number): number;
+    /** Gets the current gravity vector */
+    getGravity(): IVec2;
+    /** Sets the gravity scale for a rigid body */
+    setBodyGravityScale(handle: number, scale: number): number;
+    /** Gets the gravity scale for a rigid body */
+    getBodyGravityScale(handle: number): number;
+    /** Sets the friction coefficient for a collider */
+    setColliderFriction(handle: number, friction: number): number;
+    /** Gets the friction coefficient for a collider */
+    getColliderFriction(handle: number): number;
+    /** Sets the restitution (bounciness) for a collider */
+    setColliderRestitution(handle: number, restitution: number): number;
+    /** Gets the restitution (bounciness) for a collider */
+    getColliderRestitution(handle: number): number;
+    /** Set the fixed physics timestep in seconds */
+    setTimestep(dt: number): number;
+    /** Get the current fixed physics timestep in seconds */
+    getTimestep(): number;
+}
+/** 3D physics simulation powered by Rapier3D */
+export interface IPhysicsWorld3D {
+    /** Creates a 3D physics world with given gravity */
+    create(gravityX: number, gravityY: number, gravityZ: number): number;
+    /** Destroys the 3D physics world */
+    destroy(): number;
+    /** Sets the gravity vector */
+    setGravity(x: number, y: number, z: number): number;
+    /** Adds a rigid body and returns its handle */
+    addRigidBody(bodyType: number, x: number, y: number, z: number, gravityScale: number): number;
+    /** Adds a rigid body with explicit CCD control and returns its handle (FFI: goud_physics3d_add_rigid_body_ex) */
+    addRigidBodyEx(bodyType: number, x: number, y: number, z: number, gravityScale: number, ccdEnabled: boolean): number;
+    /** Adds a collider to a rigid body */
+    addCollider(bodyHandle: number, shapeType: number, hx: number, hy: number, hz: number, radius: number, friction: number, restitution: number): number;
+    /** Removes a rigid body from the simulation */
+    removeBody(handle: number): number;
+    /** Creates a 3D joint between two bodies and returns its handle (FFI: goud_physics3d_create_joint) */
+    createJoint(bodyA: number, bodyB: number, kind: number, anchorAx: number, anchorAy: number, anchorAz: number, anchorBx: number, anchorBy: number, anchorBz: number, axisX: number, axisY: number, axisZ: number, hasLimits: boolean, limitMin: number, limitMax: number, hasMotor: boolean, motorTargetVelocity: number, motorMaxForce: number): number;
+    /** Removes a 3D joint from the simulation (FFI: goud_physics3d_remove_joint) */
+    removeJoint(handle: number): number;
+    /** Steps the physics simulation */
+    step(dt: number): number;
+    /** Gets the position of a rigid body */
+    getPosition(handle: number): IVec3;
+    /** Sets the velocity of a rigid body */
+    setVelocity(handle: number, vx: number, vy: number, vz: number): number;
+    /** Applies a force to a rigid body */
+    applyForce(handle: number, fx: number, fy: number, fz: number): number;
+    /** Applies an impulse to a rigid body */
+    applyImpulse(handle: number, ix: number, iy: number, iz: number): number;
+    /** Gets the current gravity vector */
+    getGravity(): IVec3;
+    /** Sets the gravity scale for a rigid body */
+    setBodyGravityScale(handle: number, scale: number): number;
+    /** Gets the gravity scale for a rigid body */
+    getBodyGravityScale(handle: number): number;
+    /** Sets the friction coefficient for a collider */
+    setColliderFriction(handle: number, friction: number): number;
+    /** Gets the friction coefficient for a collider */
+    getColliderFriction(handle: number): number;
+    /** Sets the restitution (bounciness) for a collider */
+    setColliderRestitution(handle: number, restitution: number): number;
+    /** Gets the restitution (bounciness) for a collider */
+    getColliderRestitution(handle: number): number;
+    /** Set the fixed physics timestep in seconds */
+    setTimestep(dt: number): number;
+    /** Get the current fixed physics timestep in seconds */
+    getTimestep(): number;
+}
+/** Immediate-mode UI manager for creating and managing UI node trees */
+export interface IUiManager {
+    /** Runs the UI layout update tick */
+    update(): void;
+    /** Renders the UI tree */
+    render(): void;
+    /** Returns the number of live nodes in the UI tree */
+    nodeCount(): number;
+    /** Creates a new UI node with the given component type (0=Panel, -1=none) */
+    createNode(componentType: number): UiNodeId;
+    /** Removes a UI node and its subtree */
+    removeNode(nodeId: UiNodeId): number;
+    /** Sets or clears the parent of a UI node (use u64.MAX to detach) */
+    setParent(childId: UiNodeId, parentId: UiNodeId): number;
+    /** Returns the parent node ID, or u64.MAX if none */
+    getParent(nodeId: UiNodeId): UiNodeId;
+    /** Returns the number of children of a node */
+    getChildCount(nodeId: UiNodeId): number;
+    /** Returns the child node ID at a given index, or u64.MAX if out of bounds */
+    getChildAt(nodeId: UiNodeId, index: number): UiNodeId;
+    /** Sets or clears the widget component on an existing UI node */
+    setWidget(nodeId: UiNodeId, widgetKind: number): number;
+    /** Applies per-node style overrides using a C-safe style payload */
+    setStyle(nodeId: UiNodeId, style: IUiStyle): number;
+    /** Sets or creates a label widget and updates its text */
+    setLabelText(nodeId: UiNodeId, text: string): number;
+    /** Sets or creates a button widget and updates its enabled state */
+    setButtonEnabled(nodeId: UiNodeId, enabled: boolean): number;
+    /** Sets or creates an image widget and updates its texture path */
+    setImageTexturePath(nodeId: UiNodeId, path: string): number;
+    /** Sets or creates a slider widget and updates range/value/enabled */
+    setSlider(nodeId: UiNodeId, min: number, max: number, value: number, enabled: boolean): number;
+    /** Returns the number of UI events captured in the latest update tick */
+    eventCount(): number;
+    /** Reads one captured UI event by index */
+    eventRead(index: number): IUiEvent | null;
+    createPanel(): UiNodeId;
+    createLabel(text: string): UiNodeId;
+    createButton(enabled?: boolean): UiNodeId;
+    createImage(path: string): UiNodeId;
+    createSlider(min: number, max: number, value: number, enabled?: boolean): UiNodeId;
+}
 //# sourceMappingURL=engine.g.d.ts.map