@zylem/game-lib 0.7.0 → 0.8.0

package/dist/api/game-lib.api.md

@@ -0,0 +1,4544 @@
+## API Report File for "@zylem/game-lib"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { abs } from 'three/tsl';
+import { asin } from 'three/tsl';
+import { atan } from 'three/tsl';
+import { BehaviorDescriptor } from '@zylem/behaviors';
+import { BehaviorDescriptor as BehaviorDescriptor_2 } from '@zylem/behaviors/core';
+import { BehaviorEntityLink } from '@zylem/behaviors/core';
+import { BehaviorHandle } from '@zylem/behaviors';
+import { BehaviorHandle as BehaviorHandle_2 } from '@zylem/behaviors/core';
+import { BehaviorRef } from '@zylem/behaviors';
+import { BehaviorRef as BehaviorRef_2 } from '@zylem/behaviors/core';
+import { BehaviorRuntime } from '@zylem/behaviors/core';
+import { BehaviorSystem } from '@zylem/behaviors';
+import { BehaviorSystem as BehaviorSystem_2 } from '@zylem/behaviors/core';
+import { BehaviorSystemFactory } from '@zylem/behaviors';
+import { BehaviorSystemFactory as BehaviorSystemFactory_2 } from '@zylem/behaviors/core';
+import { bindRuntimeDynamicCircleBody2DHandle } from '@zylem/behaviors/runtime-2d';
+import { Blending } from 'three';
+import { BoundaryRicochet3DCoordinator } from '@zylem/behaviors';
+import { BoundaryRicochet3DEntity } from '@zylem/behaviors';
+import { BoundaryRicochetCoordinator } from '@zylem/behaviors';
+import { BoundaryRicochetEntity } from '@zylem/behaviors';
+import { BoundaryRicochetUpdate } from '@zylem/behaviors';
+import { BufferGeometry } from 'three';
+import { BurstParticlePresetOptions } from '@zylem/behaviors';
+import { Camera } from 'three';
+import { clamp } from 'three/tsl';
+import { Color } from 'three';
+import { ColorRepresentation } from 'three';
+import { computeWorldBoundary2DHits } from '@zylem/behaviors';
+import { computeWorldBoundary3DHits } from '@zylem/behaviors';
+import { CooldownBehavior } from '@zylem/behaviors';
+import { CooldownConfig } from '@zylem/behaviors';
+import { CooldownEntry } from '@zylem/behaviors';
+import { CooldownHandle } from '@zylem/behaviors';
+import { CooldownOptions } from '@zylem/behaviors';
+import { cos } from 'three/tsl';
+import { createFirstPersonInputComponent } from '@zylem/behaviors';
+import { createFirstPersonMovementComponent } from '@zylem/behaviors';
+import { createFirstPersonStateComponent } from '@zylem/behaviors';
+import { createJumpConfig2D } from '@zylem/behaviors';
+import { createJumpConfig3D } from '@zylem/behaviors';
+import { createJumpInput2D } from '@zylem/behaviors';
+import { createJumpInput3D } from '@zylem/behaviors';
+import { createJumpState2D } from '@zylem/behaviors';
+import { createJumpState3D } from '@zylem/behaviors';
+import { createPhysicsBodyComponent } from '@zylem/behaviors';
+import { createPlatformer2DInputComponent } from '@zylem/behaviors';
+import { createPlatformer2DMovementComponent } from '@zylem/behaviors';
+import { createPlatformer2DStateComponent } from '@zylem/behaviors';
+import { createPlatformer3DInputComponent } from '@zylem/behaviors';
+import { createPlatformer3DMovementComponent } from '@zylem/behaviors';
+import { createPlatformer3DStateComponent } from '@zylem/behaviors';
+import { createShooter2DStateComponent } from '@zylem/behaviors';
+import { createSimulation } from '@zylem/behaviors/core';
+import { createThrusterInputComponent } from '@zylem/behaviors';
+import { createThrusterMovementComponent } from '@zylem/behaviors';
+import { createThrusterStateComponent } from '@zylem/behaviors';
+import { createTopDownMovementComponent } from '@zylem/behaviors';
+import { createTopDownMovementInputComponent } from '@zylem/behaviors';
+import { createTopDownMovementStateComponent } from '@zylem/behaviors';
+import { createTransformComponent } from '@zylem/behaviors';
+import { createTransformStore } from '@zylem/behaviors/core';
+import { defineBehavior } from '@zylem/behaviors';
+import { DefineBehaviorConfig } from '@zylem/behaviors';
+import { Destructible3DBehavior } from '@zylem/behaviors';
+import { Destructible3DBehaviorOptions } from '@zylem/behaviors';
+import { Destructible3DColliderOptions } from '@zylem/behaviors';
+import { Destructible3DFragmentColliderShape } from '@zylem/behaviors';
+import { Destructible3DFragmentPhysicsOptions } from '@zylem/behaviors';
+import { Destructible3DHandle } from '@zylem/behaviors';
+import { DestructibleMesh } from '@zylem/behaviors';
+import { DestructiblePrebakeWorkerAPI } from '@zylem/behaviors';
+import { dot } from 'three/tsl';
+import { emitRuntimeGoal } from '@zylem/behaviors/runtime-2d';
+import { emitRuntimeRicochet } from '@zylem/behaviors/runtime-2d';
+import { emitRuntimeTriggerRegionEnter } from '@zylem/behaviors/runtime-2d';
+import { EntityDefinition } from '@zylem/behaviors/core';
+import { EntityHandle } from '@zylem/behaviors/core';
+import { exp } from 'three/tsl';
+import { FacingAngle2DEntity } from '@zylem/behaviors';
+import { fireCooldown } from '@zylem/behaviors';
+import { fireShooter2DIfRequested } from '@zylem/behaviors';
+import { FirstPersonBehavior } from '@zylem/behaviors';
+import { FirstPersonBehaviorOptions } from '@zylem/behaviors';
+import { FirstPersonContext } from '@zylem/behaviors';
+import { FirstPersonEntity } from '@zylem/behaviors';
+import { FirstPersonEvent } from '@zylem/behaviors';
+import { FirstPersonFSM } from '@zylem/behaviors';
+import { FirstPersonInputComponent } from '@zylem/behaviors';
+import { FirstPersonMovementComponent } from '@zylem/behaviors';
+import { FirstPersonPresentation } from '@zylem/behaviors';
+import { FirstPersonShooterCoordinator } from '@zylem/behaviors';
+import { FirstPersonShooterEntity } from '@zylem/behaviors';
+import { FirstPersonShooterInput } from '@zylem/behaviors';
+import { FirstPersonState } from '@zylem/behaviors';
+import { FirstPersonStateComponent } from '@zylem/behaviors';
+import { float } from 'three/tsl';
+import { floor } from 'three/tsl';
+import { Fn } from 'three/tsl';
+import { Fog } from 'three';
+import { FogExp2 } from 'three';
+import { fract } from 'three/tsl';
+import { FractureOptions } from '@zylem/behaviors';
+import { FractureOptionsInput } from '@zylem/behaviors';
+import { getCooldown } from '@zylem/behaviors';
+import { getCooldownStore } from '@zylem/behaviors';
+import { getEntityFacingAngle2D } from '@zylem/behaviors';
+import { getPosition } from '@zylem/behaviors/core';
+import { getVelocity } from '@zylem/behaviors/core';
+import { Group } from 'three';
+import { hasAnyWorldBoundary2DHit } from '@zylem/behaviors';
+import { hasAnyWorldBoundary3DHit } from '@zylem/behaviors';
+import { Howl as Howl_2 } from 'howler';
+import { JumpConfig2D } from '@zylem/behaviors';
+import { JumpConfig3D } from '@zylem/behaviors';
+import { JumpContext2D } from '@zylem/behaviors';
+import { JumpContext3D } from '@zylem/behaviors';
+import { Jumper2DBehavior } from '@zylem/behaviors';
+import { Jumper2DBehaviorOptions } from '@zylem/behaviors';
+import { Jumper2DEntity } from '@zylem/behaviors';
+import { Jumper2DEvent } from '@zylem/behaviors';
+import { Jumper2DFSM } from '@zylem/behaviors';
+import { Jumper2DState } from '@zylem/behaviors';
+import { Jumper3DBehavior } from '@zylem/behaviors';
+import { Jumper3DBehaviorOptions } from '@zylem/behaviors';
+import { Jumper3DEntity } from '@zylem/behaviors';
+import { Jumper3DEvent } from '@zylem/behaviors';
+import { Jumper3DFSM } from '@zylem/behaviors';
+import { Jumper3DState } from '@zylem/behaviors';
+import { JumpInput2D } from '@zylem/behaviors';
+import { JumpInput3D } from '@zylem/behaviors';
+import { JumpState2D } from '@zylem/behaviors';
+import { JumpState3D } from '@zylem/behaviors';
+import { length as length_2 } from 'three/tsl';
+import { Light } from 'three';
+import { Line2 } from 'three/addons/lines/webgpu/Line2.js';
+import { Material } from 'three';
+import { max } from 'three/tsl';
+import { Mesh } from 'three';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+import { min } from 'three/tsl';
+import * as mitt from 'mitt';
+import { mix } from 'three/tsl';
+import { mod } from 'three/tsl';
+import { move } from '@zylem/behaviors/core';
+import { MoveableEntity } from '@zylem/behaviors/core';
+import { moveForwardXY } from '@zylem/behaviors/core';
+import { moveX } from '@zylem/behaviors/core';
+import { moveXY } from '@zylem/behaviors/core';
+import { moveXZ } from '@zylem/behaviors/core';
+import { moveY } from '@zylem/behaviors/core';
+import { moveZ } from '@zylem/behaviors/core';
+import { MultidirectionalSpaceShooterCoordinator } from '@zylem/behaviors';
+import { MultidirectionalSpaceShooterEntity } from '@zylem/behaviors';
+import { MultidirectionalSpaceShooterInput } from '@zylem/behaviors';
+import { normalize } from 'three/tsl';
+import { Object3D } from 'three';
+import { particleEffect } from '@zylem/behaviors';
+import { ParticleEffectDefinition } from '@zylem/behaviors';
+import { ParticleEffectDefinition as ParticleEffectDefinition_2 } from '@zylem/behaviors/particle-emitter';
+import { ParticleEmitterBehavior } from '@zylem/behaviors';
+import { ParticleEmitterBehaviorOptions } from '@zylem/behaviors';
+import { ParticleEmitterBehaviorOptions as ParticleEmitterBehaviorOptions_2 } from '@zylem/behaviors/particle-emitter';
+import { ParticleEmitterHandle } from '@zylem/behaviors';
+import { ParticleEmitterHandle as ParticleEmitterHandle_2 } from '@zylem/behaviors/particle-emitter';
+import { ParticleMagicAgency } from '@zylem/behaviors';
+import { ParticleMagicAlignment } from '@zylem/behaviors';
+import { ParticleMagicModifierInput } from '@zylem/behaviors';
+import { ParticleMagicModifierOptions } from '@zylem/behaviors';
+import { ParticleMagicOrder } from '@zylem/behaviors';
+import { ParticleMagicRealityEffect } from '@zylem/behaviors';
+import { ParticleMagicTemperament } from '@zylem/behaviors';
+import { ParticlePresetMaterialOptions } from '@zylem/behaviors';
+import { particlePresets } from '@zylem/behaviors';
+import { PhysicsBodyComponent } from '@zylem/behaviors';
+import { PlainBufferGeometryPayload } from '@zylem/behaviors';
+import { PlainFractureOptions } from '@zylem/behaviors';
+import { Platformer2DBehavior } from '@zylem/behaviors';
+import { Platformer2DBehaviorOptions } from '@zylem/behaviors';
+import { Platformer2DCollisionContext } from '@zylem/behaviors';
+import { Platformer2DContext } from '@zylem/behaviors';
+import { Platformer2DEntity } from '@zylem/behaviors';
+import { Platformer2DEvent } from '@zylem/behaviors';
+import { Platformer2DFSM } from '@zylem/behaviors';
+import { Platformer2DInputComponent } from '@zylem/behaviors';
+import { Platformer2DMovementComponent } from '@zylem/behaviors';
+import { Platformer2DState } from '@zylem/behaviors';
+import { Platformer2DStateComponent } from '@zylem/behaviors';
+import { Platformer3DBehavior } from '@zylem/behaviors';
+import { Platformer3DBehaviorOptions } from '@zylem/behaviors';
+import { Platformer3DContext } from '@zylem/behaviors';
+import { Platformer3DEntity } from '@zylem/behaviors';
+import { Platformer3DEvent } from '@zylem/behaviors';
+import { Platformer3DFSM } from '@zylem/behaviors';
+import { Platformer3DInputComponent } from '@zylem/behaviors';
+import { Platformer3DMovementComponent } from '@zylem/behaviors';
+import { Platformer3DState } from '@zylem/behaviors';
+import { Platformer3DStateComponent } from '@zylem/behaviors';
+import { PlatformerCollisionContext } from '@zylem/behaviors';
+import { PlayerInput } from '@zylem/behaviors';
+import { positionWorld } from 'three/tsl';
+import { positionWorldDirection } from 'three/tsl';
+import { pow } from 'three/tsl';
+import { PrebakeWorkerRequest } from '@zylem/behaviors';
+import { PrebakeWorkerResponse } from '@zylem/behaviors';
+import { Quaternion } from 'three';
+import { Raycaster } from 'three';
+import { registerCooldown } from '@zylem/behaviors';
+import { RenderPipeline } from 'three/webgpu';
+import { RenderTarget } from 'three';
+import { resetCooldown } from '@zylem/behaviors';
+import { resetVelocity } from '@zylem/behaviors/core';
+import { resolveAim2D } from '@zylem/behaviors';
+import { ResolvedAim2D } from '@zylem/behaviors';
+import { Ricochet2DBehavior } from '@zylem/behaviors';
+import { Ricochet2DCollisionContext } from '@zylem/behaviors';
+import { Ricochet2DEvent } from '@zylem/behaviors';
+import { Ricochet2DFSM } from '@zylem/behaviors';
+import { Ricochet2DHandle } from '@zylem/behaviors';
+import { Ricochet2DOptions } from '@zylem/behaviors';
+import { Ricochet2DResult } from '@zylem/behaviors';
+import { Ricochet2DState } from '@zylem/behaviors';
+import { Ricochet3DBehavior } from '@zylem/behaviors';
+import { Ricochet3DCallback } from '@zylem/behaviors';
+import { Ricochet3DCollisionContext } from '@zylem/behaviors';
+import { Ricochet3DEvent } from '@zylem/behaviors';
+import { Ricochet3DFSM } from '@zylem/behaviors';
+import { Ricochet3DHandle } from '@zylem/behaviors';
+import { Ricochet3DOptions } from '@zylem/behaviors';
+import { Ricochet3DResult } from '@zylem/behaviors';
+import { Ricochet3DState } from '@zylem/behaviors';
+import { RicochetCallback } from '@zylem/behaviors';
+import { RUNTIME_BOUNDARY_2D_BEHAVIOR_KEY } from '@zylem/behaviors/runtime-2d';
+import { RUNTIME_DYNAMIC_CIRCLE_BODY_2D_BEHAVIOR_KEY } from '@zylem/behaviors/runtime-2d';
+import { RUNTIME_GOAL_ZONE_2D_BEHAVIOR_KEY } from '@zylem/behaviors/runtime-2d';
+import { RUNTIME_PLAYER_INPUT_2D_BEHAVIOR_KEY } from '@zylem/behaviors/runtime-2d';
+import { RUNTIME_RICOCHET_2D_BEHAVIOR_KEY } from '@zylem/behaviors/runtime-2d';
+import { RUNTIME_TRIGGER_REGION_2D_BEHAVIOR_KEY } from '@zylem/behaviors/runtime-2d';
+import { RuntimeBoundary2DBehavior } from '@zylem/behaviors/runtime-2d';
+import { RuntimeBoundary2DOptions } from '@zylem/behaviors/runtime-2d';
+import { RuntimeDynamicCircleBody2DBehavior } from '@zylem/behaviors/runtime-2d';
+import { RuntimeDynamicCircleBody2DHandle } from '@zylem/behaviors/runtime-2d';
+import { RuntimeDynamicCircleBody2DOptions } from '@zylem/behaviors/runtime-2d';
+import { RuntimeGoalZone2DBehavior } from '@zylem/behaviors/runtime-2d';
+import { RuntimeGoalZone2DEvent } from '@zylem/behaviors/runtime-2d';
+import { RuntimeGoalZone2DHandle } from '@zylem/behaviors/runtime-2d';
+import { RuntimeGoalZone2DOptions } from '@zylem/behaviors/runtime-2d';
+import { RuntimePlayerInput2DBehavior } from '@zylem/behaviors/runtime-2d';
+import { RuntimePlayerInput2DOptions } from '@zylem/behaviors/runtime-2d';
+import { RuntimeRicochet2DBehavior } from '@zylem/behaviors/runtime-2d';
+import { RuntimeRicochet2DEvent } from '@zylem/behaviors/runtime-2d';
+import { RuntimeRicochet2DHandle } from '@zylem/behaviors/runtime-2d';
+import { RuntimeRicochet2DOptions } from '@zylem/behaviors/runtime-2d';
+import { RuntimeTriggerRegion2DBehavior } from '@zylem/behaviors/runtime-2d';
+import { RuntimeTriggerRegion2DEvent } from '@zylem/behaviors/runtime-2d';
+import { RuntimeTriggerRegion2DHandle } from '@zylem/behaviors/runtime-2d';
+import { RuntimeTriggerRegion2DOptions } from '@zylem/behaviors/runtime-2d';
+import { Scene } from 'three';
+import { ScreenVisibilityBehavior } from '@zylem/behaviors';
+import { ScreenVisibilityChangeContext } from '@zylem/behaviors';
+import { ScreenVisibilityFSM } from '@zylem/behaviors';
+import { ScreenVisibilityHandle } from '@zylem/behaviors';
+import { ScreenVisibilityOptions } from '@zylem/behaviors';
+import { ScreenVisibilitySize } from '@zylem/behaviors';
+import { ScreenVisibilitySnapshot } from '@zylem/behaviors';
+import { ScreenWrapBehavior } from '@zylem/behaviors';
+import { ScreenWrapEvent } from '@zylem/behaviors';
+import { ScreenWrapFSM } from '@zylem/behaviors';
+import { ScreenWrapOptions } from '@zylem/behaviors';
+import { ScreenWrapState } from '@zylem/behaviors';
+import { SemanticParticlePresetOptions } from '@zylem/behaviors';
+import { setPosition } from '@zylem/behaviors/core';
+import { setPositionX } from '@zylem/behaviors/core';
+import { setPositionY } from '@zylem/behaviors/core';
+import { setPositionZ } from '@zylem/behaviors/core';
+import { ShaderMaterial } from 'three';
+import { Shooter2DAimFireInput } from '@zylem/behaviors';
+import { Shooter2DBehavior } from '@zylem/behaviors';
+import { Shooter2DBehaviorOptions } from '@zylem/behaviors';
+import { Shooter2DFireArgs } from '@zylem/behaviors';
+import { Shooter2DHandle } from '@zylem/behaviors';
+import { Shooter2DProjectileFactory } from '@zylem/behaviors';
+import { Shooter2DSourceEntity } from '@zylem/behaviors';
+import { Shooter2DStageLike } from '@zylem/behaviors';
+import { Shooter2DStateComponent } from '@zylem/behaviors';
+import { Shooter2DTarget } from '@zylem/behaviors';
+import { Side } from 'three';
+import { Simulation } from '@zylem/behaviors/core';
+import { SimulationBodyDefinition } from '@zylem/behaviors/core';
+import { SimulationColliderDefinition } from '@zylem/behaviors/core';
+import { SimulationEvent } from '@zylem/behaviors/core';
+import { SimulationFrame } from '@zylem/behaviors/core';
+import { SimulationOptions } from '@zylem/behaviors/core';
+import { sin } from 'three/tsl';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { smoothstep } from 'three/tsl';
+import { Sprite } from 'three';
+import { StageBodyConfig } from '@zylem/behaviors/core';
+import { StageBodyInfo } from '@zylem/behaviors/core';
+import { StageBodyKind } from '@zylem/behaviors/core';
+import { StageBodyKindValue } from '@zylem/behaviors/core';
+import { StageBoundaryDim } from '@zylem/behaviors/core';
+import { StageColliderConfig } from '@zylem/behaviors/core';
+import { StageColliderShape } from '@zylem/behaviors/core';
+import { StageDebugRender } from '@zylem/behaviors/core';
+import { StageEvent } from '@zylem/behaviors/core';
+import { StageEventType } from '@zylem/behaviors/core';
+import { StagePose } from '@zylem/behaviors/core';
+import { StageRaycastHit } from '@zylem/behaviors/core';
+import { StageRenderSlot } from '@zylem/behaviors/core';
+import { StageRicochetDim } from '@zylem/behaviors/core';
+import { StageRicochetReflection } from '@zylem/behaviors/core';
+import { StageTopDownPlane } from '@zylem/behaviors/core';
+import { Static } from '@sinclair/typebox';
+import { step } from 'three/tsl';
+import { Texture } from 'three';
+import { ThrusterBehavior } from '@zylem/behaviors';
+import { ThrusterBehaviorOptions } from '@zylem/behaviors';
+import { ThrusterEntity } from '@zylem/behaviors';
+import { ThrusterEvent } from '@zylem/behaviors';
+import { ThrusterFSM } from '@zylem/behaviors';
+import { ThrusterFSMContext } from '@zylem/behaviors';
+import { ThrusterInputComponent } from '@zylem/behaviors';
+import { ThrusterMovementComponent } from '@zylem/behaviors';
+import { ThrusterState } from '@zylem/behaviors';
+import { ThrusterStateComponent } from '@zylem/behaviors';
+import { tickCooldowns } from '@zylem/behaviors';
+import { time } from 'three/tsl';
+import { TopDownMovementBehavior } from '@zylem/behaviors';
+import { TopDownMovementBehaviorOptions } from '@zylem/behaviors';
+import { TopDownMovementComponent } from '@zylem/behaviors';
+import { TopDownMovementEntity } from '@zylem/behaviors';
+import { TopDownMovementHandle } from '@zylem/behaviors';
+import { TopDownMovementInputComponent } from '@zylem/behaviors';
+import { TopDownMovementStateComponent } from '@zylem/behaviors';
+import { TopDownShooterCoordinator } from '@zylem/behaviors';
+import { TopDownShooterEntity } from '@zylem/behaviors';
+import { TopDownShooterInput } from '@zylem/behaviors';
+import { TransformComponent } from '@zylem/behaviors';
+import { TransformState } from '@zylem/behaviors/core';
+import { uniform } from 'three/tsl';
+import { updateBoundaryRicochet } from '@zylem/behaviors';
+import { useBehavior } from '@zylem/behaviors';
+import { uv } from 'three/tsl';
+import { vec2 } from 'three/tsl';
+import { vec3 } from 'three/tsl';
+import { Vec3Like } from '@zylem/behaviors';
+import { vec4 } from 'three/tsl';
+import { Vector } from '@zylem/behaviors/core';
+import { Vector2 } from 'three';
+import { Vector3 } from 'three';
+import { ViewmodelConfig } from '@zylem/behaviors';
+import { VoronoiOptions } from '@zylem/behaviors';
+import { WebGPURenderer } from 'three/webgpu';
+import { WorldBoundary2DBehavior } from '@zylem/behaviors';
+import { WorldBoundary2DBounds } from '@zylem/behaviors';
+import { WorldBoundary2DEvent } from '@zylem/behaviors';
+import { WorldBoundary2DFSM } from '@zylem/behaviors';
+import { WorldBoundary2DHandle } from '@zylem/behaviors';
+import { WorldBoundary2DHit } from '@zylem/behaviors';
+import { WorldBoundary2DHits } from '@zylem/behaviors';
+import { WorldBoundary2DOptions } from '@zylem/behaviors';
+import { WorldBoundary2DPosition } from '@zylem/behaviors';
+import { WorldBoundary2DState } from '@zylem/behaviors';
+import { WorldBoundary3DBehavior } from '@zylem/behaviors';
+import { WorldBoundary3DBounds } from '@zylem/behaviors';
+import { WorldBoundary3DEvent } from '@zylem/behaviors';
+import { WorldBoundary3DFSM } from '@zylem/behaviors';
+import { WorldBoundary3DHandle } from '@zylem/behaviors';
+import { WorldBoundary3DHit } from '@zylem/behaviors';
+import { WorldBoundary3DHits } from '@zylem/behaviors';
+import { WorldBoundary3DOptions } from '@zylem/behaviors';
+import { WorldBoundary3DPosition } from '@zylem/behaviors';
+import { WorldBoundary3DState } from '@zylem/behaviors';
+import { wrapAround3D } from '@zylem/behaviors/core';
+import { wrapAroundXY } from '@zylem/behaviors/core';
+
+export { abs }
+
+// @public
+export interface Action {
+    readonly done: boolean;
+    readonly duration: number;
+    persistent: boolean;
+    reset(): void;
+    tick(entity: GameEntity<any>, delta: number): void;
+}
+
+// @public (undocumented)
+export const ACTOR_TYPE: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "BaseLightOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export interface AmbientLightOptions extends BaseLightOptions {
+    // (undocumented)
+    type: 'ambient';
+}
+
+// @public (undocumented)
+export interface AnalogState {
+    // (undocumented)
+    held: number;
+    // (undocumented)
+    value: number;
+}
+
+// Warning: (ae-forgotten-export) The symbol "TransformableEntity" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function applyTransformChanges(entity: TransformableEntity, store: TransformState): void;
+
+export { asin }
+
+// @public (undocumented)
+export const AspectRatio: {
+    readonly FourByThree: number;
+    readonly SixteenByNine: number;
+    readonly NineBySixteen: number;
+    readonly TwentyOneByNine: number;
+    readonly OneByOne: number;
+};
+
+// @public (undocumented)
+export type AspectRatioValue = (typeof AspectRatio)[keyof typeof AspectRatio] | number;
+
+export { atan }
+
+export { BehaviorDescriptor }
+
+export { BehaviorHandle }
+
+export { BehaviorRef }
+
+export { BehaviorRuntime }
+
+export { BehaviorSystem }
+
+export { BehaviorSystemFactory }
+
+export { bindRuntimeDynamicCircleBody2DHandle }
+
+export { BoundaryRicochet3DCoordinator }
+
+export { BoundaryRicochet3DEntity }
+
+export { BoundaryRicochetCoordinator }
+
+export { BoundaryRicochetEntity }
+
+export { BoundaryRicochetUpdate }
+
+// @public (undocumented)
+export const BOX_TYPE: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "BoxCollisionOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function boxCollision(opts?: BoxCollisionOptions): CollisionComponent;
+
+// Warning: (ae-forgotten-export) The symbol "BoxMeshOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function boxMesh(opts?: BoxMeshOptions): Mesh;
+
+// @public
+export function buildBoxCollider(size: Vec3Input, options?: RuntimeColliderOptions): StageColliderConfig;
+
+// @public (undocumented)
+export function buildCapsuleCollider(halfHeight: number, radius: number, options?: RuntimeColliderOptions): StageColliderConfig;
+
+// @public (undocumented)
+export function buildConvexHullCollider(vertices: Float32Array, options?: RuntimeColliderOptions): StageColliderConfig;
+
+// @public (undocumented)
+export function buildCylinderCollider(halfHeight: number, radius: number, options?: RuntimeColliderOptions): StageColliderConfig;
+
+// @public (undocumented)
+export function buildHeightfieldCollider(rows: number, cols: number, heights: Float32Array, scale: readonly [number, number, number], options?: RuntimeColliderOptions): StageColliderConfig;
+
+// @public (undocumented)
+export function buildRuntimeBody(options?: RuntimeBodyOptions): StageBodyConfig;
+
+// @public (undocumented)
+export function buildSphereCollider(radius: number, options?: RuntimeColliderOptions): StageColliderConfig;
+
+// @public (undocumented)
+export function buildTrimeshCollider(vertices: Float32Array, indices: Uint32Array, options?: RuntimeColliderOptions): StageColliderConfig;
+
+// @public (undocumented)
+export function bundleRuntimeCollision(body: StageBodyConfig, colliders: StageColliderConfig[]): RuntimeCollisionBundle;
+
+export { BurstParticlePresetOptions }
+
+// @public (undocumented)
+export type ButtonName = keyof InputGamepad['buttons'];
+
+// @public (undocumented)
+export interface ButtonState {
+    // (undocumented)
+    held: number;
+    // (undocumented)
+    pressed: boolean;
+    // (undocumented)
+    released: boolean;
+}
+
+// @public
+export function callFunc(fn: () => void): Action;
+
+// @public
+export interface CameraAction {
+    isDone(ctx: CameraContext): boolean;
+    priority?: number;
+    update(ctx: CameraContext): PoseDelta;
+}
+
+// @public
+export interface CameraBehavior {
+    enabled?: boolean;
+    onAttach?(ctx: CameraContext): void;
+    onDetach?(ctx: CameraContext): void;
+    priority?: number;
+    update(ctx: CameraContext, pose: CameraPose): CameraPose;
+}
+
+// @public
+export interface CameraContext {
+    dt: number;
+    targets: Record<string, TransformLike>;
+    time: number;
+    viewport: {
+        width: number;
+        height: number;
+        aspect: number;
+    };
+}
+
+// @public
+export interface CameraFeedOptions {
+    height?: number;
+    width?: number;
+}
+
+// @public
+export class CameraManager {
+    constructor();
+    // Warning: (ae-forgotten-export) The symbol "ZylemCamera" needs to be exported by the entry point public.d.ts
+    get activeCameras(): ReadonlyArray<ZylemCamera>;
+    addActiveCamera(nameOrRef: string | ZylemCamera): boolean;
+    addCamera(camera: ZylemCamera, name?: string): string;
+    get allCameras(): ReadonlyArray<ZylemCamera>;
+    deactivateCamera(nameOrRef: string | ZylemCamera): boolean;
+    get debugCamera(): ZylemCamera | null;
+    dispose(): void;
+    ensureDefaultCamera(): ZylemCamera;
+    getCamera(name: string): ZylemCamera | null;
+    get primaryCamera(): ZylemCamera | null;
+    removeCamera(nameOrRef: string | ZylemCamera): boolean;
+    render(scene: Scene): void;
+    setActiveCamera(nameOrRef: string | ZylemCamera): boolean;
+    // Warning: (ae-forgotten-export) The symbol "RendererManager" needs to be exported by the entry point public.d.ts
+    setup(scene: Scene, rendererManager: RendererManager): Promise<void>;
+    update(delta: number): void;
+}
+
+// @public (undocumented)
+export interface CameraOptions {
+    behaviors?: Record<string, CameraBehavior>;
+    damping?: number;
+    name?: string;
+    // (undocumented)
+    perspective?: PerspectiveType;
+    // (undocumented)
+    position?: Vec3Input;
+    renderToTexture?: {
+        width?: number;
+        height?: number;
+    };
+    // (undocumented)
+    screenResolution?: Vec2Input;
+    skipDebugOrbit?: boolean;
+    // (undocumented)
+    target?: Vec3Input;
+    useOrbitalControls?: boolean;
+    viewport?: Viewport;
+    // (undocumented)
+    zoom?: number;
+}
+
+// @public
+export interface CameraPerspective {
+    defaults?: {
+        damping?: number;
+    };
+    getBasePose(ctx: CameraContext): CameraPose;
+    // (undocumented)
+    id: string;
+}
+
+// @public
+export class CameraPipeline {
+    constructor(perspective?: CameraPerspective);
+    addAction(action: CameraAction): void;
+    addBehavior(key: string, behavior: CameraBehavior, ctx?: CameraContext): void;
+    damping: number;
+    getState(): CameraPipelineState;
+    hasBehavior(key: string): boolean;
+    perspective: CameraPerspective | null;
+    removeBehavior(key: string, ctx?: CameraContext): boolean;
+    run(ctx: CameraContext): CameraPose;
+    setPerspective(perspective: CameraPerspective): void;
+}
+
+// @public
+export interface CameraPipelineState {
+    // (undocumented)
+    activeActionCount: number;
+    // (undocumented)
+    activeBehaviors: string[];
+    // (undocumented)
+    desiredPose: CameraPose | null;
+    // (undocumented)
+    finalPose: CameraPose | null;
+    // (undocumented)
+    perspectiveId: string | null;
+}
+
+// @public
+export interface CameraPose {
+    // (undocumented)
+    far?: number;
+    // (undocumented)
+    fov?: number;
+    lookAt?: Vector3;
+    // (undocumented)
+    near?: number;
+    // (undocumented)
+    position: Vector3;
+    // (undocumented)
+    rotation: Quaternion;
+    // (undocumented)
+    zoom?: number;
+}
+
+// @public
+export class CameraWrapper {
+    constructor(camera: ZylemCamera);
+    addAction(action: CameraAction): void;
+    addBehavior(key: string, behavior: CameraBehavior): void;
+    addTarget(entity: StageEntity): void;
+    // (undocumented)
+    cameraRef: ZylemCamera;
+    clearTargets(): void;
+    disableOrbitalControls(): void;
+    enableOrbitalControls(): void;
+    getPerspective<T extends CameraPerspective = CameraPerspective>(): T;
+    getRenderTexture(): Texture | null;
+    getState(): CameraPipelineState;
+    removeBehavior(key: string): boolean;
+    removeTarget(entity: StageEntity): void;
+    setPerspective(type: PerspectiveType, options?: PerspectiveOptions): void;
+    setViewport(x: number, y: number, width: number, height: number): void;
+}
+
+export { clamp }
+
+// @public
+export function clearGlobalSubscriptions(): void;
+
+// @public
+export interface CollisionComponent {
+    // (undocumented)
+    __kind: 'collision';
+    // (undocumented)
+    bodyDesc: SimulationBodyDefinition;
+    // (undocumented)
+    cloneComponent: () => CollisionComponent;
+    // (undocumented)
+    colliderDesc: SimulationColliderDefinition;
+}
+
+// @public (undocumented)
+export type CollisionShapeType = 'capsule' | 'bounds' | 'trimesh' | 'model';
+
+// @public
+export const ColorJsonSchema: _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>;
+
+export { computeWorldBoundary2DHits }
+
+export { computeWorldBoundary3DHits }
+
+// @public (undocumented)
+export const CONE_TYPE: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "ConeCollisionOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function coneCollision(opts?: ConeCollisionOptions): CollisionComponent;
+
+// Warning: (ae-forgotten-export) The symbol "ConeMeshOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function coneMesh(opts?: ConeMeshOptions): Mesh;
+
+export { CooldownBehavior }
+
+export { CooldownConfig }
+
+export { CooldownEntry }
+
+export { CooldownHandle }
+
+export { CooldownOptions }
+
+export { cos }
+
+// @public
+export function create(options?: Partial<GameEntityOptions>): GameEntity<GameEntityOptions>;
+
+// Warning: (ae-forgotten-export) The symbol "ActorOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createActor(...args: Array<ActorOptions>): ZylemActor;
+
+// @public
+export function createBackgroundShader(colorNode: any, transparent?: boolean): ZylemTSLShader;
+
+// Warning: (ae-forgotten-export) The symbol "BoxOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createBox(...args: Array<BoxOptions>): ZylemBox;
+
+// @public
+export function createCamera(options: CameraOptions): CameraWrapper;
+
+// Warning: (ae-forgotten-export) The symbol "ConeOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function createCone(...args: Array<ConeOptions>): ZylemCone;
+
+// Warning: (ae-forgotten-export) The symbol "CooldownIconOptions" needs to be exported by the entry point public.d.ts
+// Warning: (ae-forgotten-export) The symbol "ZylemCooldownIcon" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function createCooldownIcon(...args: Array<CooldownIconOptions>): ZylemCooldownIcon;
+
+// Warning: (ae-forgotten-export) The symbol "CylinderOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function createCylinder(...args: Array<CylinderOptions>): ZylemCylinder;
+
+// Warning: (ae-forgotten-export) The symbol "DiskOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createDisk(...args: Array<DiskOptions>): ZylemDisk;
+
+// Warning: (ae-forgotten-export) The symbol "CreateGameEntityOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createEntity<T extends GameEntity<any>, CreateOptions extends GameEntityOptions>(params: CreateGameEntityOptions<T, CreateOptions>): T;
+
+// @public
+export function createEntityFactory<E extends GameEntity<O>, O extends GameEntityOptions = GameEntityOptions>(template: E): TemplateFactory<E, O>;
+
+export { createFirstPersonInputComponent }
+
+export { createFirstPersonMovementComponent }
+
+export { createFirstPersonStateComponent }
+
+// @public
+export function createFog(options?: ZylemFogOptions): ZylemFog;
+
+// @public
+export function createFollowTarget(options?: FollowTargetOptions): CameraBehavior;
+
+// Warning: (ae-forgotten-export) The symbol "BaseGlobals" needs to be exported by the entry point public.d.ts
+// Warning: (ae-forgotten-export) The symbol "GameOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function createGame<TGlobals extends BaseGlobals>(...options: GameOptions<TGlobals>): Game<TGlobals>;
+
+// @public
+export function createGlobal<T>(path: string, defaultValue: T): T;
+
+export { createJumpConfig2D }
+
+export { createJumpConfig3D }
+
+export { createJumpInput2D }
+
+export { createJumpInput3D }
+
+export { createJumpState2D }
+
+export { createJumpState3D }
+
+// @public
+export function createLight(options: ZylemLightOptions): ZylemLight;
+
+// Warning: (ae-forgotten-export) The symbol "LineOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createLine(...args: Array<LineOptions>): ZylemLine;
+
+// @public
+export function createNodeMaterialFromTSL(tslShader: ZylemTSLShader, opacity?: number): MeshBasicNodeMaterial;
+
+// @public (undocumented)
+export function createParticleSystem(options?: Partial<ZylemParticleSystemOptions>): ZylemParticleSystem;
+
+// @public
+export function createPerspective(type: PerspectiveType, options?: PerspectiveOptions): CameraPerspective;
+
+export { createPhysicsBodyComponent }
+
+// Warning: (ae-forgotten-export) The symbol "PillOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function createPill(...args: Array<PillOptions>): ZylemPill;
+
+// Warning: (ae-forgotten-export) The symbol "PlaneOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createPlane(...args: Array<PlaneOptions>): ZylemPlane;
+
+export { createPlatformer2DInputComponent }
+
+export { createPlatformer2DMovementComponent }
+
+export { createPlatformer2DStateComponent }
+
+export { createPlatformer3DInputComponent }
+
+export { createPlatformer3DMovementComponent }
+
+export { createPlatformer3DStateComponent }
+
+// Warning: (ae-forgotten-export) The symbol "PyramidOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function createPyramid(...args: Array<PyramidOptions>): ZylemPyramid;
+
+// Warning: (ae-forgotten-export) The symbol "RectOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createRect(...args: Array<RectOptions>): ZylemRect;
+
+export { createShooter2DStateComponent }
+
+export { createSimulation }
+
+// Warning: (ae-forgotten-export) The symbol "SphereOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createSphere(...args: Array<SphereOptions>): ZylemSphere;
+
+// Warning: (ae-forgotten-export) The symbol "SpriteOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createSprite(...args: Array<SpriteOptions>): ZylemSprite;
+
+// Warning: (ae-forgotten-export) The symbol "Stage" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function createStage(...options: StageOptions): Stage;
+
+// Warning: (ae-forgotten-export) The symbol "TextOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createText(...args: Array<TextOptions>): ZylemText;
+
+export { createThrusterInputComponent }
+
+export { createThrusterMovementComponent }
+
+export { createThrusterStateComponent }
+
+export { createTopDownMovementComponent }
+
+export { createTopDownMovementInputComponent }
+
+export { createTopDownMovementStateComponent }
+
+export { createTransformComponent }
+
+export { createTransformStore }
+
+// @public
+export function createVariable<T>(target: object, path: string, defaultValue: T): T;
+
+// Warning: (ae-forgotten-export) The symbol "ZoneOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function createZone(...args: Array<ZoneOptions>): ZylemZone;
+
+// @public
+export const crossfadeTransitionShader: ZylemTransitionShader;
+
+// @public (undocumented)
+export const CYLINDER_TYPE: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "CylinderCollisionOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function cylinderCollision(opts?: CylinderCollisionOptions): CollisionComponent;
+
+// Warning: (ae-forgotten-export) The symbol "CylinderMeshOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function cylinderMesh(opts?: CylinderMeshOptions): Mesh;
+
+// Warning: (ae-forgotten-export) The symbol "DebugState" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export const debugState: DebugState;
+
+// @public (undocumented)
+export type DebugTools = 'select' | 'translate' | 'rotate' | 'scale' | 'delete' | 'none';
+
+// @public
+export function defaultTouchControls(player?: InputPlayer, options?: DefaultTouchControlsOptions): GameInputConfig;
+
+// @public (undocumented)
+export interface DefaultTouchControlsOptions {
+    buttonAccents?: Partial<Record<VirtualTouchButtonSlot, string>>;
+    buttonLabels?: Partial<Record<VirtualTouchButtonSlot, string>>;
+    buttons?: VirtualTouchButtonSlot[];
+    enabled?: boolean | 'auto';
+    joysticks?: JoystickSelection;
+    override?: VirtualTouchConfig;
+    theme?: TouchTheme | TouchThemeName;
+}
+
+export { defineBehavior }
+
+export { DefineBehaviorConfig }
+
+// @public
+export function delay(ms: number): Action;
+
+// @public (undocumented)
+export function destroy(entity: any, globals?: any): void;
+
+export { Destructible3DBehavior }
+
+export { Destructible3DBehaviorOptions }
+
+export { Destructible3DColliderOptions }
+
+export { Destructible3DFragmentColliderShape }
+
+export { Destructible3DFragmentPhysicsOptions }
+
+export { Destructible3DHandle }
+
+export { DestructibleMesh }
+
+export { DestructiblePrebakeWorkerAPI }
+
+// @public (undocumented)
+export type DeviceProfile = 'auto' | 'desktop' | 'mobile';
+
+// @public (undocumented)
+export interface DirectionalLightOptions extends BaseLightOptions {
+    castShadow?: boolean;
+    shadow?: LightShadowOptions;
+    // Warning: (ae-forgotten-export) The symbol "Vec3_2" needs to be exported by the entry point public.d.ts
+    target?: Vec3_2;
+    // (undocumented)
+    type: 'directional';
+}
+
+// @public (undocumented)
+export const DISK_TYPE: unique symbol;
+
+// @public
+export function dispatchStageState(): void;
+
+export { dot }
+
+export { emitRuntimeGoal }
+
+export { emitRuntimeRicochet }
+
+export { emitRuntimeTriggerRegionEnter }
+
+// @public (undocumented)
+export type EntityBlueprint = Static<typeof EntitySchema>;
+
+// @public
+export interface EntityConfigPayload {
+    bounds?: {
+        width: number;
+        height: number;
+        depth: number;
+    };
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    // (undocumented)
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    // (undocumented)
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    thumbnail?: string | null;
+    // (undocumented)
+    type: string;
+    // (undocumented)
+    uuid: string;
+}
+
+export { EntityDefinition }
+
+// @public (undocumented)
+export type EntityEvents = {
+    'entity:spawned': {
+        entityId: string;
+        name: string;
+    };
+    'entity:destroyed': {
+        entityId: string;
+    };
+    'entity:collision': {
+        entityId: string;
+        otherId: string;
+    };
+    'entity:model:loading': {
+        entityId: string;
+        files: string[];
+    };
+    'entity:model:loaded': {
+        entityId: string;
+        success: boolean;
+        meshCount?: number;
+        errorMessage?: string;
+    };
+    'entity:animation:loaded': {
+        entityId: string;
+        animationCount: number;
+    };
+};
+
+// @public
+export interface EntityFocusContext {
+    ensureDebugReady?(): void;
+    frameObject(object: Object3D): void;
+    resolveEntity(uuid: string): GameEntity<any> | null;
+}
+
+// Warning: (ae-forgotten-export) The symbol "BaseNode" needs to be exported by the entry point public.d.ts
+//
+// @public
+export type EntityForType<T> = T extends keyof EntityTypeMap ? EntityTypeMap[T] : BaseNode;
+
+export { EntityHandle }
+
+// @public (undocumented)
+export type EntityJson = Static<typeof EntityJsonSchema>;
+
+// @public
+export const EntityJsonSchema: _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    type: _sinclair_typebox.TLiteral<"text">;
+    position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+    data: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        value: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        color: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        fontSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        fontFamily: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    }>>;
+}>, _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    type: _sinclair_typebox.TLiteral<"sprite">;
+    position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+    data: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        imagePath: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        width: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        height: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    }>>;
+}>, _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    type: _sinclair_typebox.TLiteral<"line">;
+    position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+    data: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        points: _sinclair_typebox.TArray<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+        color: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        colors: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
+        linewidth: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        worldUnits: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        alphaToCoverage: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        opacity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        transparent: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        dashed: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        dashSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        gapSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        pickThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    }>>;
+}>, _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    type: _sinclair_typebox.TString;
+    position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+    data: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnknown>>;
+}>]>;
+
+// @public
+export const EntitySchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    type: _sinclair_typebox.TString;
+    position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+    data: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TAny>>;
+}>;
+
+// Warning: (ae-forgotten-export) The symbol "EntitySpawner" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export function entitySpawner(factory: (x: number, y: number) => Promise<any> | GameEntity<any>): EntitySpawner;
+
+// @public
+export class EntityThumbnailCache {
+    constructor(size?: number);
+    // (undocumented)
+    clear(): void;
+    ensure(uuid: string, object: Object3D | null | undefined): Promise<EntityThumbnailCacheEntry | null>;
+    // (undocumented)
+    get(uuid: string): EntityThumbnailCacheEntry | null;
+    // (undocumented)
+    invalidate(uuid: string): void;
+    // (undocumented)
+    setRenderer(renderer: WebGPURenderer | null): void;
+}
+
+// @public
+export const entityThumbnailCache: EntityThumbnailCache;
+
+// @public (undocumented)
+export interface EntityThumbnailCacheEntry extends EntityThumbnailResult {
+    // (undocumented)
+    uuid: string;
+}
+
+// @public (undocumented)
+export interface EntityThumbnailResult {
+    // Warning: (ae-forgotten-export) The symbol "ObjectBounds" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    bounds: Pick<ObjectBounds, 'width' | 'height' | 'depth'>;
+    // (undocumented)
+    dataUrl: string;
+}
+
+// @public
+export interface EntityTypeMap {
+    // (undocumented)
+    [ACTOR_TYPE]: ZylemActor;
+    // (undocumented)
+    [BOX_TYPE]: ZylemBox;
+    // (undocumented)
+    [CONE_TYPE]: ZylemCone;
+    // (undocumented)
+    [CYLINDER_TYPE]: ZylemCylinder;
+    // (undocumented)
+    [DISK_TYPE]: ZylemDisk;
+    // (undocumented)
+    [FOG_TYPE]: ZylemFog;
+    // (undocumented)
+    [LIGHT_TYPE]: ZylemLight;
+    // (undocumented)
+    [LINE_TYPE]: ZylemLine;
+    // (undocumented)
+    [PARTICLE_SYSTEM_TYPE]: ZylemParticleSystem;
+    // (undocumented)
+    [PILL_TYPE]: ZylemPill;
+    // (undocumented)
+    [PLANE_TYPE]: ZylemPlane;
+    // (undocumented)
+    [PYRAMID_TYPE]: ZylemPyramid;
+    // (undocumented)
+    [RECT_TYPE]: ZylemRect;
+    // (undocumented)
+    [SPHERE_TYPE]: ZylemSphere;
+    // (undocumented)
+    [SPRITE_TYPE]: ZylemSprite;
+    // (undocumented)
+    [TEXT_TYPE]: ZylemText;
+    // (undocumented)
+    [ZONE_TYPE]: ZylemZone;
+}
+
+// @public
+export class EventEmitterDelegate<TEvents extends Record<string, unknown>> {
+    constructor();
+    dispatch<K extends keyof TEvents>(event: K, payload: TEvents[K]): void;
+    dispose(): void;
+    listen<K extends keyof TEvents>(event: K, handler: (payload: TEvents[K]) => void): () => void;
+    listenAll(handler: (type: keyof TEvents, payload: TEvents[keyof TEvents]) => void): () => void;
+}
+
+export { exp }
+
+export { FacingAngle2DEntity }
+
+// @public
+export function fadeOpacity(opts: FadeOpacityOptions): Action;
+
+// @public (undocumented)
+export interface FadeOpacityOptions {
+    duration: number;
+    from?: number;
+    restoreOpaque?: boolean;
+    targets?: Object3D[];
+    to?: number;
+}
+
+export { fireCooldown }
+
+export { fireShooter2DIfRequested }
+
+export { FirstPersonBehavior }
+
+export { FirstPersonBehaviorOptions }
+
+export { FirstPersonContext }
+
+export { FirstPersonEntity }
+
+export { FirstPersonEvent }
+
+export { FirstPersonFSM }
+
+export { FirstPersonInputComponent }
+
+export { FirstPersonMovementComponent }
+
+// @public
+export interface FirstPersonOptions {
+    defaultFov?: number;
+    eyeHeight?: number;
+    fovLerpSpeed?: number;
+    initialLookAt?: Vec3Input;
+    initialPosition?: Vec3Input;
+    lookAtLerpSpeed?: number;
+    pitchLimit?: number;
+    targetKey?: string;
+    verticalSmoothing?: number;
+}
+
+// @public
+export class FirstPersonPerspective implements CameraPerspective {
+    constructor(options?: FirstPersonOptions);
+    clearLookAt(): void;
+    get currentFov(): number;
+    // (undocumented)
+    readonly defaults: {
+        damping: number;
+    };
+    // (undocumented)
+    getBasePose(ctx: CameraContext): CameraPose;
+    // (undocumented)
+    readonly id = "first-person";
+    initialPosition?: Vector3;
+    look(deltaYaw: number, deltaPitch: number): void;
+    lookAt(target: Vector3, lerpSpeed?: number): void;
+    get pitch(): number;
+    resetZoom(): void;
+    setLook(yaw: number, pitch: number): void;
+    get yaw(): number;
+    zoom(fov: number): void;
+}
+
+export { FirstPersonPresentation }
+
+export { FirstPersonShooterCoordinator }
+
+export { FirstPersonShooterEntity }
+
+export { FirstPersonShooterInput }
+
+export { FirstPersonState }
+
+export { FirstPersonStateComponent }
+
+// @public
+export interface Fixed2DOptions {
+    position?: Vec3Input;
+    zoom?: number;
+}
+
+// @public
+export class Fixed2DPerspective implements CameraPerspective {
+    constructor(options?: Fixed2DOptions);
+    // (undocumented)
+    readonly defaults: {
+        damping: number;
+    };
+    // (undocumented)
+    getBasePose(_ctx: CameraContext): CameraPose;
+    // (undocumented)
+    readonly id = "fixed-2d";
+}
+
+export { float }
+
+export { floor }
+
+export { Fn }
+
+// @public
+export function focusEntity(uuid: string): boolean;
+
+// @public (undocumented)
+export const FOG_TYPE: unique symbol;
+
+// @public
+export interface FollowTargetOptions {
+    lerpFactor?: number;
+    offset?: Vec3Input;
+    targetKey?: string;
+}
+
+export { fract }
+
+export { FractureOptions }
+
+export { FractureOptionsInput }
+
+// Warning: (ae-forgotten-export) The symbol "IGame" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class Game<TGlobals extends BaseGlobals> implements IGame<TGlobals> {
+    constructor(options: GameOptions<TGlobals>);
+    dispatch<K extends keyof GameEvents>(event: K, payload: GameEvents[K]): void;
+    // (undocumented)
+    dispose(): void;
+    // (undocumented)
+    end(): Promise<void>;
+    readonly experimental: {
+        getRuntime: () => Simulation | null;
+    };
+    getCurrentStage(): Stage | null;
+    // (undocumented)
+    goToStage(): Promise<void>;
+    listen<K extends keyof GameEvents>(event: K, handler: (payload: GameEvents[K]) => void): () => void;
+    // (undocumented)
+    loadStageFromId(stageId: string): Promise<void>;
+    nextStage(options?: StageNavigationOptions): void;
+    // Warning: (ae-forgotten-export) The symbol "DestroyFunction" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    onDestroy(...callbacks: Array<DestroyFunction<ZylemGame<TGlobals>, TGlobals>>): this;
+    onGlobalChange<T = unknown>(path: string, callback: (value: T, stage: Stage | null) => void): this;
+    onGlobalChanges<T extends unknown[] = unknown[]>(paths: string[], callback: (values: T, stage: Stage | null) => void): this;
+    onLoading(callback: (event: GameLoadingEvent) => void): () => void;
+    // Warning: (ae-forgotten-export) The symbol "SetupFunction" needs to be exported by the entry point public.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ZylemGame" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    onSetup(...callbacks: Array<SetupFunction<ZylemGame<TGlobals>, TGlobals>>): this;
+    // Warning: (ae-forgotten-export) The symbol "UpdateFunction" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    onUpdate(...callbacks: Array<UpdateFunction<ZylemGame<TGlobals>, TGlobals>>): this;
+    // (undocumented)
+    options: GameOptions<TGlobals>;
+    // (undocumented)
+    pause(): Promise<void>;
+    previousStage(options?: StageNavigationOptions): void;
+    // (undocumented)
+    refErrorMessage: string;
+    reset(options?: StageNavigationOptions): Promise<void>;
+    // (undocumented)
+    resume(): Promise<void>;
+    // (undocumented)
+    setDeviceProfile(profile: DeviceProfile): this;
+    // (undocumented)
+    setDisplayRuntime(runtime: Partial<ResolveGameConfigRuntime>): this;
+    setInputConfiguration(...configs: GameInputConfig[]): this;
+    // (undocumented)
+    setViewportSize(width: number, height: number): this;
+    // (undocumented)
+    start(): Promise<this>;
+    step(deltaTime?: number): void;
+}
+
+// @public
+export function gameConfig(config: GameConfigLike): GameConfigLike;
+
+// @public (undocumented)
+export type GameConfigJson = Static<typeof GameConfigJsonSchema>;
+
+// @public
+export const GameConfigJsonSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    globals: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnknown>>;
+    debug: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    time: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    input: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TObject<{
+        key: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>>;
+        mouse: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            mapping: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>>;
+            pointerLock: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            sensitivity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        }>>;
+        touch: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TLiteral<"auto">]>>;
+            className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+            joysticks: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+                left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+                    enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                    className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+                    position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                        top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                        right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                        bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                        left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                        transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    }>>;
+                    size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+                    verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+                    emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                    svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                        base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                        thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    }>>;
+                }>, _sinclair_typebox.TLiteral<false>]>>;
+                right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+                    enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                    className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+                    position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                        top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                        right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                        bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                        left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                        transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    }>>;
+                    size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                    horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+                    verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+                    emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                    svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                        base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                        thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    }>>;
+                }>, _sinclair_typebox.TLiteral<false>]>>;
+            }>, _sinclair_typebox.TLiteral<false>]>>;
+            buttons: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+                enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+                position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                    top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                }>>;
+                size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                label: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                svg: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            }>, _sinclair_typebox.TLiteral<false>]>>, _sinclair_typebox.TLiteral<false>]>>;
+        }>>;
+        includeDefaults: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    }>>>;
+    aspectRatio: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString]>>;
+    preset: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    resolution: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TObject<{
+        width: _sinclair_typebox.TNumber;
+        height: _sinclair_typebox.TNumber;
+    }>, _sinclair_typebox.TLiteral<"native">]>>;
+    mobile: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        aspectRatio: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString]>>;
+        preset: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        resolution: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TObject<{
+            width: _sinclair_typebox.TNumber;
+            height: _sinclair_typebox.TNumber;
+        }>, _sinclair_typebox.TLiteral<"native">]>>;
+        controls: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    }>>;
+    fullscreen: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    bodyBackground: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    containerId: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+}>;
+
+// @public (undocumented)
+export type GameConfigLike = Partial<{
+    id: string;
+    globals: Record<string, any>;
+    stages: StageInterface[];
+    debug: boolean;
+    time: number;
+    input: GameInputConfig;
+    aspectRatio: AspectRatioValue | keyof typeof AspectRatio;
+    preset: RetroPresetKey;
+    resolution: ResolutionInput;
+    mobile: GameDeviceConfig;
+    fullscreen: boolean;
+    bodyBackground: string;
+    container: HTMLElement;
+    containerId: string;
+    canvas: HTMLCanvasElement;
+}>;
+
+// @public (undocumented)
+export type GameDeviceConfig = Partial<{
+    aspectRatio: AspectRatioValue | keyof typeof AspectRatio;
+    preset: RetroPresetKey;
+    resolution: ResolutionInput;
+    controls: boolean | DefaultTouchControlsOptions;
+}>;
+
+// @public (undocumented)
+export type GameDeviceConfigJson = Static<typeof GameDeviceConfigJsonSchema>;
+
+// @public
+export const GameDeviceConfigJsonSchema: _sinclair_typebox.TObject<{
+    aspectRatio: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString]>>;
+    preset: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    resolution: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TObject<{
+        width: _sinclair_typebox.TNumber;
+        height: _sinclair_typebox.TNumber;
+    }>, _sinclair_typebox.TLiteral<"native">]>>;
+    controls: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+}>;
+
+// Warning: (ae-forgotten-export) The symbol "GameEntityLifeCycle" needs to be exported by the entry point public.d.ts
+// Warning: (ae-forgotten-export) The symbol "EntityDebugInfo" needs to be exported by the entry point public.d.ts
+// Warning: (ae-forgotten-export) The symbol "RotatableEntityAPI" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implements GameEntityLifeCycle, EntityDebugInfo, MoveableEntity, RotatableEntityAPI {
+    constructor();
+    action<A extends Action>(action: A): A;
+    // Warning: (ae-forgotten-export) The symbol "NodeInterface" needs to be exported by the entry point public.d.ts
+    add(...components: Array<NodeInterface | Mesh | CollisionComponent>): this;
+    // (undocumented)
+    body: SimulationBody | null;
+    // (undocumented)
+    bodyDesc: SimulationBodyDefinition | null;
+    // (undocumented)
+    buildInfo(): Record<string, string>;
+    bundleKey: string | null;
+    // Warning: (ae-forgotten-export) The symbol "CleanupContext" needs to be exported by the entry point public.d.ts
+    protected _cleanup(_params: CleanupContext<this>): void;
+    clearActions(): void;
+    // (undocumented)
+    clone(overrides?: Partial<O>): this;
+    // (undocumented)
+    colliderDesc: SimulationColliderDefinition | undefined;
+    colliderDescs: SimulationColliderDefinition[];
+    // Warning: (ae-forgotten-export) The symbol "CollisionDispatchMetadata" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    _collision(other: GameEntity<O>, globals?: any, dispatch?: CollisionDispatchMetadata): void;
+    // Warning: (ae-forgotten-export) The symbol "CollisionDelegate" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    collisionDelegate: CollisionDelegate<this, O>;
+    // (undocumented)
+    collisionType?: string;
+    compoundMeshes: Mesh[];
+    // (undocumented)
+    create(): this;
+    // (undocumented)
+    custom: Record<string, any>;
+    // (undocumented)
+    debugInfo: Record<string, any>;
+    // (undocumented)
+    debugMaterial: ShaderMaterial | undefined;
+    // Warning: (ae-forgotten-export) The symbol "DestroyContext" needs to be exported by the entry point public.d.ts
+    _destroy(params: DestroyContext<this>): void;
+    dispatch<K extends keyof EntityEvents>(event: K, payload: EntityEvents[K]): void;
+    disposeEvents(): void;
+    // (undocumented)
+    protected eventDelegate: EventEmitterDelegate<EntityEvents>;
+    // (undocumented)
+    finalizeCloneSupport(factory: (options?: Partial<O>) => GameEntity<O>): this;
+    getBehaviorRefs(): BehaviorRef_2[];
+    // (undocumented)
+    getCollisionCallbacks(): Array<(params: CollisionContext<this, O>) => void>;
+    // Warning: (ae-forgotten-export) The symbol "CollisionRegistration" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    getCollisionRegistrations(): Array<CollisionRegistration<this, O>>;
+    getPose(): {
+        position: Vec3;
+        rotation: {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+    } | null;
+    // (undocumented)
+    getPosition: () => Vector | null;
+    // (undocumented)
+    getRotation: () => any;
+    // (undocumented)
+    getVelocity: () => Vector | null;
+    // (undocumented)
+    group: Group | undefined;
+    instanceId: number;
+    isBundled: boolean;
+    isInstanced: boolean;
+    listen<K extends keyof EntityEvents>(event: K, handler: (payload: EntityEvents[K]) => void): () => void;
+    // Warning: (ae-forgotten-export) The symbol "LoadedContext" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    protected _loaded(_params: LoadedContext<this>): Promise<void>;
+    // (undocumented)
+    materials: Material[] | undefined;
+    // (undocumented)
+    mesh: Mesh | undefined;
+    // (undocumented)
+    move: (vector: Vector3) => void;
+    // (undocumented)
+    moveForwardXY: (delta: number, rotation2DAngle: number) => void;
+    // (undocumented)
+    moveX: (delta: number) => void;
+    // (undocumented)
+    moveXY: (deltaX: number, deltaY: number) => void;
+    // (undocumented)
+    moveXZ: (deltaX: number, deltaZ: number) => void;
+    // (undocumented)
+    moveY: (delta: number) => void;
+    // (undocumented)
+    moveZ: (delta: number) => void;
+    // Warning: (ae-forgotten-export) The symbol "CollisionContext" needs to be exported by the entry point public.d.ts
+    // Warning: (ae-forgotten-export) The symbol "CollisionRegistrationOptions" needs to be exported by the entry point public.d.ts
+    onCollision(callback: (params: CollisionContext<this, O>) => void, options?: CollisionRegistrationOptions): this;
+    // (undocumented)
+    onCollision(...callbacks: ((params: CollisionContext<this, O>) => void)[]): this;
+    packKey: string | null;
+    // (undocumented)
+    physicsAttached: boolean;
+    physicsWorldRef: unknown;
+    // (undocumented)
+    resetVelocity: () => void;
+    // (undocumented)
+    rotateEuler: (eulerRotation: Vector3) => void;
+    // (undocumented)
+    rotateInDirection: (moveVector: Vector3) => void;
+    // (undocumented)
+    rotateX: (delta: number) => void;
+    // (undocumented)
+    rotateY: (delta: number) => void;
+    // (undocumented)
+    rotateYEuler: (amount: number) => void;
+    // (undocumented)
+    rotateZ: (delta: number) => void;
+    runAction<A extends Action>(action: A): A;
+    runtimeAttached: boolean;
+    runtimeHandle: number;
+    setPose(input: {
+        position?: Vec3Input;
+        rotation?: {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+    }): boolean;
+    // (undocumented)
+    setPosition: (x: number, y: number, z: number) => void;
+    // (undocumented)
+    setPositionX: (x: number) => void;
+    // (undocumented)
+    setPositionY: (y: number) => void;
+    // (undocumented)
+    setPositionZ: (z: number) => void;
+    // (undocumented)
+    setRotation: (x: number, y: number, z: number) => void;
+    // (undocumented)
+    setRotationDegrees: (x: number, y: number, z: number) => void;
+    // (undocumented)
+    setRotationDegreesX: (x: number) => void;
+    // (undocumented)
+    setRotationDegreesY: (y: number) => void;
+    // (undocumented)
+    setRotationDegreesZ: (z: number) => void;
+    // (undocumented)
+    setRotationX: (x: number) => void;
+    // (undocumented)
+    setRotationY: (y: number) => void;
+    // (undocumented)
+    setRotationZ: (z: number) => void;
+    _setup(params: SetupContext<this>): void;
+    _tickActions(delta: number): void;
+    // (undocumented)
+    transformStore: TransformState;
+    _update(params: UpdateContext<this>): void;
+    // (undocumented)
+    protected updateMaterials(params: any): void;
+    use<O extends Record<string, any>, H extends Record<string, any> = Record<string, never>>(descriptor: BehaviorDescriptor_2<O, H>, options?: Partial<O>): BehaviorHandle_2<O, H>;
+    wasmStageRef: BehaviorRuntime | null;
+    // (undocumented)
+    wrapAround3D: (boundsX: number, boundsY: number, boundsZ: number) => void;
+    // (undocumented)
+    wrapAroundXY: (boundsX: number, boundsY: number) => void;
+}
+
+// @public (undocumented)
+export type GameEntityOptions = {
+    name?: string;
+    color?: Color;
+    size?: Vec3Input;
+    position?: Vec3Input;
+    category?: RenderCategory_2;
+    runtime?: RuntimeEntityOptions;
+    collision?: Partial<CollisionOptions>;
+    material?: Partial<MaterialOptions>;
+    custom?: {
+        [key: string]: any;
+    };
+    collisionType?: string;
+    collisionGroup?: string;
+    collisionFilter?: string[];
+    _builders?: {
+        meshBuilder?: IBuilder | EntityMeshBuilder | null;
+        collisionBuilder?: IBuilder | EntityCollisionBuilder | null;
+        materialBuilder?: MaterialBuilder | null;
+    };
+};
+
+// @public (undocumented)
+export type GameEvents = {
+    'loading:start': GameLoadingPayload;
+    'loading:progress': GameLoadingPayload;
+    'loading:complete': GameLoadingPayload;
+    'paused': {
+        paused: boolean;
+    };
+    'debug': {
+        enabled: boolean;
+    };
+    'state:dispatch': StateDispatchPayload;
+};
+
+// @public (undocumented)
+export interface GameInputConfig {
+    // (undocumented)
+    p1?: GameInputPlayerConfig;
+    // (undocumented)
+    p2?: GameInputPlayerConfig;
+    // (undocumented)
+    p3?: GameInputPlayerConfig;
+    // (undocumented)
+    p4?: GameInputPlayerConfig;
+    // (undocumented)
+    p5?: GameInputPlayerConfig;
+    // (undocumented)
+    p6?: GameInputPlayerConfig;
+    // (undocumented)
+    p7?: GameInputPlayerConfig;
+    // (undocumented)
+    p8?: GameInputPlayerConfig;
+}
+
+// @public (undocumented)
+export type GameInputConfigJson = Static<typeof GameInputConfigSchema>;
+
+// @public
+export const GameInputConfigSchema: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TObject<{
+    key: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>>;
+    mouse: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        mapping: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>>;
+        pointerLock: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        sensitivity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    }>>;
+    touch: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TLiteral<"auto">]>>;
+        className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+        joysticks: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+            left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+                enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+                position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                    top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                }>>;
+                size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+                verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+                emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                    base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                }>>;
+            }>, _sinclair_typebox.TLiteral<false>]>>;
+            right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+                enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+                position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                    top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                }>>;
+                size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+                verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+                emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                    base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                }>>;
+            }>, _sinclair_typebox.TLiteral<false>]>>;
+        }>, _sinclair_typebox.TLiteral<false>]>>;
+        buttons: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+            enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+            position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            }>>;
+            size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            label: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            svg: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>, _sinclair_typebox.TLiteral<false>]>>, _sinclair_typebox.TLiteral<false>]>>;
+    }>>;
+    includeDefaults: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+}>>;
+
+// @public (undocumented)
+export interface GameInputPlayerConfig {
+    // (undocumented)
+    includeDefaults?: boolean;
+    // (undocumented)
+    key?: KeyboardMapping;
+    // (undocumented)
+    mouse?: MouseConfig;
+    // (undocumented)
+    touch?: VirtualTouchConfig;
+}
+
+// @public
+export const GameInputPlayerConfigSchema: _sinclair_typebox.TObject<{
+    key: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>>;
+    mouse: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        mapping: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>>;
+        pointerLock: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        sensitivity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    }>>;
+    touch: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TLiteral<"auto">]>>;
+        className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+        joysticks: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+            left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+                enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+                position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                    top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                }>>;
+                size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+                verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+                emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                    base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                }>>;
+            }>, _sinclair_typebox.TLiteral<false>]>>;
+            right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+                enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+                position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                    top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                    transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                }>>;
+                size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+                horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+                verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+                emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+                svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                    base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                    thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                }>>;
+            }>, _sinclair_typebox.TLiteral<false>]>>;
+        }>, _sinclair_typebox.TLiteral<false>]>>;
+        buttons: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+            enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+            position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            }>>;
+            size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            label: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            svg: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>, _sinclair_typebox.TLiteral<false>]>>, _sinclair_typebox.TLiteral<false>]>>;
+    }>>;
+    includeDefaults: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+}>;
+
+// @public
+export interface GameLoadingEvent {
+    // (undocumented)
+    current?: number;
+    // (undocumented)
+    message: string;
+    // (undocumented)
+    progress: number;
+    // (undocumented)
+    stageIndex?: number;
+    // (undocumented)
+    stageName?: string;
+    // (undocumented)
+    total?: number;
+    // (undocumented)
+    type: 'start' | 'progress' | 'complete';
+}
+
+// @public
+export interface GameLoadingPayload extends LoadingEvent {
+    // (undocumented)
+    stageIndex?: number;
+    // (undocumented)
+    stageName?: string;
+}
+
+export { getCooldown }
+
+export { getCooldownStore }
+
+// @public (undocumented)
+export function getDisplayAspect(preset: RetroPresetKey): number;
+
+export { getEntityFacingAngle2D }
+
+// @public
+export function getGlobal<T = unknown>(path: string): T | undefined;
+
+// @public
+export function getGlobals<T = Record<string, unknown>>(): T;
+
+export { getPosition }
+
+// @public (undocumented)
+export function getPresetResolution(preset: RetroPresetKey, key?: string): RetroResolution | undefined;
+
+// Warning: (ae-forgotten-export) The symbol "RotatableEntity" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function getRotation(entity: RotatableEntity): any;
+
+// @public
+export function getVariable<T = unknown>(target: object, path: string): T | undefined;
+
+export { getVelocity }
+
+// @public
+export function globalChange<T = any>(key: string, callback: (value: T, ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
+
+// @public
+export function globalChanges<T = any>(keys: string[], callback: (values: T[], ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
+
+export { hasAnyWorldBoundary2DHit }
+
+export { hasAnyWorldBoundary3DHit }
+
+// @public (undocumented)
+export interface HemisphereLightOptions extends BaseLightOptions {
+    groundColor?: ColorRepresentation;
+    skyColor?: ColorRepresentation;
+    // (undocumented)
+    type: 'hemisphere';
+}
+
+export { Howl_2 as Howl }
+
+// @public
+export type IconSize = IconSizePreset | number | {
+    width: number;
+    height: number;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ICON_SIZE_PRESETS" needs to be exported by the entry point public.d.ts
+//
+// @public
+export type IconSizePreset = keyof typeof ICON_SIZE_PRESETS;
+
+// @public
+export function initStageStateDispatcher(): () => void;
+
+// @public (undocumented)
+export interface InputGamepad {
+    // (undocumented)
+    axes: {
+        Horizontal: AnalogState;
+        Vertical: AnalogState;
+        SecondaryHorizontal: AnalogState;
+        SecondaryVertical: AnalogState;
+    };
+    // (undocumented)
+    buttons: {
+        A: ButtonState;
+        B: ButtonState;
+        X: ButtonState;
+        Y: ButtonState;
+        Start: ButtonState;
+        Select: ButtonState;
+        L: ButtonState;
+        R: ButtonState;
+    };
+    // (undocumented)
+    directions: {
+        Up: ButtonState;
+        Down: ButtonState;
+        Left: ButtonState;
+        Right: ButtonState;
+    };
+    // (undocumented)
+    playerNumber: InputPlayerNumber;
+    pointer?: {
+        x: number;
+        y: number;
+    };
+    // (undocumented)
+    shoulders: {
+        LTrigger: ButtonState;
+        RTrigger: ButtonState;
+    };
+}
+
+// @public (undocumented)
+export type InputPlayer = `p${InputPlayerNumber}`;
+
+// @public
+export type InputPlayerNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+// @public (undocumented)
+export interface InputProvider {
+    // (undocumented)
+    dispose?(): void;
+    // (undocumented)
+    getInput(delta: number): Partial<InputGamepad>;
+    // (undocumented)
+    getName(): string;
+    // (undocumented)
+    isConnected(): boolean;
+}
+
+// @public (undocumented)
+export type Inputs = Record<InputPlayer, InputGamepad>;
+
+// @public
+export function isGLSLShader(shader: ZylemShader): shader is ZylemShaderObject;
+
+// @public
+export function isManagedRenderEntity(entity: {
+    isInstanced?: boolean;
+    isBundled?: boolean;
+}): boolean;
+
+// @public
+export function isTSLShader(shader: ZylemShader): shader is ZylemTSLShader;
+
+// @public
+export function isWebGPUSupported(): Promise<boolean>;
+
+// @public
+export function joystickBaseSvg(theme?: TouchThemeInput): string;
+
+// @public (undocumented)
+export type JoystickSelection = 'left' | 'right' | 'both' | 'none';
+
+// @public
+export function joystickThumbSvg(theme?: TouchThemeInput): string;
+
+export { JumpConfig2D }
+
+export { JumpConfig3D }
+
+export { JumpContext2D }
+
+export { JumpContext3D }
+
+export { Jumper2DBehavior }
+
+export { Jumper2DBehaviorOptions }
+
+export { Jumper2DEntity }
+
+export { Jumper2DEvent }
+
+export { Jumper2DFSM }
+
+export { Jumper2DState }
+
+export { Jumper3DBehavior }
+
+export { Jumper3DBehaviorOptions }
+
+export { Jumper3DEntity }
+
+export { Jumper3DEvent }
+
+export { Jumper3DFSM }
+
+export { Jumper3DState }
+
+export { JumpInput2D }
+
+export { JumpInput3D }
+
+export { JumpState2D }
+
+export { JumpState3D }
+
+// @public (undocumented)
+export type KeyboardMapping = Record<string, string[]>;
+
+// @public
+export const KeyboardMappingSchema: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>;
+
+export { length_2 as length }
+
+// @public (undocumented)
+export const LIGHT_TYPE: unique symbol;
+
+// @public
+export interface LightShadowOptions {
+    bias?: number;
+    bottom?: number;
+    far?: number;
+    left?: number;
+    mapSize?: number;
+    near?: number;
+    radius?: number;
+    right?: number;
+    top?: number;
+}
+
+// @public (undocumented)
+export const LINE_TYPE: unique symbol;
+
+// @public (undocumented)
+export type LineEntityData = Static<typeof LineEntityDataSchema>;
+
+// @public
+export const LineEntityDataSchema: _sinclair_typebox.TObject<{
+    points: _sinclair_typebox.TArray<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+    color: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    colors: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
+    linewidth: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    worldUnits: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    alphaToCoverage: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    opacity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    transparent: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    dashed: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    dashSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    gapSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    pickThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+}>;
+
+// @public (undocumented)
+export interface LinePickResult {
+    // (undocumented)
+    distance: number;
+    // (undocumented)
+    faceIndex: number;
+    // (undocumented)
+    point: Vector3;
+    // (undocumented)
+    pointOnLine: Vector3;
+}
+
+// @public (undocumented)
+export type LoadingEvent = {
+    type: 'start' | 'progress' | 'complete';
+    message?: string;
+    progress?: number;
+    total?: number;
+    current?: number;
+};
+
+export { max }
+
+// @public
+export function mergeInputConfigs(...configs: GameInputConfig[]): GameInputConfig;
+
+export { min }
+
+export { mix }
+
+export { mod }
+
+// @public (undocumented)
+export interface MouseConfig {
+    mapping?: MouseMapping;
+    pointerLock?: boolean;
+    sensitivity?: number;
+}
+
+// @public
+export const MouseConfigSchema: _sinclair_typebox.TObject<{
+    mapping: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>>;
+    pointerLock: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    sensitivity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+}>;
+
+// @public (undocumented)
+export type MouseMapping = Record<string, string[]>;
+
+// @public
+export const MouseMappingSchema: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>;
+
+export { move }
+
+// @public
+function moveBy_2(opts: MoveByOptions): Action;
+export { moveBy_2 as moveBy }
+
+// @public (undocumented)
+export interface MoveByOptions {
+    duration: number;
+    x?: number;
+    y?: number;
+    z?: number;
+}
+
+export { moveForwardXY }
+
+// @public
+function moveTo_2(opts: MoveToOptions): Action;
+export { moveTo_2 as moveTo }
+
+// @public (undocumented)
+export interface MoveToOptions {
+    duration: number;
+    x: number;
+    y: number;
+    z: number;
+}
+
+export { moveX }
+
+export { moveXY }
+
+export { moveXZ }
+
+export { moveY }
+
+export { moveZ }
+
+export { MultidirectionalSpaceShooterCoordinator }
+
+export { MultidirectionalSpaceShooterEntity }
+
+export { MultidirectionalSpaceShooterInput }
+
+export { normalize }
+
+// @public (undocumented)
+export function normalizeVec2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vec2Components;
+
+// @public (undocumented)
+export function normalizeVec3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vec3Components;
+
+// @public (undocumented)
+export const objectVertexShader = "\nuniform vec2 uvScale;\nvarying vec2 vUv;\n\nvoid main() {\n\tvUv = uv;\n\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n\tgl_Position = projectionMatrix * mvPosition;\n}\n";
+
+// @public (undocumented)
+export type OnEnterParams = Pick<OnHeldParams, 'self' | 'visitor' | 'globals'>;
+
+// @public (undocumented)
+export type OnExitParams = Pick<OnHeldParams, 'self' | 'visitor' | 'globals'>;
+
+// @public
+export function onGlobalChange<T = unknown>(path: string, callback: (value: T) => void): () => void;
+
+// @public
+export function onGlobalChanges<T extends unknown[] = unknown[]>(paths: string[], callback: (values: T) => void): () => void;
+
+// @public (undocumented)
+export type OnHeldParams = {
+    delta: number;
+    self: ZylemZone;
+    visitor: GameEntity<any>;
+    heldTime: number;
+    globals: any;
+};
+
+// Warning: (ae-forgotten-export) The symbol "OnPressAction" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function onPress(): OnPressAction;
+
+// Warning: (ae-forgotten-export) The symbol "OnReleaseAction" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function onRelease(): OnReleaseAction;
+
+// @public
+export function onVariableChange<T = unknown>(target: object, path: string, callback: (value: T) => void): () => void;
+
+// @public
+export function onVariableChanges<T extends unknown[] = unknown[]>(target: object, paths: string[], callback: (values: T) => void): () => void;
+
+// @public
+export type OpacityEntity = {
+    group?: Object3D | null;
+    mesh?: Object3D | null;
+};
+
+// @public
+export function packCollisionGroups(collisionType?: string, collisionFilter?: string[]): number;
+
+// @public
+export function parallel(...actions: Action[]): Action;
+
+// @public (undocumented)
+export function parseResolution(text: string): {
+    width: number;
+    height: number;
+} | null;
+
+// @public (undocumented)
+export const PARTICLE_SYSTEM_TYPE: unique symbol;
+
+export { particleEffect }
+
+export { ParticleEffectDefinition }
+
+export { ParticleEmitterBehavior }
+
+export { ParticleEmitterBehaviorOptions }
+
+export { ParticleEmitterHandle }
+
+export { ParticleMagicAgency }
+
+export { ParticleMagicAlignment }
+
+export { ParticleMagicModifierInput }
+
+export { ParticleMagicModifierOptions }
+
+export { ParticleMagicOrder }
+
+export { ParticleMagicRealityEffect }
+
+export { ParticleMagicTemperament }
+
+export { ParticlePresetMaterialOptions }
+
+export { particlePresets }
+
+// @public
+export type PerspectiveOptions = ThirdPersonOptions | Fixed2DOptions | FirstPersonOptions;
+
+// @public (undocumented)
+export const Perspectives: {
+    readonly FirstPerson: "first-person";
+    readonly ThirdPerson: "third-person";
+    readonly Isometric: "isometric";
+    readonly Flat2D: "flat-2d";
+    readonly Fixed2D: "fixed-2d";
+    readonly TopDown: "top-down";
+};
+
+// @public (undocumented)
+export type PerspectiveType = (typeof Perspectives)[keyof typeof Perspectives];
+
+export { PhysicsBodyComponent }
+
+// @public
+export function pickZylemLine(raycaster: Raycaster, line: ZylemLine, options?: {
+    threshold?: number;
+}): LinePickResult | null;
+
+// @public (undocumented)
+export const PILL_TYPE: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "PillCollisionOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function pillCollision(opts?: PillCollisionOptions): CollisionComponent;
+
+// Warning: (ae-forgotten-export) The symbol "PillMeshOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function pillMesh(opts?: PillMeshOptions): Mesh;
+
+// @public
+export function pingPongBeep(frequency?: number, duration?: number): void;
+
+export { PlainBufferGeometryPayload }
+
+export { PlainFractureOptions }
+
+// @public (undocumented)
+export const PLANE_TYPE: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "PlaneCollisionOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function planeCollision(opts?: PlaneCollisionOptions): CollisionComponent;
+
+export { Platformer2DBehavior }
+
+export { Platformer2DBehaviorOptions }
+
+export { Platformer2DCollisionContext }
+
+export { Platformer2DContext }
+
+export { Platformer2DEntity }
+
+export { Platformer2DEvent }
+
+export { Platformer2DFSM }
+
+export { Platformer2DInputComponent }
+
+export { Platformer2DMovementComponent }
+
+export { Platformer2DState }
+
+export { Platformer2DStateComponent }
+
+export { Platformer3DBehavior }
+
+export { Platformer3DBehaviorOptions }
+
+export { Platformer3DContext }
+
+export { Platformer3DEntity }
+
+export { Platformer3DEvent }
+
+export { Platformer3DFSM }
+
+export { Platformer3DInputComponent }
+
+export { Platformer3DMovementComponent }
+
+export { Platformer3DState }
+
+export { Platformer3DStateComponent }
+
+export { PlatformerCollisionContext }
+
+export { PlayerInput }
+
+// @public (undocumented)
+export interface PointLightOptions extends BaseLightOptions {
+    // (undocumented)
+    castShadow?: boolean;
+    decay?: number;
+    distance?: number;
+    shadow?: Omit<LightShadowOptions, 'left' | 'right' | 'top' | 'bottom'>;
+    // (undocumented)
+    type: 'point';
+}
+
+// @public
+export interface PoseDelta {
+    // (undocumented)
+    fov?: number;
+    // (undocumented)
+    position?: Vector3;
+    // (undocumented)
+    rotation?: Quaternion;
+    // (undocumented)
+    zoom?: number;
+}
+
+export { positionWorld }
+
+export { positionWorldDirection }
+
+export { pow }
+
+export { PrebakeWorkerRequest }
+
+export { PrebakeWorkerResponse }
+
+// @public (undocumented)
+export const PYRAMID_TYPE: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "PyramidCollisionOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function pyramidCollision(opts?: PyramidCollisionOptions): CollisionComponent;
+
+// Warning: (ae-forgotten-export) The symbol "PyramidMeshOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function pyramidMesh(opts?: PyramidMeshOptions): Mesh;
+
+// @public (undocumented)
+export const RECT_TYPE: unique symbol;
+
+export { registerCooldown }
+
+// @public
+export function registerEntityFocusContext(context: EntityFocusContext): () => void;
+
+// @public
+export class RenderBundleManager {
+    // (undocumented)
+    dispose(): void;
+    // (undocumented)
+    getStats(): {
+        bundleCount: number;
+        entityCount: number;
+    };
+    register(entity: GameEntity<any>, _geometry: BufferGeometry, _material: Material, bundleKey: string): boolean;
+    // (undocumented)
+    setScene(scene: Object3D): void;
+    // (undocumented)
+    unregister(entity: GameEntity<any>): void;
+}
+
+// @public
+export type RenderCategory = 'none' | 'environment' | 'pack';
+
+// @public
+export class RenderStrategyManager {
+    // (undocumented)
+    readonly bundles: RenderBundleManager;
+    // (undocumented)
+    dispose(): void;
+    // Warning: (ae-forgotten-export) The symbol "InstanceManager" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    readonly instances: InstanceManager;
+    register(entity: GameEntity<any>): boolean;
+    // (undocumented)
+    setScene(scene: Object3D): void;
+    // (undocumented)
+    unregister(entity: GameEntity<any>): void;
+    // (undocumented)
+    update(interpolationAlpha?: number): void;
+}
+
+// @public
+export function repeat(action: Action, times: number): Action;
+
+// @public
+export function repeatForever(action: Action): Action;
+
+export { resetCooldown }
+
+// @public
+export function resetEntityOpacity(entity: OpacityEntity, opacity?: number, transparent?: boolean): void;
+
+export { resetVelocity }
+
+// @public
+export type ResolutionInput = string | {
+    width: number;
+    height: number;
+} | 'native';
+
+// @public
+export const ResolutionInputSchema: _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TObject<{
+    width: _sinclair_typebox.TNumber;
+    height: _sinclair_typebox.TNumber;
+}>, _sinclair_typebox.TLiteral<"native">]>;
+
+export { resolveAim2D }
+
+// @public
+export function resolveButtonAccent(theme: TouchTheme, slot: VirtualTouchButtonSlot, accentOverride?: string): string;
+
+export { ResolvedAim2D }
+
+// @public (undocumented)
+export interface ResolveGameConfigRuntime {
+    // (undocumented)
+    deviceProfile?: DeviceProfile;
+    // Warning: (ae-forgotten-export) The symbol "ViewportSize" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    viewportSize?: ViewportSize;
+}
+
+// Warning: (ae-forgotten-export) The symbol "RenderCategoryOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function resolveRenderCategory(options?: RenderCategoryOptions | null): RenderCategory;
+
+// @public
+export function resolveTouchTheme(input?: TouchTheme | TouchThemeName): TouchTheme;
+
+// @public (undocumented)
+export type RetroPreset = {
+    displayAspect: number;
+    resolutions: RetroResolution[];
+};
+
+// Warning: (ae-forgotten-export) The symbol "RetroPresets" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type RetroPresetKey = keyof typeof RetroPresets;
+
+// @public (undocumented)
+export type RetroResolution = {
+    key: string;
+    width: number;
+    height: number;
+    notes?: string;
+};
+
+export { Ricochet2DBehavior }
+
+export { Ricochet2DCollisionContext }
+
+export { Ricochet2DEvent }
+
+export { Ricochet2DFSM }
+
+export { Ricochet2DHandle }
+
+export { Ricochet2DOptions }
+
+export { Ricochet2DResult }
+
+export { Ricochet2DState }
+
+export { Ricochet3DBehavior }
+
+export { Ricochet3DCallback }
+
+export { Ricochet3DCollisionContext }
+
+export { Ricochet3DEvent }
+
+export { Ricochet3DFSM }
+
+export { Ricochet3DHandle }
+
+export { Ricochet3DOptions }
+
+export { Ricochet3DResult }
+
+export { Ricochet3DState }
+
+export { RicochetCallback }
+
+// @public
+export function ricochetSound(frequency?: number, duration?: number): void;
+
+// @public
+export function rotateBy(opts: RotateByOptions): Action;
+
+// @public (undocumented)
+export interface RotateByOptions {
+    duration: number;
+    x?: number;
+    y?: number;
+    z?: number;
+}
+
+// @public
+export function rotateEuler(entity: RotatableEntity, rotation: Vector3): void;
+
+// @public
+export function rotateInDirection(entity: RotatableEntity, moveVector: Vector3): void;
+
+// @public
+export function rotateX(entity: RotatableEntity, delta: number): void;
+
+// @public
+export function rotateY(entity: RotatableEntity, delta: number): void;
+
+// @public
+export function rotateYEuler(entity: RotatableEntity, amount: number): void;
+
+// @public
+export function rotateZ(entity: RotatableEntity, delta: number): void;
+
+export { RUNTIME_BOUNDARY_2D_BEHAVIOR_KEY }
+
+export { RUNTIME_DYNAMIC_CIRCLE_BODY_2D_BEHAVIOR_KEY }
+
+export { RUNTIME_GOAL_ZONE_2D_BEHAVIOR_KEY }
+
+export { RUNTIME_PLAYER_INPUT_2D_BEHAVIOR_KEY }
+
+export { RUNTIME_RICOCHET_2D_BEHAVIOR_KEY }
+
+export { RUNTIME_TRIGGER_REGION_2D_BEHAVIOR_KEY }
+
+// @public
+export interface RuntimeBodyOptions {
+    // (undocumented)
+    angularDamping?: number;
+    // (undocumented)
+    canSleep?: boolean;
+    // (undocumented)
+    ccdEnabled?: boolean;
+    // (undocumented)
+    gravityScale?: number;
+    // (undocumented)
+    kind?: StageBodyKindValue;
+    // (undocumented)
+    linearDamping?: number;
+    // (undocumented)
+    lockRotation?: readonly [boolean, boolean, boolean];
+    // (undocumented)
+    lockTranslation?: readonly [boolean, boolean, boolean];
+    // (undocumented)
+    position?: Vec3Input;
+    // (undocumented)
+    rotation?: readonly [number, number, number, number];
+}
+
+export { RuntimeBoundary2DBehavior }
+
+export { RuntimeBoundary2DOptions }
+
+// @public
+export interface RuntimeColliderOptions {
+    // (undocumented)
+    collisionFilter?: string[];
+    // (undocumented)
+    collisionType?: string;
+    // (undocumented)
+    friction?: number;
+    // (undocumented)
+    offset?: Vec3Input;
+    // (undocumented)
+    restitution?: number;
+    // (undocumented)
+    sensor?: boolean;
+}
+
+// @public
+export interface RuntimeCollisionBundle {
+    // (undocumented)
+    body: StageBodyConfig;
+    // (undocumented)
+    colliders: StageColliderConfig[];
+}
+
+export { RuntimeDynamicCircleBody2DBehavior }
+
+export { RuntimeDynamicCircleBody2DHandle }
+
+export { RuntimeDynamicCircleBody2DOptions }
+
+export { RuntimeGoalZone2DBehavior }
+
+export { RuntimeGoalZone2DEvent }
+
+export { RuntimeGoalZone2DHandle }
+
+export { RuntimeGoalZone2DOptions }
+
+export { RuntimePlayerInput2DBehavior }
+
+export { RuntimePlayerInput2DOptions }
+
+export { RuntimeRicochet2DBehavior }
+
+export { RuntimeRicochet2DEvent }
+
+export { RuntimeRicochet2DHandle }
+
+export { RuntimeRicochet2DOptions }
+
+export { RuntimeTriggerRegion2DBehavior }
+
+export { RuntimeTriggerRegion2DEvent }
+
+export { RuntimeTriggerRegion2DHandle }
+
+export { RuntimeTriggerRegion2DOptions }
+
+// @public
+export type ScreenAnchor = 'top-left' | 'top-center' | 'top-right' | 'center-left' | 'center' | 'center-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+
+export { ScreenVisibilityBehavior }
+
+export { ScreenVisibilityChangeContext }
+
+export { ScreenVisibilityFSM }
+
+export { ScreenVisibilityHandle }
+
+export { ScreenVisibilityOptions }
+
+export { ScreenVisibilitySize }
+
+export { ScreenVisibilitySnapshot }
+
+export { ScreenWrapBehavior }
+
+export { ScreenWrapEvent }
+
+export { ScreenWrapFSM }
+
+export { ScreenWrapOptions }
+
+export { ScreenWrapState }
+
+export { SemanticParticlePresetOptions }
+
+// @public
+export function sequence(...actions: Action[]): Action;
+
+// @public
+export function setCameraFeed(entity: StageEntity, camera: CameraWrapper, options?: CameraFeedOptions): void;
+
+// @public (undocumented)
+export function setDebugTool(tool: DebugTools): void;
+
+// @public
+export function setGlobal(path: string, value: unknown): void;
+
+// @public (undocumented)
+export function setPaused(paused: boolean): void;
+
+export { setPosition }
+
+export { setPositionX }
+
+export { setPositionY }
+
+export { setPositionZ }
+
+// @public
+export function setRotation(entity: RotatableEntity, x: number, y: number, z: number): void;
+
+// @public
+export function setRotationDegrees(entity: RotatableEntity, x: number, y: number, z: number): void;
+
+// @public
+export function setRotationDegreesX(entity: RotatableEntity, x: number): void;
+
+// @public
+export function setRotationDegreesY(entity: RotatableEntity, y: number): void;
+
+// @public
+export function setRotationDegreesZ(entity: RotatableEntity, z: number): void;
+
+// @public
+export function setRotationX(entity: RotatableEntity, x: number): void;
+
+// @public
+export function setRotationY(entity: RotatableEntity, y: number): void;
+
+// @public
+export function setRotationZ(entity: RotatableEntity, z: number): void;
+
+// @public (undocumented)
+export function setSelectedEntity(entity: GameEntity<any> | null): void;
+
+// @public (undocumented)
+export function setStageFrameProfilerEnabled(value: boolean): void;
+
+// Warning: (ae-forgotten-export) The symbol "GlobalRecord" needs to be exported by the entry point public.d.ts
+//
+// @public
+export interface SetupContext<T, TGlobals extends GlobalRecord = any> {
+    // Warning: (ae-forgotten-export) The symbol "ICamera" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    camera?: ICamera;
+    // (undocumented)
+    game?: IGame<TGlobals>;
+    // (undocumented)
+    globals: TGlobals;
+    // (undocumented)
+    inputs?: Inputs;
+    // (undocumented)
+    me: T;
+    // Warning: (ae-forgotten-export) The symbol "IStage" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    stage?: IStage;
+}
+
+// @public
+export function setVariable(target: object, path: string, value: unknown): void;
+
+export { Shooter2DAimFireInput }
+
+export { Shooter2DBehavior }
+
+export { Shooter2DBehaviorOptions }
+
+export { Shooter2DFireArgs }
+
+export { Shooter2DHandle }
+
+export { Shooter2DProjectileFactory }
+
+export { Shooter2DSourceEntity }
+
+export { Shooter2DStageLike }
+
+export { Shooter2DStateComponent }
+
+export { Shooter2DTarget }
+
+export { Simulation }
+
+// Warning: (ae-forgotten-export) The symbol "PhysicsRenderPoseProvider" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class SimulationBody implements PhysicsRenderPoseProvider {
+    constructor(simulation: Simulation, handle: EntityHandle, clock: SimulationStepClock);
+    // (undocumented)
+    angvel(): PhysicsVector3;
+    // (undocumented)
+    applyImpulse(impulse: PhysicsVector3, _wakeUp?: boolean): void;
+    // (undocumented)
+    bodyType(): number;
+    // Warning: (ae-forgotten-export) The symbol "PhysicsPoseHistory" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    getPoseHistory(): PhysicsPoseHistory;
+    // Warning: (ae-forgotten-export) The symbol "PhysicsPose" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    getRenderPose(alpha: number): PhysicsPose;
+    // (undocumented)
+    readonly handle: EntityHandle;
+    // (undocumented)
+    isEnabled(): boolean;
+    isRenderSleeping(): boolean;
+    // (undocumented)
+    isSleeping(): boolean;
+    // (undocumented)
+    linvel(): PhysicsVector3;
+    // (undocumented)
+    mass(): number;
+    // Warning: (ae-forgotten-export) The symbol "PhysicsQuaternion" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    rotation(): PhysicsQuaternion;
+    // (undocumented)
+    setAngvel(velocity: PhysicsVector3, _wakeUp?: boolean): void;
+    setGravityScale(_scale: number, _wakeUp?: boolean): void;
+    setLinearDamping(_damping: number): void;
+    // (undocumented)
+    setLinvel(velocity: PhysicsVector3, _wakeUp?: boolean): void;
+    // (undocumented)
+    setRotation(rotation: PhysicsQuaternion, _wakeUp?: boolean): void;
+    // (undocumented)
+    setTranslation(translation: PhysicsVector3, _wakeUp?: boolean): void;
+    // Warning: (ae-forgotten-export) The symbol "PhysicsVector3" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    translation(): PhysicsVector3;
+    writeRenderPose(alpha: number, outPosition: {
+        x: number;
+        y: number;
+        z: number;
+    }, outRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): void;
+}
+
+export { SimulationBodyDefinition }
+
+export { SimulationColliderDefinition }
+
+export { SimulationEvent }
+
+export { SimulationFrame }
+
+export { SimulationOptions }
+
+// @public
+export interface SimulationStepClock {
+    // (undocumented)
+    steps: number;
+}
+
+export { sin }
+
+export { smoothstep }
+
+// @public (undocumented)
+export const SPHERE_TYPE: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "SphereCollisionOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function sphereCollision(opts?: SphereCollisionOptions): CollisionComponent;
+
+// Warning: (ae-forgotten-export) The symbol "SphereMeshOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function sphereMesh(opts?: SphereMeshOptions): Mesh;
+
+// @public (undocumented)
+export interface SpotLightOptions extends BaseLightOptions {
+    angle?: number;
+    // (undocumented)
+    castShadow?: boolean;
+    decay?: number;
+    distance?: number;
+    penumbra?: number;
+    shadow?: Omit<LightShadowOptions, 'left' | 'right' | 'top' | 'bottom'>;
+    target?: Vec3_2;
+    // (undocumented)
+    type: 'spot';
+}
+
+// @public (undocumented)
+export const SPRITE_TYPE: unique symbol;
+
+// @public (undocumented)
+export type SpriteAnimation = {
+    name: string;
+    frames: string[];
+    speed: number | number[];
+    loop: boolean;
+};
+
+// @public (undocumented)
+export type SpriteEntityData = Static<typeof SpriteEntityDataSchema>;
+
+// @public
+export const SpriteEntityDataSchema: _sinclair_typebox.TObject<{
+    imagePath: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    width: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    height: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+}>;
+
+// @public (undocumented)
+export type SpriteImage = {
+    name: string;
+    file: string;
+};
+
+// @public
+export const STAGE_STATE_CHANGE = "STAGE_STATE_CHANGE";
+
+// @public
+export const StageAssetLoaderConfigSchema: _sinclair_typebox.TObject<{
+    gltf: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        meshopt: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        ktx2TranscoderPath: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    }>>;
+}>;
+
+// @public (undocumented)
+export type StageBlueprint = Static<typeof StageSchema>;
+
+export { StageBodyConfig }
+
+export { StageBodyInfo }
+
+export { StageBodyKind }
+
+export { StageBodyKindValue }
+
+export { StageBoundaryDim }
+
+export { StageColliderConfig }
+
+export { StageColliderShape }
+
+// @public
+export function stageConfig(config: StageConfigLike): StageConfigLike;
+
+// @public (undocumented)
+export type StageConfigJson = Static<typeof StageConfigJsonSchema>;
+
+// @public
+export const StageConfigJsonSchema: _sinclair_typebox.TObject<{
+    inputs: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>>>;
+    backgroundColor: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+    backgroundImage: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNull]>>;
+    gravity: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+    variables: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnknown>>;
+    physicsRate: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    assetLoaders: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        gltf: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            meshopt: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            ktx2TranscoderPath: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>>;
+    }>>;
+    defaultLighting: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+}>;
+
+// @public
+export type StageConfigLike = Partial<{
+    inputs: Record<string, string[]>;
+    backgroundColor: Color | string;
+    backgroundImage: string | null;
+    backgroundShader: ZylemShader;
+    gravity: Vector3 | Vec3Components;
+    variables: Record<string, any>;
+    physicsRate: number;
+    assetLoaders: StageAssetLoaderConfig;
+    defaultLighting: boolean;
+    postProcessingEffects: ZylemPostEffect[];
+}>;
+
+// @public
+export interface StageConfigPayload {
+    // (undocumented)
+    backgroundColor: string;
+    // (undocumented)
+    backgroundImage: string | null;
+    // (undocumented)
+    gravity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    inputs: Record<string, string[]>;
+    // (undocumented)
+    variables: Record<string, unknown>;
+}
+
+export { StageDebugRender }
+
+// Warning: (ae-forgotten-export) The symbol "Entity" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export interface StageEntity extends Entity {
+    // (undocumented)
+    body: SimulationBody;
+    // (undocumented)
+    controlledRotation: boolean;
+    // (undocumented)
+    group: Group;
+    // (undocumented)
+    instanceId: number;
+    // (undocumented)
+    isBundled?: boolean;
+    // (undocumented)
+    isInstanced?: boolean;
+    // (undocumented)
+    markedForRemoval: boolean;
+    // (undocumented)
+    mesh: Mesh;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    uuid: string;
+}
+
+export { StageEvent }
+
+// @public (undocumented)
+export type StageEvents = {
+    'stage:loaded': {
+        stageId: string;
+    };
+    'stage:unloaded': {
+        stageId: string;
+    };
+    'stage:variable:changed': {
+        key: string;
+        value: unknown;
+    };
+};
+
+export { StageEventType }
+
+// @public
+export const StageGLTFAssetLoaderConfigSchema: _sinclair_typebox.TObject<{
+    meshopt: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    ktx2TranscoderPath: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+}>;
+
+// @public (undocumented)
+export type StageJson = Static<typeof StageJsonSchema>;
+
+// @public
+export const StageJsonSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    entities: _sinclair_typebox.TArray<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        type: _sinclair_typebox.TLiteral<"text">;
+        position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+        data: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            value: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            color: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            fontSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            fontFamily: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>>;
+    }>, _sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        type: _sinclair_typebox.TLiteral<"sprite">;
+        position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+        data: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            imagePath: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            width: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            height: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        }>>;
+    }>, _sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        type: _sinclair_typebox.TLiteral<"line">;
+        position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+        data: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            points: _sinclair_typebox.TArray<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+            color: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            colors: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
+            linewidth: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            worldUnits: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            alphaToCoverage: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            opacity: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            transparent: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            dashed: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            dashSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            gapSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            pickThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        }>>;
+    }>, _sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        type: _sinclair_typebox.TString;
+        position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+        data: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnknown>>;
+    }>]>>;
+    assets: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
+}>;
+
+// @public (undocumented)
+export const StageManager: {
+    staticRegistry: Map<string, {
+        name?: string | undefined;
+        assets?: string[] | undefined;
+        id: string;
+        entities: {
+            position?: [number, number] | undefined;
+            data?: {
+                [x: string]: any;
+            } | undefined;
+            id: string;
+            type: string;
+        }[];
+    }>;
+    registerStaticStage(id: string, blueprint: StageBlueprint): void;
+    loadStageData(stageId: string): Promise<StageBlueprint>;
+    transitionForward(nextStageId: string, loadStaticStage?: (id: string) => Promise<StageBlueprint>): Promise<void>;
+    preloadNext(stageId: string, loadStaticStage?: (id: string) => Promise<StageBlueprint>): Promise<void>;
+};
+
+// @public
+export interface StageNavigationOptions {
+    transition?: StageTransitionConfig;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemStageConfig" needs to be exported by the entry point public.d.ts
+// Warning: (ae-forgotten-export) The symbol "StageOptionItem" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type StageOptions = [] | [Partial<ZylemStageConfig>, ...StageOptionItem[]];
+
+export { StagePose }
+
+export { StageRaycastHit }
+
+export { StageRenderSlot }
+
+export { StageRicochetDim }
+
+export { StageRicochetReflection }
+
+// @public
+export const StageSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    name: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    entities: _sinclair_typebox.TArray<_sinclair_typebox.TObject<{
+        id: _sinclair_typebox.TString;
+        type: _sinclair_typebox.TString;
+        position: _sinclair_typebox.TOptional<_sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>>;
+        data: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TAny>>;
+    }>>;
+    assets: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
+}>;
+
+// @public (undocumented)
+export const stageState: {
+    previous: StageBlueprint | null;
+    current: StageBlueprint | null;
+    next: StageBlueprint | null;
+    isLoading: boolean;
+};
+
+// @public
+export interface StageStateChangeEvent {
+    // Warning: (ae-forgotten-export) The symbol "StageStateInterface" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    entities: StageStateInterface['entities'];
+    // (undocumented)
+    variables: StageStateInterface['variables'];
+}
+
+export { StageTopDownPlane }
+
+// @public
+export interface StageTransitionConfig {
+    duration?: number;
+    easing?: StageTransitionEasing | ((t: number) => number);
+    onComplete?: () => void;
+    shader?: ZylemTransitionShader | {
+        shader: ZylemTransitionShader;
+    };
+}
+
+// @public
+export type StageTransitionEasing = 'linear' | 'easeInOut';
+
+// @public (undocumented)
+export const standardShader: {
+    vertex: string;
+    fragment: string;
+};
+
+// @public
+export interface StateDispatchPayload {
+    // (undocumented)
+    config?: {
+        id: string;
+        aspectRatio: number;
+        fullscreen: boolean;
+        bodyBackground: string | undefined;
+        internalResolution: {
+            width: number;
+            height: number;
+        } | undefined;
+        debug: boolean;
+    } | null;
+    // (undocumented)
+    entities?: EntityConfigPayload[] | null;
+    // (undocumented)
+    path: string;
+    // (undocumented)
+    previousValue?: unknown;
+    // (undocumented)
+    scope: 'game' | 'stage' | 'entity';
+    // (undocumented)
+    stageConfig?: StageConfigPayload | null;
+    // (undocumented)
+    value: unknown;
+}
+
+export { step }
+
+// @public
+export interface TemplateFactory<E extends GameEntity<O>, O extends GameEntityOptions = GameEntityOptions> {
+    generate(count: number): E[];
+    readonly template: E;
+}
+
+// @public (undocumented)
+export const TEXT_TYPE: unique symbol;
+
+// @public (undocumented)
+export type TextEntityData = Static<typeof TextEntityDataSchema>;
+
+// @public
+export const TextEntityDataSchema: _sinclair_typebox.TObject<{
+    value: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    color: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    fontSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    fontFamily: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+}>;
+
+// @public
+export interface ThirdPersonOptions {
+    distance?: number;
+    fov?: number;
+    height?: number;
+    initialLookAt?: Vec3Input;
+    initialPosition?: Vec3Input;
+    minDistance?: number;
+    paddingFactor?: number;
+    shoulderOffset?: number;
+    targetKey?: string;
+    trailBufferSize?: number;
+    trailDelay?: number;
+}
+
+// @public
+export class ThirdPersonPerspective implements CameraPerspective {
+    constructor(options?: ThirdPersonOptions);
+    readonly defaults: {
+        damping: number;
+    };
+    // (undocumented)
+    getBasePose(ctx: CameraContext): CameraPose;
+    // (undocumented)
+    readonly id = "third-person";
+}
+
+// Warning: (ae-forgotten-export) The symbol "ThrottleAction" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function throttle(opts: ThrottleOptions): ThrottleAction;
+
+// @public (undocumented)
+export interface ThrottleOptions {
+    duration: number;
+}
+
+export { ThrusterBehavior }
+
+export { ThrusterBehaviorOptions }
+
+export { ThrusterEntity }
+
+export { ThrusterEvent }
+
+export { ThrusterFSM }
+
+export { ThrusterFSMContext }
+
+export { ThrusterInputComponent }
+
+export { ThrusterMovementComponent }
+
+export { ThrusterState }
+
+export { ThrusterStateComponent }
+
+export { tickCooldowns }
+
+export { time }
+
+export { TopDownMovementBehavior }
+
+export { TopDownMovementBehaviorOptions }
+
+export { TopDownMovementComponent }
+
+export { TopDownMovementEntity }
+
+export { TopDownMovementHandle }
+
+export { TopDownMovementInputComponent }
+
+export { TopDownMovementStateComponent }
+
+export { TopDownShooterCoordinator }
+
+export { TopDownShooterEntity }
+
+export { TopDownShooterInput }
+
+// @public (undocumented)
+export function toThreeVector2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vector2;
+
+// @public (undocumented)
+export function toThreeVector3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vector3;
+
+// @public
+export function touchButtonSvg(label: string, options?: TouchButtonSvgOptions): string;
+
+// @public (undocumented)
+export interface TouchButtonSvgOptions {
+    accent?: string;
+    theme?: TouchThemeInput;
+}
+
+// @public
+export interface TouchTheme {
+    baseFill: string;
+    buttonAccents?: Partial<Record<VirtualTouchButtonSlot, string>>;
+    defaultButtonAccent: string;
+    joystickAccentFill: string;
+    joystickInnerStroke: string;
+    joystickStroke: string;
+    joystickTabFill: string;
+    thumbFill: string;
+    thumbInnerFill: string;
+    thumbStroke: string;
+}
+
+// @public (undocumented)
+export type TouchThemeInput = TouchTheme | TouchThemeName;
+
+// @public (undocumented)
+export type TouchThemeName = keyof typeof touchThemes;
+
+// @public
+export const touchThemes: {
+    readonly default: TouchTheme;
+    readonly lagoon: TouchTheme;
+};
+
+export { TransformComponent }
+
+// @public
+export interface TransformLike {
+    // (undocumented)
+    position: Vector3;
+    // (undocumented)
+    rotation?: Quaternion;
+}
+
+export { TransformState }
+
+export { uniform }
+
+export { updateBoundaryRicochet }
+
+// @public
+export type UpdateContext<T, TGlobals extends GlobalRecord = any> = {
+    me: T;
+    delta: number;
+    inputs: Inputs;
+    globals: TGlobals;
+    camera: ICamera;
+    stage?: IStage;
+    game?: IGame<TGlobals>;
+};
+
+// @public
+export function useArrowsForAxes(player: InputPlayer): GameInputConfig;
+
+// @public
+export function useArrowsForDirections(player: InputPlayer): GameInputConfig;
+
+// @public
+export function useArrowsForSecondaryAxes(player: InputPlayer): GameInputConfig;
+
+export { useBehavior }
+
+// @public
+export function useIJKLForAxes(player: InputPlayer): GameInputConfig;
+
+// @public
+export function useIJKLForDirections(player: InputPlayer): GameInputConfig;
+
+// @public
+export function useMouse(player: InputPlayer, options?: {
+    sensitivity?: number;
+}): GameInputConfig;
+
+// @public
+export function useMouseLook(player: InputPlayer, options?: {
+    sensitivity?: number;
+}): GameInputConfig;
+
+// @public
+export function usesManagedRenderPath(options?: RenderCategoryOptions | null): boolean;
+
+// @public
+export function useVirtualControls(player: InputPlayer, options?: VirtualTouchConfig): GameInputConfig;
+
+// @public
+export function useWASDForAxes(player: InputPlayer): GameInputConfig;
+
+// @public
+export function useWASDForDirections(player: InputPlayer): GameInputConfig;
+
+export { uv }
+
+// @public
+export function variableChange<T = any>(key: string, callback: (value: T, ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
+
+// @public
+export function variableChanges<T = any>(keys: string[], callback: (values: T[], ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
+
+// @public (undocumented)
+export type Vec2 = Vector2;
+
+export { vec2 }
+
+// @public (undocumented)
+export const VEC2_ONE: Readonly<Vec2Components>;
+
+// @public (undocumented)
+export const VEC2_ZERO: Readonly<Vec2Components>;
+
+// @public (undocumented)
+export type Vec2Components = {
+    x: number;
+    y: number;
+};
+
+// Warning: (ae-forgotten-export) The symbol "Vec2Tuple" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type Vec2Input = Vec2 | {
+    x?: number;
+    y?: number;
+} | Vec2Tuple;
+
+// @public (undocumented)
+export type Vec3 = Vector3 | Vec3Components;
+
+export { vec3 }
+
+// @public (undocumented)
+export const VEC3_ONE: Readonly<Vec3Components>;
+
+// @public (undocumented)
+export const VEC3_ZERO: Readonly<Vec3Components>;
+
+// @public (undocumented)
+export type Vec3Components = {
+    x: number;
+    y: number;
+    z: number;
+};
+
+// @public
+export const Vec3ComponentsSchema: _sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>;
+
+// Warning: (ae-forgotten-export) The symbol "Vec3Tuple" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export type Vec3Input = Vec3 | {
+    x?: number;
+    y?: number;
+    z?: number;
+} | Vec3Tuple;
+
+export { Vec3Like }
+
+export { vec4 }
+
+// @public @deprecated (undocumented)
+export type Vect3 = Vec3;
+
+// @public
+export const Vector2Schema: _sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>;
+
+// @public
+export const Vector3TupleSchema: _sinclair_typebox.TTuple<[_sinclair_typebox.TNumber, _sinclair_typebox.TNumber, _sinclair_typebox.TNumber]>;
+
+// Warning: (ae-forgotten-export) The symbol "Vessel" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function vessel(...args: Array<BaseNode>): Vessel;
+
+export { ViewmodelConfig }
+
+// @public
+export interface Viewport {
+    // (undocumented)
+    height: number;
+    // (undocumented)
+    width: number;
+    // (undocumented)
+    x: number;
+    // (undocumented)
+    y: number;
+}
+
+// @public (undocumented)
+export interface VirtualTouchButtonConfig {
+    // (undocumented)
+    className?: string;
+    // (undocumented)
+    enabled?: boolean;
+    // (undocumented)
+    label?: string;
+    // (undocumented)
+    position?: VirtualTouchPosition;
+    // (undocumented)
+    size?: number;
+    // (undocumented)
+    style?: VirtualTouchStyle;
+    svg?: string;
+}
+
+// @public
+export const VirtualTouchButtonConfigSchema: _sinclair_typebox.TObject<{
+    enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+    position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    }>>;
+    size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    label: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    svg: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+}>;
+
+// @public (undocumented)
+export type VirtualTouchButtonsConfig = Partial<Record<VirtualTouchButtonSlot, VirtualTouchButtonConfig | false>>;
+
+// @public
+export const VirtualTouchButtonsConfigSchema: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+    enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+    position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    }>>;
+    size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    label: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    svg: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+}>, _sinclair_typebox.TLiteral<false>]>>;
+
+// @public (undocumented)
+export type VirtualTouchButtonSlot = 'A' | 'B' | 'X' | 'Y' | 'Start' | 'Select' | 'L' | 'R' | 'LTrigger' | 'RTrigger' | 'Up' | 'Down' | 'Left' | 'Right';
+
+// @public (undocumented)
+export interface VirtualTouchConfig {
+    // (undocumented)
+    buttons?: VirtualTouchButtonsConfig | false;
+    // (undocumented)
+    className?: string;
+    // (undocumented)
+    enabled?: boolean | 'auto';
+    // (undocumented)
+    joysticks?: VirtualTouchJoysticksConfig | false;
+    // (undocumented)
+    style?: VirtualTouchStyle;
+}
+
+// @public
+export const VirtualTouchConfigSchema: _sinclair_typebox.TObject<{
+    enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TLiteral<"auto">]>>;
+    className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+    joysticks: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+        left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+            enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+            position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            }>>;
+            size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+            verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+            emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            }>>;
+        }>, _sinclair_typebox.TLiteral<false>]>>;
+        right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+            enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+            position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+                transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            }>>;
+            size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+            horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+            verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+            emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+            svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+                base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+                thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            }>>;
+        }>, _sinclair_typebox.TLiteral<false>]>>;
+    }>, _sinclair_typebox.TLiteral<false>]>>;
+    buttons: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+        enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+        position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>>;
+        size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        label: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        svg: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    }>, _sinclair_typebox.TLiteral<false>]>>, _sinclair_typebox.TLiteral<false>]>>;
+}>;
+
+// @public (undocumented)
+export interface VirtualTouchJoystickConfig {
+    // (undocumented)
+    className?: string;
+    // (undocumented)
+    deadzone?: number;
+    // (undocumented)
+    directionThreshold?: number;
+    // (undocumented)
+    emitDirections?: boolean;
+    // (undocumented)
+    enabled?: boolean;
+    // (undocumented)
+    horizontalAxis?: 'Horizontal' | 'SecondaryHorizontal';
+    // (undocumented)
+    maxDistance?: number;
+    // (undocumented)
+    position?: VirtualTouchPosition;
+    // (undocumented)
+    size?: number;
+    // (undocumented)
+    style?: VirtualTouchStyle;
+    // (undocumented)
+    svg?: {
+        base?: string;
+        thumb?: string;
+    };
+    // (undocumented)
+    thumbSize?: number;
+    // (undocumented)
+    verticalAxis?: 'Vertical' | 'SecondaryVertical';
+}
+
+// @public
+export const VirtualTouchJoystickConfigSchema: _sinclair_typebox.TObject<{
+    enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+    position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+        transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    }>>;
+    size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+    horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+    verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+    emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+    svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    }>>;
+}>;
+
+// @public (undocumented)
+export interface VirtualTouchJoysticksConfig {
+    // (undocumented)
+    left?: VirtualTouchJoystickConfig | false;
+    // (undocumented)
+    right?: VirtualTouchJoystickConfig | false;
+}
+
+// @public
+export const VirtualTouchJoysticksConfigSchema: _sinclair_typebox.TObject<{
+    left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+        enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+        position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>>;
+        size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+        verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+        emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>>;
+    }>, _sinclair_typebox.TLiteral<false>]>>;
+    right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+        enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        className: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        style: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>>;
+        position: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+            transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>>;
+        size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        thumbSize: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        maxDistance: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        deadzone: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        directionThreshold: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        horizontalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Horizontal">, _sinclair_typebox.TLiteral<"SecondaryHorizontal">]>>;
+        verticalAxis: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"Vertical">, _sinclair_typebox.TLiteral<"SecondaryVertical">]>>;
+        emitDirections: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
+        svg: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            base: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+            thumb: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        }>>;
+    }>, _sinclair_typebox.TLiteral<false>]>>;
+}>;
+
+// @public (undocumented)
+export interface VirtualTouchPosition {
+    // (undocumented)
+    bottom?: string | number;
+    // (undocumented)
+    left?: string | number;
+    // (undocumented)
+    right?: string | number;
+    // (undocumented)
+    top?: string | number;
+    // (undocumented)
+    transform?: string;
+}
+
+// @public
+export const VirtualTouchPositionSchema: _sinclair_typebox.TObject<{
+    top: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+    right: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+    bottom: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+    left: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+    transform: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+}>;
+
+// @public (undocumented)
+export type VirtualTouchStyle = Partial<Record<string, string | number>>;
+
+// @public
+export const VirtualTouchStyleSchema: _sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TNumber]>>;
+
+export { VoronoiOptions }
+
+export { WorldBoundary2DBehavior }
+
+export { WorldBoundary2DBounds }
+
+export { WorldBoundary2DEvent }
+
+export { WorldBoundary2DFSM }
+
+export { WorldBoundary2DHandle }
+
+export { WorldBoundary2DHit }
+
+export { WorldBoundary2DHits }
+
+export { WorldBoundary2DOptions }
+
+export { WorldBoundary2DPosition }
+
+export { WorldBoundary2DState }
+
+export { WorldBoundary3DBehavior }
+
+export { WorldBoundary3DBounds }
+
+export { WorldBoundary3DEvent }
+
+export { WorldBoundary3DFSM }
+
+export { WorldBoundary3DHandle }
+
+export { WorldBoundary3DHit }
+
+export { WorldBoundary3DHits }
+
+export { WorldBoundary3DOptions }
+
+export { WorldBoundary3DPosition }
+
+export { WorldBoundary3DState }
+
+export { wrapAround3D }
+
+export { wrapAroundXY }
+
+// @public (undocumented)
+export const ZONE_TYPE: unique symbol;
+
+// Warning: (ae-forgotten-export) The symbol "ZoneCollisionOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export function zoneCollision(opts?: ZoneCollisionOptions): CollisionComponent;
+
+// Warning: (ae-forgotten-export) The symbol "ZylemActorOptions" needs to be exported by the entry point public.d.ts
+// Warning: (ae-forgotten-export) The symbol "EntityLoaderDelegate" needs to be exported by the entry point public.d.ts
+// Warning: (ae-forgotten-export) The symbol "DebugInfoProvider" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class ZylemActor extends GameEntity<ZylemActorOptions> implements EntityLoaderDelegate, DebugInfoProvider {
+    constructor(options?: ZylemActorOptions);
+    // (undocumented)
+    actorDestroy(): void;
+    // (undocumented)
+    actorUpdate(params: UpdateContext<ZylemActorOptions>): void;
+    // (undocumented)
+    _cleanup(params: CleanupContext<this>): void;
+    // (undocumented)
+    get collisionSource(): Object3D | null;
+    // (undocumented)
+    controlledRotation: boolean;
+    // (undocumented)
+    create(): this;
+    // (undocumented)
+    data(): any;
+    // (undocumented)
+    getDebugInfo(): Record<string, any>;
+    // (undocumented)
+    hasWarnedDynamicTrimesh: boolean;
+    // (undocumented)
+    load(): void;
+    // (undocumented)
+    needsDeferredModelCollision(): boolean;
+    // (undocumented)
+    get object(): Object3D | null;
+    // Warning: (ae-forgotten-export) The symbol "AnimationOptions" needs to be exported by the entry point public.d.ts
+    //
+    // (undocumented)
+    playAnimation(animationOptions: AnimationOptions): void;
+    // (undocumented)
+    synchronizeRuntimeCollider(): void;
+    // (undocumented)
+    static type: symbol;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemBoxOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class ZylemBox extends GameEntity<ZylemBoxOptions> {
+    constructor(options?: ZylemBoxOptions);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    static type: symbol;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemConeOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export class ZylemCone extends GameEntity<ZylemConeOptions> {
+    constructor(options?: ZylemConeOptions);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    static type: symbol;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemCylinderOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export class ZylemCylinder extends GameEntity<ZylemCylinderOptions> {
+    constructor(options?: ZylemCylinderOptions);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    static type: symbol;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemDiskOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class ZylemDisk extends GameEntity<ZylemDiskOptions> {
+    constructor(options?: ZylemDiskOptions);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    static type: symbol;
+}
+
+// @public
+export const zylemEventBus: mitt.Emitter<ZylemEvents>;
+
+// @public (undocumented)
+export type ZylemEvents = GameEvents & StageEvents & EntityEvents;
+
+// Warning: (ae-forgotten-export) The symbol "ZylemFogGameOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export class ZylemFog extends GameEntity<ZylemFogGameOptions> {
+    constructor(options?: ZylemFogOptions);
+    attachToScene(scene: Scene): void;
+    // (undocumented)
+    protected _cleanup(params: CleanupContext<this>): void;
+    // (undocumented)
+    create(): this;
+    threeFog: Fog | FogExp2 | null;
+    // (undocumented)
+    static type: symbol;
+    _update(params: UpdateContext<this>): void;
+}
+
+// @public
+export interface ZylemFogHeightOptions {
+    enabled?: boolean;
+    falloff?: number;
+    level?: number;
+}
+
+// @public
+export interface ZylemFogNoiseOptions {
+    scale?: number;
+    speed?: number;
+    strength?: number;
+}
+
+// @public (undocumented)
+export interface ZylemFogOptions {
+    color?: ColorRepresentation;
+    density?: number;
+    end?: number;
+    height?: ZylemFogHeightOptions;
+    name?: string;
+    noise?: ZylemFogNoiseOptions;
+    start?: number;
+    type?: ZylemFogType;
+}
+
+// @public
+export type ZylemFogType = 'linear' | 'exp2';
+
+// @public (undocumented)
+export interface ZylemGameConfig<StageInterface, GameInterface, TGlobals extends BaseGlobals> {
+    // (undocumented)
+    debug?: boolean;
+    // (undocumented)
+    globals?: TGlobals;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    input?: GameInputConfig;
+    // (undocumented)
+    stages?: StageInterface[];
+    // (undocumented)
+    time?: number;
+    // (undocumented)
+    update?: UpdateFunction<GameInterface>;
+}
+
+// @public (undocumented)
+export class ZylemGameElement extends HTMLElement {
+    constructor();
+    // (undocumented)
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+    // (undocumented)
+    connectedCallback(): void;
+    // (undocumented)
+    disconnectedCallback(): void;
+    focus(): void;
+    set game(game: Game<any>);
+    // (undocumented)
+    get game(): Game<any> | null;
+    // (undocumented)
+    static get observedAttributes(): string[];
+    set state(value: ZylemGameState);
+    // (undocumented)
+    get state(): ZylemGameState;
+    set viewportProfile(value: DeviceProfile);
+    // (undocumented)
+    get viewportProfile(): DeviceProfile;
+}
+
+// @public
+export interface ZylemGameState {
+    // (undocumented)
+    [key: string]: unknown;
+    // (undocumented)
+    gameState?: {
+        debugFlag?: boolean;
+        [key: string]: unknown;
+    };
+    // (undocumented)
+    toolbarState?: {
+        tool?: DebugTools;
+        paused?: boolean;
+    };
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemLightGameOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export class ZylemLight extends GameEntity<ZylemLightGameOptions> {
+    constructor(options: ZylemLightOptions);
+    protected _cleanup(params: CleanupContext<this>): void;
+    // (undocumented)
+    create(): this;
+    light: Light | null;
+    lightTarget: Object3D | null;
+    // (undocumented)
+    static type: symbol;
+}
+
+// @public (undocumented)
+export type ZylemLightOptions = AmbientLightOptions | HemisphereLightOptions | DirectionalLightOptions | PointLightOptions | SpotLightOptions;
+
+// @public (undocumented)
+export class ZylemLine extends GameEntity<ZylemLineOptions> {
+    constructor(options?: Partial<ZylemLineOptions>);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    protected _cleanup(_params: CleanupContext<this>): void;
+    // (undocumented)
+    create(): this;
+    // (undocumented)
+    getLineObject(): Line2 | null;
+    // (undocumented)
+    pickFromRaycaster(raycaster: Raycaster, options?: {
+        threshold?: number;
+    }): LinePickResult | null;
+    setPoints(points: Vec3Input[], colors?: ColorRepresentation[]): this;
+    // (undocumented)
+    static type: symbol;
+}
+
+// @public (undocumented)
+export type ZylemLineOptions = GameEntityOptions & {
+    points: Vec3Input[];
+    colors?: ColorRepresentation[];
+    linewidth?: number;
+    worldUnits?: boolean;
+    alphaToCoverage?: boolean;
+    opacity?: number;
+    transparent?: boolean;
+    dashed?: boolean;
+    dashSize?: number;
+    gapSize?: number;
+    pickThreshold?: number;
+};
+
+// @public (undocumented)
+export class ZylemParticleSystem extends GameEntity<ZylemParticleSystemOptions> {
+    constructor(options?: Partial<ZylemParticleSystemOptions>, initializeBehavior?: boolean);
+    // (undocumented)
+    __zylemParticleSystemEntity: true;
+    // (undocumented)
+    buildInfo(): Record<string, string>;
+    // (undocumented)
+    burst(): void;
+    // (undocumented)
+    getSystem(): ParticleEmitterHandle_2['getSystem'] extends () => infer T ? T : null;
+    // (undocumented)
+    isPlaying(): boolean;
+    // (undocumented)
+    pause(): void;
+    // (undocumented)
+    play(): void;
+    // (undocumented)
+    restart(): void;
+    // (undocumented)
+    stop(): void;
+    // (undocumented)
+    static type: symbol;
+}
+
+// @public (undocumented)
+export type ZylemParticleSystemOptions = GameEntityOptions & ParticleEmitterBehaviorOptions_2 & {
+    preset?: ParticleEffectDefinition_2;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ZylemPillOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export class ZylemPill extends GameEntity<ZylemPillOptions> {
+    constructor(options?: ZylemPillOptions);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    static type: symbol;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemPlaneOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class ZylemPlane extends GameEntity<ZylemPlaneOptions> {
+    constructor(options?: ZylemPlaneOptions);
+    // (undocumented)
+    static type: symbol;
+}
+
+// @public
+export type ZylemPostEffect = (inputNode: any, ctx: {
+    scenePass: any;
+    scene: any;
+    camera: any;
+}) => any;
+
+// Warning: (ae-forgotten-export) The symbol "ZylemPyramidOptions" needs to be exported by the entry point public.d.ts
+//
+// @public
+export class ZylemPyramid extends GameEntity<ZylemPyramidOptions> {
+    constructor(options?: ZylemPyramidOptions);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    static type: symbol;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemRectOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class ZylemRect extends GameEntity<ZylemRectOptions> {
+    constructor(options?: ZylemRectOptions);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    getHeight(): number;
+    // (undocumented)
+    getWidth(): number;
+    // (undocumented)
+    static type: symbol;
+    // (undocumented)
+    updateRect(options?: Partial<Pick<ZylemRectOptions, 'width' | 'height' | 'fillColor' | 'strokeColor' | 'strokeWidth' | 'radius'>>): void;
+}
+
+// @public
+export type ZylemRenderer = WebGPURenderer;
+
+// @public
+export type ZylemShader = ZylemShaderObject | ZylemTSLShader;
+
+// @public @deprecated
+export type ZylemShaderObject = {
+    fragment: string;
+    vertex: string;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ZylemSphereOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class ZylemSphere extends GameEntity<ZylemSphereOptions> {
+    constructor(options?: ZylemSphereOptions);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    static type: symbol;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemSpriteOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class ZylemSprite extends GameEntity<ZylemSpriteOptions> {
+    constructor(options?: ZylemSpriteOptions);
+    // (undocumented)
+    protected animations: Map<string, any>;
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    create(): this;
+    // (undocumented)
+    protected createAnimations(animations: SpriteAnimation[]): void;
+    // (undocumented)
+    protected createSpritesFromImages(images: SpriteImage[]): void;
+    // (undocumented)
+    protected currentAnimation: any;
+    // (undocumented)
+    protected currentAnimationFrame: string;
+    // (undocumented)
+    protected currentAnimationIndex: number;
+    // (undocumented)
+    protected currentAnimationTime: number;
+    // (undocumented)
+    protected currentSpriteIndex: number;
+    // (undocumented)
+    setAnimation(name: string, delta: number): void;
+    // (undocumented)
+    setSprite(key: string): void;
+    // (undocumented)
+    spriteDestroy(params: DestroyContext<ZylemSpriteOptions>): void;
+    // (undocumented)
+    protected spriteMap: Map<string, number>;
+    // (undocumented)
+    protected sprites: Sprite[];
+    // (undocumented)
+    spriteSetup(_params: SetupContext<ZylemSpriteOptions>): void;
+    // (undocumented)
+    spriteUpdate(params: UpdateContext<ZylemSpriteOptions>): void;
+    // (undocumented)
+    static type: symbol;
+}
+
+// Warning: (ae-forgotten-export) The symbol "ZylemTextOptions" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class ZylemText extends GameEntity<ZylemTextOptions> {
+    constructor(options?: ZylemTextOptions);
+    // (undocumented)
+    buildInfo(): Record<string, any>;
+    // (undocumented)
+    create(): this;
+    // (undocumented)
+    static type: symbol;
+    // (undocumented)
+    updateText(_text: string): void;
+}
+
+// @public
+export type ZylemTransitionShader = (ctx: {
+    fromNode: any;
+    toNode: any;
+    progress: any;
+}) => any;
+
+// @public
+export type ZylemTSLShader = {
+    colorNode: any;
+    positionNode?: any;
+    normalNode?: any;
+    transparent?: boolean;
+    blending?: Blending;
+    side?: Side;
+    depthTest?: boolean;
+};
+
+// Warning: (ae-forgotten-export) The symbol "ZylemZoneOptions" needs to be exported by the entry point public.d.ts
+// Warning: (ae-forgotten-export) The symbol "CollisionHandlerDelegate" needs to be exported by the entry point public.d.ts
+//
+// @public (undocumented)
+export class ZylemZone extends GameEntity<ZylemZoneOptions> implements CollisionHandlerDelegate {
+    constructor(options?: ZylemZoneOptions);
+    // (undocumented)
+    entered(other: any): void;
+    // (undocumented)
+    exited(delta: number, key: string): void;
+    // (undocumented)
+    handleIntersectionEvent(input: {
+        other: any;
+        delta: number;
+    }): void;
+    // (undocumented)
+    handlePostCollision(input: {
+        delta: number;
+    }): boolean;
+    // (undocumented)
+    held(delta: number, other: any): void;
+    // (undocumented)
+    onEnter(callback: (params: OnEnterParams) => void): this;
+    // (undocumented)
+    onExit(callback: (params: OnExitParams) => void): this;
+    // (undocumented)
+    onHeld(callback: (params: OnHeldParams) => void): this;
+    // (undocumented)
+    static type: symbol;
+}
+
+// Warnings were encountered during analysis:
+//
+// dist/entity-BdSI8CL3.d.ts:406:5 - (ae-forgotten-export) The symbol "RenderCategory_2" needs to be exported by the entry point public.d.ts
+// dist/entity-BdSI8CL3.d.ts:407:5 - (ae-forgotten-export) The symbol "RuntimeEntityOptions" needs to be exported by the entry point public.d.ts
+// dist/entity-BdSI8CL3.d.ts:408:5 - (ae-forgotten-export) The symbol "CollisionOptions" needs to be exported by the entry point public.d.ts
+// dist/entity-BdSI8CL3.d.ts:409:5 - (ae-forgotten-export) The symbol "MaterialOptions" needs to be exported by the entry point public.d.ts
+// dist/entity-BdSI8CL3.d.ts:417:9 - (ae-forgotten-export) The symbol "IBuilder" needs to be exported by the entry point public.d.ts
+// dist/entity-BdSI8CL3.d.ts:417:9 - (ae-forgotten-export) The symbol "EntityMeshBuilder" needs to be exported by the entry point public.d.ts
+// dist/entity-BdSI8CL3.d.ts:418:9 - (ae-forgotten-export) The symbol "EntityCollisionBuilder" needs to be exported by the entry point public.d.ts
+// dist/entity-BdSI8CL3.d.ts:419:9 - (ae-forgotten-export) The symbol "MaterialBuilder" needs to be exported by the entry point public.d.ts
+// dist/game-C1FHVqXl.d.ts:908:5 - (ae-forgotten-export) The symbol "StageAssetLoaderConfig" needs to be exported by the entry point public.d.ts
+// dist/game-C1FHVqXl.d.ts:1520:5 - (ae-forgotten-export) The symbol "StageInterface" needs to be exported by the entry point public.d.ts
+
+// (No @packageDocumentation comment for this package)
+
+```