import { type Collider, type ColliderDescriptor, type CollisionEvent, type Constraint, type ConstraintDescriptor, type Contact, type DebugLine, type PhysicsBackendSelection, type PhysicsShape, type PhysicsSnapshot, type PhysicsWorldDescriptor, type RaycastHit, type RaycastOptions, type RigidBody, type RigidBodyDescriptor, type RigidBodyType, type ScenePhysicsNode, type SphereCastHit } from "@aura3d/physics";
import type { GLTFSceneAnimationRuntime, GLTFSceneAnimationRuntimeOptions } from "@aura3d/assets/browser";
export { Engine } from "@aura3d/core";
export type AuraVec3 = readonly [number, number, number];
export type AuraColor = `#${string}` | string;
export type AuraAssetType = "model" | "texture" | "environment" | "audio";
export type AuraModelFormat = "glb" | "gltf";
export type AuraTextureFormat = "png" | "jpg" | "jpeg" | "webp" | "ktx2";
export type AuraProceduralTextureKind = "fabric-normal" | "rubber-roughness" | "brushed-metal-anisotropy" | "plastic-micro-scratch";
export interface AuraProceduralTextureSpec {
    readonly kind: "aura-procedural-texture";
    readonly texture: AuraProceduralTextureKind;
    readonly scale: number;
    readonly strength: number;
    readonly contrast?: number;
    readonly direction?: AuraVec3;
    readonly colorA?: AuraColor;
    readonly colorB?: AuraColor;
}
export type AuraMaterialTextureInput = AuraAssetRef<"texture"> | AuraProceduralTextureSpec;
export interface AuraAssetDefinition {
    readonly type: AuraAssetType;
    readonly format: string;
    readonly url: string;
    readonly hash?: string;
    readonly bounds?: AuraVec3;
    readonly sizeBytes?: number;
    readonly optional?: boolean;
    readonly metadata?: AuraAssetMetadata;
}
export interface AuraAssetMetadata {
    readonly materials?: readonly string[];
    readonly animations?: readonly string[];
    readonly textures?: readonly string[];
    readonly thumbnailUrl?: string;
    readonly license?: string;
}
declare const auraAssetRefBrand: unique symbol;
export type AuraAssetRef<TType extends AuraAssetType = AuraAssetType, TId extends string = string> = AuraAssetDefinition & {
    readonly kind: "aura-asset-ref";
    readonly id: TId;
    readonly type: TType;
    readonly [auraAssetRefBrand]: {
        readonly type: TType;
        readonly id: TId;
    };
};
export type AuraAssetMap<T extends Record<string, AuraAssetDefinition>> = {
    readonly [K in keyof T]: AuraAssetRef<T[K]["type"], Extract<K, string>> & T[K];
};
export declare function defineAuraAssets<const T extends Record<string, AuraAssetDefinition>>(definitions: T): AuraAssetMap<T>;
export interface AuraTransformSpec {
    readonly position?: AuraVec3;
    readonly rotation?: AuraVec3;
    readonly scale?: number | AuraVec3;
    readonly lookAt?: AuraVec3;
}
export interface AuraMaterialSpec {
    readonly name?: string;
    readonly shader?: "solar-sun" | "solar-corona";
    readonly color?: AuraColor;
    readonly coreColor?: AuraColor;
    readonly rimColor?: AuraColor;
    readonly noiseStrength?: number;
    readonly falloff?: number;
    readonly roughness?: number;
    readonly metallic?: number;
    readonly metalness?: number;
    readonly emissive?: AuraColor;
    readonly emissiveIntensity?: number;
    readonly opacity?: number;
    readonly transmission?: number;
    readonly clearcoat?: number;
    readonly clearcoatRoughness?: number;
    readonly thickness?: number;
    readonly ior?: number;
    readonly sheen?: number;
    readonly sheenRoughness?: number;
    readonly sheenColor?: AuraColor;
    readonly iridescence?: number;
    readonly iridescenceIOR?: number;
    readonly iridescenceThicknessRange?: readonly [number, number];
    readonly anisotropy?: number;
    readonly anisotropyRotation?: number;
    readonly attenuationColor?: AuraColor;
    readonly attenuationDistance?: number;
    readonly envMapIntensity?: number;
    readonly normal?: AuraMaterialTextureInput;
    readonly normalScale?: number;
    readonly roughnessMap?: AuraMaterialTextureInput;
    readonly metalnessMap?: AuraMaterialTextureInput;
    readonly texture?: AuraAssetRef<"texture">;
}
export interface AuraEditableMaterialParameters {
    readonly kind: "aura-material-parameters";
    readonly name: string;
    readonly material: AuraMaterialSpec;
    readonly roughness: number;
    readonly metallic: number;
    readonly metalness: number;
    readonly transmission: number;
    readonly clearcoat: number;
    readonly clearcoatRoughness: number;
    readonly thickness: number;
    readonly ior: number;
    readonly sheen: number;
    readonly iridescence: number;
    readonly anisotropy: number;
    readonly envMapIntensity: number;
    readonly emissiveIntensity: number;
}
export interface AuraMaterialInspectorParameter {
    readonly name: keyof AuraMaterialSpec | "metalness";
    readonly value: number | string | boolean | readonly number[] | undefined;
    readonly min?: number;
    readonly max?: number;
    readonly step?: number;
    readonly unit?: string;
    readonly visible: boolean;
}
export interface AuraMaterialInspectorPanel {
    readonly kind: "aura-material-inspector";
    readonly name: string;
    readonly material: AuraMaterialSpec;
    readonly parameters: readonly AuraMaterialInspectorParameter[];
    readonly liveValues: Record<string, number | string | boolean | readonly number[] | undefined>;
    readonly summary: string;
}
export interface AuraMaterialVisualQAResult {
    readonly passes: boolean;
    readonly score: number;
    readonly classes: readonly string[];
    readonly plinths: number;
    readonly labels: number;
    readonly reflectionCards: number;
    readonly chromeReflectsEnvironment: boolean;
    readonly glassTransparent: boolean;
    readonly rubberNonReflective: boolean;
    readonly emissiveGlows: boolean;
    readonly clearcoatLayeredHighlight: boolean;
    readonly minimumMaterialDistance: number;
    readonly problems: readonly string[];
}
export interface AuraModelOptions extends AuraTransformSpec {
    readonly name?: string;
    readonly material?: AuraMaterialSpec;
    readonly castShadow?: boolean;
    readonly receiveShadow?: boolean;
    readonly visible?: boolean;
    readonly physics?: AuraNodePhysicsSpec;
}
export interface AuraPrimitiveOptions extends AuraTransformSpec {
    readonly name?: string;
    readonly material?: AuraMaterialSpec;
    readonly size?: number | AuraVec3;
    readonly castShadow?: boolean;
    readonly receiveShadow?: boolean;
    readonly physics?: AuraNodePhysicsSpec;
}
export interface AuraAnimationSpec {
    readonly clip?: string;
    readonly loop?: boolean;
    readonly speed?: number;
    readonly startTime?: number;
    readonly duration?: number;
    readonly easing?: "linear" | "easeInOut";
    readonly captureTime?: number;
    readonly orbitCenter?: AuraVec3;
    readonly orbitPhase?: number;
    readonly orbitRadius?: number;
    readonly joint?: AuraCharacterJointName;
    readonly chain?: "root" | "left-arm" | "right-arm" | "left-leg" | "right-leg";
    readonly rootBob?: boolean;
    readonly jointHierarchy?: boolean;
}
export interface AuraInteractionSpec {
    readonly cursor?: string;
    readonly onClick?: string;
    readonly onHover?: string;
}
export type AuraCharacterClipName = "idle" | "walk" | "run" | "wave" | "turn" | "pose" | "benchmark-pose";
export type AuraCharacterStyle = "simple" | "athletic" | "robot" | "mannequin";
export type AuraCharacterPose = "mid-stride" | "planted-foot" | "side-view" | "three-quarter";
export type AuraCharacterJointName = "root" | "pelvis" | "spine" | "neck" | "head" | "left-shoulder" | "left-elbow" | "left-wrist" | "right-shoulder" | "right-elbow" | "right-wrist" | "left-hip" | "left-knee" | "left-ankle" | "right-hip" | "right-knee" | "right-ankle";
export interface AuraCharacterJoint {
    readonly name: AuraCharacterJointName;
    readonly parent?: AuraCharacterJointName;
    readonly position: AuraVec3;
}
export interface AuraCharacterClip {
    readonly name: AuraCharacterClipName;
    readonly duration: number;
    readonly captureTime: number;
    readonly loop: boolean;
}
export interface AuraCharacterSkeleton {
    readonly kind: "aura-character-skeleton";
    readonly style: AuraCharacterStyle;
    readonly joints: readonly AuraCharacterJoint[];
    readonly clips: readonly AuraCharacterClip[];
}
export interface AuraCharacterRigSpec {
    readonly skeleton: AuraCharacterSkeleton;
    readonly clip: AuraCharacterClipName;
    readonly pose: AuraCharacterPose;
    readonly rootBob?: boolean;
    readonly limbSwing?: "joint-hierarchy";
    readonly footPlanting?: AuraCharacterFootPlantingSpec;
    readonly rootMotion?: AuraCharacterRootMotionSpec;
    readonly constraints?: AuraCharacterConstraintCorrectionSpec;
}
export interface AuraCharacterFootPlantingSpec {
    readonly enabled: boolean;
    readonly groundY: number;
    readonly plantedFeet: readonly ("left" | "right")[];
    readonly captureTime: number;
    readonly evidence: string;
}
export interface AuraCharacterRootMotionSpec {
    readonly enabled: boolean;
    readonly bodyBob: boolean;
    readonly torsoMovesAsSingleBody: boolean;
    readonly strideLength: number;
    readonly evidence: string;
}
export interface AuraCharacterConstraintCorrectionSpec {
    readonly enabled: boolean;
    readonly correctedChains: readonly ("spine" | "left-arm" | "right-arm" | "left-leg" | "right-leg")[];
    readonly maxJointGap: number;
    readonly evidence: string;
}
export interface AuraCharacterVisualQAGap {
    readonly id: string;
    readonly from: string;
    readonly to: string;
    readonly distance: number;
    readonly maxDistance: number;
}
export interface AuraCharacterVisualQAResult {
    readonly connected: boolean;
    readonly impossibleProportions: boolean;
    readonly score: number;
    readonly gaps: readonly AuraCharacterVisualQAGap[];
    readonly problems: readonly string[];
}
export type AuraProceduralHumanMeshPartName = "torso" | "pelvis" | "neck" | "head" | "left-shoulder" | "right-shoulder" | "left-upper-arm" | "left-lower-arm" | "right-upper-arm" | "right-lower-arm" | "left-hand" | "right-hand" | "left-hip" | "right-hip" | "left-upper-leg" | "left-lower-leg" | "right-upper-leg" | "right-lower-leg" | "left-foot" | "right-foot";
export interface AuraProceduralHumanMeshPart {
    readonly name: AuraProceduralHumanMeshPartName;
    readonly parent?: AuraProceduralHumanMeshPartName;
    readonly joint: AuraCharacterJointName;
    readonly center: AuraVec3;
    readonly size: AuraVec3;
    readonly vertices: readonly AuraVec3[];
    readonly indices: readonly number[];
    readonly material: AuraMaterialSpec;
}
export interface AuraProceduralHumanMeshDescriptor {
    readonly kind: "aura-procedural-human-mesh";
    readonly style: AuraCharacterStyle;
    readonly skeleton: AuraCharacterSkeleton;
    readonly clips: readonly AuraCharacterClip[];
    readonly parts: readonly AuraProceduralHumanMeshPart[];
    readonly evidence: readonly string[];
}
export type AuraHelperBudgetId = "physicsPlayground" | "particleFountain" | "solarSystem" | "dataBars3D" | "neonTunnel" | "miniGolfHole" | "materialSwatches" | "cityBlock" | "lowPolyHumanoid" | "primitiveHumanoid" | "productStage";
export interface AuraHelperPerformanceBudget {
    readonly helper: AuraHelperBudgetId;
    readonly maxDrawCalls: number;
    readonly maxNodes: number;
    readonly targetFpsP50: number;
    readonly maxBundleBytes?: number;
    readonly evidence: string;
}
export type AuraSceneNode = AuraModelNode | AuraPrimitiveNode | AuraGroupNode | AuraLightNode | AuraEffectNode | AuraInteractionNode | AuraLabelNode | AuraEnvironmentNode;
export interface AuraModelNode extends AuraTransformSpec {
    readonly kind: "model";
    readonly name?: string;
    readonly asset: AuraAssetRef<"model">;
    readonly material?: AuraMaterialSpec;
    readonly castShadow: boolean;
    readonly receiveShadow: boolean;
    readonly visible: boolean;
    readonly animation?: AuraAnimationSpec;
    readonly interaction?: AuraInteractionSpec;
    readonly physics?: AuraNodePhysicsSpec;
}
export interface AuraPrimitiveNode extends AuraTransformSpec {
    readonly kind: "primitive";
    readonly primitive: "box" | "sphere" | "plane" | "cylinder" | "capsule" | "torus";
    readonly name?: string;
    readonly material?: AuraMaterialSpec;
    readonly size?: number | AuraVec3;
    readonly castShadow?: boolean;
    readonly receiveShadow?: boolean;
    readonly animation?: AuraAnimationSpec;
    readonly interaction?: AuraInteractionSpec;
    readonly physics?: AuraNodePhysicsSpec;
}
export interface AuraGroupNode extends AuraTransformSpec {
    readonly kind: "group";
    readonly name?: string;
    readonly children: readonly AuraSceneNode[];
    readonly animation?: AuraAnimationSpec;
    readonly character?: AuraCharacterRigSpec;
}
export type AuraLightType = "ambient" | "directional" | "point" | "studio" | "rect" | "softbox";
export interface AuraLightNode extends AuraTransformSpec {
    readonly kind: "light";
    readonly light: AuraLightType;
    readonly name?: string;
    readonly color?: AuraColor;
    readonly intensity: number;
    readonly width?: number;
    readonly height?: number;
}
export type AuraEffectType = "fog" | "bloom" | "rain" | "particles" | "ambient-occlusion" | "contact-occlusion";
export type AuraParticleMaterialMode = "additive-glow" | "soft-alpha" | "spark" | "smoke" | "splash" | "dust" | "star";
export interface AuraEffectNode {
    readonly kind: "effect";
    readonly effect: AuraEffectType;
    readonly name?: string;
    readonly intensity?: number;
    readonly density?: number;
    readonly color?: AuraColor;
    readonly speed?: number;
    readonly wind?: AuraVec3;
    readonly particleCount?: number;
    readonly emitter?: "fountain" | "swirl" | "ambient";
    readonly radius?: number;
    readonly height?: number;
    readonly threshold?: number;
    readonly antiBlowout?: boolean;
    readonly maxIntensity?: number;
    readonly emissionRate?: number;
    readonly gravity?: number;
    readonly groundCollision?: boolean;
    readonly lifetimeColorRamp?: readonly AuraColor[];
    readonly materialMode?: AuraParticleMaterialMode;
    readonly texturedBillboard?: boolean;
    readonly sizeOverLife?: readonly number[];
    readonly alphaOverLife?: readonly number[];
    readonly velocityOverLife?: readonly number[];
    readonly turbulence?: number;
    readonly noise?: number;
    readonly splashes?: boolean;
    readonly mist?: boolean;
}
export interface AuraParticleBudgetDiagnostics {
    readonly kind: "aura-particle-budget";
    readonly effectCount: number;
    readonly totalParticles: number;
    readonly estimatedDrawCalls: number;
    readonly estimatedUpdateCostMs: number;
    readonly modes: readonly AuraParticleMaterialMode[];
    readonly texturedBillboards: number;
    readonly gpuReady: boolean;
}
export interface AuraLabelNode extends AuraTransformSpec {
    readonly kind: "label";
    readonly label: "billboard" | "anchor" | "axis-tick" | "callout" | "hud";
    readonly name?: string;
    readonly text: string;
    readonly target?: string;
    readonly color?: AuraColor;
    readonly background?: AuraColor;
    readonly size?: number;
    readonly leader?: boolean;
    readonly screenAnchor?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
    readonly occlusionAware?: boolean;
    readonly collisionAvoidance?: boolean;
    readonly animation?: AuraAnimationSpec;
}
export interface AuraEnvironmentNode {
    readonly kind: "environment";
    readonly environment: "studio" | "material-lab" | "product-hero" | "night-cinematic" | "metal-studio" | "glass-studio";
    readonly name?: string;
    readonly intensity: number;
    readonly color?: AuraColor;
}
export type AuraSceneCategory = "product" | "material" | "neon" | "city-night" | "city-day" | "space" | "physics" | "chart" | "game";
export interface AuraRendererColorManagementPreset {
    readonly kind: "aura-renderer-color-management";
    readonly workflow: "linear";
    readonly outputColorSpace: "srgb";
    readonly toneMapping: "aces-filmic";
    readonly defaultExposure: number;
    readonly notes: readonly string[];
}
export interface AuraSceneExposurePreset {
    readonly category: AuraSceneCategory;
    readonly exposure: number;
    readonly evidence: string;
}
export interface AuraEnvironmentMapPreset {
    readonly id: AuraEnvironmentNode["environment"];
    readonly label: string;
    readonly purpose: readonly string[];
    readonly intensity: number;
    readonly color: AuraColor;
    readonly evidence: string;
}
export interface AuraRendererQualityPreset {
    readonly kind: "aura-renderer-quality";
    readonly id: "interactive" | "screenshot";
    readonly antialiasing: "msaa" | "msaa-plus-high-dpi";
    readonly shadowMap: "pcf-soft";
    readonly pixelRatio: number;
    readonly preserveDrawingBuffer: boolean;
    readonly maxRecommendedDrawCalls: number;
    readonly evidence: string;
}
export interface AuraRendererDiagnosticReport {
    readonly kind: "aura-renderer-diagnostics";
    readonly colorManagement: AuraRendererColorManagementPreset;
    readonly sceneCategory: AuraSceneCategory;
    readonly exposure: AuraSceneExposurePreset;
    readonly toneMapping: "aces-filmic";
    readonly outputColorSpace: "srgb";
    readonly linearWorkflow: true;
    readonly bloom: {
        readonly enabled: boolean;
        readonly rendered: boolean;
        readonly intensity: number;
        readonly threshold: number;
        readonly radius: number;
        readonly antiBlowout: boolean;
    };
    readonly shadows: {
        readonly enabled: boolean;
        readonly contactShadows: number;
        readonly mapType: "pcf-soft";
    };
    readonly occlusion: {
        readonly enabled: boolean;
        readonly contactOcclusion: boolean;
        readonly ambientOcclusion: boolean;
        readonly evidence: string;
    };
    readonly fog: {
        readonly enabled: boolean;
        readonly density: number;
        readonly preset: "none" | "depth" | "volumetric";
    };
    readonly postprocess: {
        readonly enabled: boolean;
        readonly requested: boolean;
        readonly renderPass: boolean;
        readonly outputPass: boolean;
        readonly bloomPass: boolean;
        readonly ambientOcclusionPass: boolean;
        readonly contactOcclusionReceiver: boolean;
        readonly pixelBacked: boolean;
        readonly runtimeStatus: "not-mounted" | "active" | "fallback" | "disabled";
        readonly requestedPasses: readonly string[];
        readonly actualPasses: readonly string[];
        readonly fallbackPasses: readonly string[];
        readonly evidence: string;
    };
    readonly runtime: {
        readonly mounted: boolean;
        readonly backend: "scene-plan" | "webgl2-agent-runtime";
        readonly postprocessVerified: boolean;
        readonly passNames: readonly string[];
        readonly warnings: readonly string[];
    };
    readonly environment: {
        readonly enabled: boolean;
        readonly preset?: AuraEnvironmentNode["environment"];
        readonly intensity?: number;
        readonly evidence: string;
    };
    readonly antialiasing: AuraRendererQualityPreset["antialiasing"];
    readonly screenshotQuality: AuraRendererQualityPreset;
    readonly warnings: readonly string[];
}
declare global {
    interface HTMLStrongElement extends HTMLElement {
    }
}
export interface AuraInteractionNode {
    readonly kind: "interaction";
    readonly mode: "orbit" | "pointer" | "keyboard" | "drag-vector" | "click-impulse" | "hover";
    readonly target?: string;
    readonly vector?: AuraVec3;
    readonly impulse?: number;
    readonly selected?: string;
}
export type AuraPhysicsShapeKind = "box" | "sphere" | "capsule" | "plane";
export interface AuraNodePhysicsSpec {
    readonly type?: RigidBodyType;
    readonly shape?: AuraPhysicsShapeKind | PhysicsShape;
    readonly mass?: number;
    readonly friction?: number;
    readonly restitution?: number;
    readonly density?: number;
    readonly sensor?: boolean;
    readonly halfExtents?: AuraVec3;
    readonly radius?: number;
    readonly halfHeight?: number;
    readonly normal?: AuraVec3;
    readonly constant?: number;
}
export interface AuraPhysicsStepOptions {
    readonly dt?: number;
    readonly steps?: number;
}
export interface AuraPhysicsDebugSnapshot {
    readonly bodyCount: number;
    readonly colliderCount: number;
    readonly contactCount: number;
    readonly sleepingBodyCount: number;
    readonly lines: readonly DebugLine[];
    readonly nodes: readonly AuraSceneNode[];
}
export interface AuraPhysicsSceneSummary {
    readonly kind: "aura-physics-world";
    readonly backend: PhysicsBackendSelection;
    readonly bodies: number;
    readonly colliders: number;
    readonly contacts: number;
    readonly steps: number;
    readonly resets: number;
    readonly debugLines: number;
    readonly snapshot: PhysicsSnapshot;
}
export interface AuraPhysicsWorldController {
    readonly kind: "aura-physics-world";
    createBody(options?: RigidBodyDescriptor & {
        readonly shape?: PhysicsShape;
        readonly sensor?: boolean;
        readonly material?: ColliderDescriptor["material"];
    }): RigidBody;
    createCollider(body: RigidBody | number, descriptor: ColliderDescriptor): Collider;
    createConstraint(descriptor: ConstraintDescriptor): Constraint;
    bindNode(body: RigidBody | number, node: ScenePhysicsNode, mode?: "dynamic" | "kinematic"): void;
    step(options?: number | AuraPhysicsStepOptions): readonly CollisionEvent[];
    reset(): void;
    contacts(): readonly Contact[];
    liveContactCount(): number;
    raycast(origin: AuraVec3, direction: AuraVec3, options?: RaycastOptions): RaycastHit | undefined;
    sphereCast(origin: AuraVec3, radius: number, direction: AuraVec3, options?: RaycastOptions): SphereCastHit | undefined;
    debug(): AuraPhysicsDebugSnapshot;
    debugNodes(): readonly AuraSceneNode[];
    snapshot(): AuraPhysicsSceneSummary;
}
export declare class AuraNodeBuilder<TNode extends AuraSceneNode> {
    private readonly value;
    constructor(value: TNode);
    position(x: number, y: number, z: number): AuraNodeBuilder<TNode & {
        readonly position: AuraVec3;
    }>;
    rotate(x: number, y: number, z: number): AuraNodeBuilder<TNode & {
        readonly rotation: AuraVec3;
    }>;
    scale(value: number | AuraVec3): AuraNodeBuilder<TNode & {
        readonly scale: number | AuraVec3;
    }>;
    lookAt(x: number, y: number, z: number): AuraNodeBuilder<TNode & {
        readonly lookAt: AuraVec3;
    }>;
    material(material: AuraMaterialSpec): AuraNodeBuilder<TNode & {
        readonly material: AuraMaterialSpec;
    }>;
    animate(animation: AuraAnimationSpec): AuraNodeBuilder<TNode & {
        readonly animation: AuraAnimationSpec;
    }>;
    onPointer(interaction: AuraInteractionSpec): AuraNodeBuilder<TNode & {
        readonly interaction: AuraInteractionSpec;
    }>;
    physics(spec: AuraNodePhysicsSpec): AuraNodeBuilder<TNode & {
        readonly physics: AuraNodePhysicsSpec;
    }>;
    toJSON(): TNode;
    private with;
}
export declare function model<TAsset extends AuraAssetRef<"model">>(asset: TAsset, options?: AuraModelOptions): AuraNodeBuilder<AuraModelNode>;
export declare function unsafeModelUrl(url: string, options?: Omit<AuraAssetDefinition, "type" | "format" | "url">): AuraAssetRef<"model", "unsafe">;
export type AuraNodeInput = AuraNodeBuilder<AuraSceneNode> | AuraSceneNode;
export declare function group(name: string, children?: readonly AuraNodeInput[], options?: AuraTransformSpec & {
    readonly animation?: AuraAnimationSpec;
    readonly character?: AuraCharacterRigSpec;
}): AuraNodeBuilder<AuraGroupNode>;
export declare const primitives: {
    readonly box: (options?: AuraPrimitiveOptions) => AuraNodeBuilder<AuraPrimitiveNode>;
    readonly sphere: (options?: AuraPrimitiveOptions) => AuraNodeBuilder<AuraPrimitiveNode>;
    readonly plane: (options?: AuraPrimitiveOptions) => AuraNodeBuilder<AuraPrimitiveNode>;
    readonly cylinder: (options?: AuraPrimitiveOptions) => AuraNodeBuilder<AuraPrimitiveNode>;
    readonly capsule: (options?: AuraPrimitiveOptions) => AuraNodeBuilder<AuraPrimitiveNode>;
    readonly torus: (options?: AuraPrimitiveOptions) => AuraNodeBuilder<AuraPrimitiveNode>;
};
export declare const groups: {
    readonly create: typeof group;
    readonly flatten: (nodes: readonly AuraSceneNode[]) => readonly AuraSceneNode[];
};
export declare const shadows: {
    readonly contact: (options?: {
        readonly name?: string;
        readonly position?: AuraVec3;
        readonly footprint?: readonly [number, number];
        readonly opacity?: number;
        readonly color?: AuraColor;
    }) => AuraNodeBuilder<AuraPrimitiveNode>;
};
declare function proceduralTexture(texture: AuraProceduralTextureKind, options?: Partial<Omit<AuraProceduralTextureSpec, "kind" | "texture">>): AuraProceduralTextureSpec;
export declare const material: {
    readonly pbr: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly physical: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly emissive: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly metal: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly rubber: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly glass: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly clearcoat: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly neon: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly reflectiveFloor: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly solarSun: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly solarCorona: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly fabric: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly chrome: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly brushedMetal: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly frostedGlass: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly clearGlass: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly blackRubber: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly matteClay: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly ceramic: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly glowingEmissive: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly clearcoatPaint: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly sneakerMesh: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly sneakerRubber: (options?: AuraMaterialSpec) => AuraMaterialSpec;
    readonly proceduralTexture: typeof proceduralTexture;
    readonly proceduralTextures: {
        readonly fabric: (options?: Partial<Omit<AuraProceduralTextureSpec, "kind" | "texture">>) => AuraProceduralTextureSpec;
        readonly rubber: (options?: Partial<Omit<AuraProceduralTextureSpec, "kind" | "texture">>) => AuraProceduralTextureSpec;
        readonly brushedMetal: (options?: Partial<Omit<AuraProceduralTextureSpec, "kind" | "texture">>) => AuraProceduralTextureSpec;
        readonly plastic: (options?: Partial<Omit<AuraProceduralTextureSpec, "kind" | "texture">>) => AuraProceduralTextureSpec;
    };
    readonly parameters: (name: string, spec: AuraMaterialSpec) => AuraEditableMaterialParameters;
    readonly fromParameters: (parameters: AuraEditableMaterialParameters) => AuraMaterialSpec;
    readonly labParameters: () => readonly AuraEditableMaterialParameters[];
    readonly presets: () => Readonly<Record<string, AuraMaterialSpec>>;
    readonly inspector: (name: string, spec: AuraMaterialSpec) => AuraMaterialInspectorPanel;
    readonly visualQA: (nodes: readonly AuraSceneNode[]) => AuraMaterialVisualQAResult;
};
export declare const lights: {
    readonly ambient: (options?: {
        readonly name?: string;
        readonly intensity?: number;
        readonly color?: AuraColor;
    }) => AuraNodeBuilder<AuraLightNode>;
    readonly directional: (options?: {
        readonly name?: string;
        readonly position?: AuraVec3;
        readonly intensity?: number;
        readonly color?: AuraColor;
    }) => AuraNodeBuilder<AuraLightNode>;
    readonly point: (options?: {
        readonly name?: string;
        readonly position?: AuraVec3;
        readonly intensity?: number;
        readonly color?: AuraColor;
    }) => AuraNodeBuilder<AuraLightNode>;
    readonly studio: (options?: {
        readonly intensity?: number;
    }) => AuraNodeBuilder<AuraLightNode>;
    readonly rect: (options?: {
        readonly name?: string;
        readonly position?: AuraVec3;
        readonly intensity?: number;
        readonly color?: AuraColor;
        readonly width?: number;
        readonly height?: number;
    }) => AuraNodeBuilder<AuraLightNode>;
    readonly softbox: (options?: {
        readonly name?: string;
        readonly position?: AuraVec3;
        readonly intensity?: number;
        readonly color?: AuraColor;
        readonly width?: number;
        readonly height?: number;
    }) => AuraNodeBuilder<AuraLightNode>;
    readonly productStudio: (options?: {
        readonly intensity?: number;
    }) => AuraNodeBuilder<AuraLightNode>;
    readonly materialLab: (options?: {
        readonly intensity?: number;
    }) => AuraNodeBuilder<AuraLightNode>;
};
export type AuraCameraMode = "perspective" | "orbit" | "dolly" | "follow" | "path" | "flythrough";
export interface AuraCameraSpec {
    readonly mode: AuraCameraMode;
    readonly position?: AuraVec3;
    readonly target?: AuraVec3;
    readonly fov?: number;
    readonly distance?: number;
    readonly from?: AuraVec3;
    readonly to?: AuraVec3;
    readonly seconds?: number;
    readonly targetNode?: string;
    readonly easing?: "linear" | "easeInOut";
    readonly captureTime?: number;
    readonly smoothing?: number;
    readonly subjectEmphasis?: number;
}
export interface AuraBoundsSpec {
    readonly min: AuraVec3;
    readonly max: AuraVec3;
}
export declare const camera: {
    readonly perspective: (options?: Omit<AuraCameraSpec, "mode">) => AuraCameraSpec;
    readonly orbit: (options?: Omit<AuraCameraSpec, "mode">) => AuraCameraSpec;
    readonly dolly: (options: Omit<AuraCameraSpec, "mode"> & {
        readonly from: AuraVec3;
        readonly to: AuraVec3;
    }) => AuraCameraSpec;
    readonly follow: (options: Omit<AuraCameraSpec, "mode"> & {
        readonly targetNode: string;
    }) => AuraCameraSpec;
    readonly path: (options: Omit<AuraCameraSpec, "mode"> & {
        readonly from: AuraVec3;
        readonly to: AuraVec3;
    }) => AuraCameraSpec;
    readonly flythrough: (options?: Omit<AuraCameraSpec, "mode"> & {
        readonly from?: AuraVec3;
        readonly to?: AuraVec3;
    }) => AuraCameraSpec;
    readonly autoFrame: (options?: {
        readonly bounds?: AuraBoundsSpec;
        readonly target?: AuraVec3;
        readonly padding?: number;
        readonly fov?: number;
    }) => AuraCameraSpec;
    readonly physics: () => AuraCameraSpec;
    readonly charts: () => AuraCameraSpec;
    readonly materials: () => AuraCameraSpec;
    readonly city: () => AuraCameraSpec;
    readonly product: () => AuraCameraSpec;
    readonly solar: () => AuraCameraSpec;
    readonly humanoid: () => AuraCameraSpec;
    readonly miniGolf: () => AuraCameraSpec;
    readonly neon: () => AuraCameraSpec;
};
export interface AuraTimelineSpec {
    readonly mode: "loop" | "once";
    readonly seconds?: number;
    readonly startTime?: number;
    readonly duration?: number;
    readonly loop?: boolean;
    readonly easing?: "linear" | "easeInOut";
    readonly captureTime?: number;
}
export declare const timeline: {
    readonly loop: (options?: Omit<AuraTimelineSpec, "mode">) => AuraTimelineSpec;
    readonly once: (options?: Omit<AuraTimelineSpec, "mode">) => AuraTimelineSpec;
};
export declare const effects: {
    readonly fog: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
    readonly bloom: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
    readonly cinematicBloom: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
    readonly neonBloom: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
    readonly volumetricFog: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
    readonly depthFog: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
    readonly ambientOcclusion: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
    readonly contactOcclusion: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
    readonly rain: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
    readonly particles: (options?: Omit<AuraEffectNode, "kind" | "effect">) => AuraNodeBuilder<AuraEffectNode>;
};
export declare const interactions: {
    readonly orbit: (options?: {
        readonly target?: string;
    }) => AuraNodeBuilder<AuraInteractionNode>;
    readonly pointer: (options?: {
        readonly target?: string;
    }) => AuraNodeBuilder<AuraInteractionNode>;
    readonly keyboard: (options?: {
        readonly target?: string;
    }) => AuraNodeBuilder<AuraInteractionNode>;
    readonly hover: (options?: {
        readonly target?: string;
        readonly selected?: string;
    }) => AuraNodeBuilder<AuraInteractionNode>;
    readonly raycastHover: (options?: {
        readonly target?: string;
        readonly selected?: string;
    }) => AuraNodeBuilder<AuraInteractionNode>;
    readonly highlight: (options?: {
        readonly target?: string;
        readonly selected?: string;
    }) => AuraNodeBuilder<AuraInteractionNode>;
    readonly dragVector: (options?: {
        readonly target?: string;
        readonly vector?: AuraVec3;
    }) => AuraNodeBuilder<AuraInteractionNode>;
    readonly clickImpulse: (options?: {
        readonly target?: string;
        readonly impulse?: number;
        readonly vector?: AuraVec3;
    }) => AuraNodeBuilder<AuraInteractionNode>;
};
type AuraUiTarget<TElement extends HTMLElement = HTMLElement> = string | TElement;
export declare const ui: {
    readonly root: (selector?: string) => HTMLElement;
    readonly text: (selector: string) => HTMLElement;
    readonly button: (selector: string) => HTMLButtonElement;
    readonly html: (target: AuraUiTarget, markup: string, position?: InsertPosition) => HTMLElement;
    readonly setText: (target: AuraUiTarget, value: string | number) => void;
    readonly setPressed: (target: AuraUiTarget<HTMLButtonElement>, pressed: boolean) => void;
    readonly onClick: (target: AuraUiTarget<HTMLButtonElement>, handler: (button: HTMLButtonElement, event: MouseEvent) => void) => HTMLButtonElement;
    readonly range: (selector: string) => HTMLInputElement;
    readonly onInput: (target: AuraUiTarget<HTMLInputElement>, handler: (input: HTMLInputElement, event: Event) => void) => HTMLInputElement;
    readonly scoreCounter: (target: AuraUiTarget, options?: {
        readonly initial?: number;
        readonly label?: string;
    }) => {
        readonly element: HTMLElement;
        get value(): number;
        set(value: number): void;
        increment(amount?: number): number;
    };
    readonly powerMeter: (target: AuraUiTarget<HTMLInputElement>, options?: {
        readonly min?: number;
        readonly max?: number;
        readonly value?: number;
    }) => HTMLInputElement;
    readonly slider: (target: AuraUiTarget<HTMLInputElement>, options?: {
        readonly min?: number;
        readonly max?: number;
        readonly value?: number;
        readonly metric?: string;
    }) => HTMLInputElement;
    readonly resetButton: (target: AuraUiTarget<HTMLButtonElement>, handler?: (button: HTMLButtonElement, event: MouseEvent) => void) => HTMLButtonElement;
    readonly hoverReadout: (target: AuraUiTarget, value?: string) => HTMLElement;
    readonly toggle: (target: AuraUiTarget<HTMLButtonElement>, options?: {
        readonly pressed?: boolean;
        readonly onLabel?: string;
        readonly offLabel?: string;
    }) => HTMLButtonElement;
};
type AuraLabelOptions = Partial<Omit<AuraLabelNode, "kind" | "label" | "text">>;
type AuraAnchorLabelOptions = Partial<Omit<AuraLabelNode, "kind" | "label" | "text" | "target">>;
type AuraEnvironmentOptions = Partial<Omit<AuraEnvironmentNode, "kind" | "environment">>;
export declare const labels: {
    readonly billboard: (text: string, options?: AuraLabelOptions) => AuraNodeBuilder<AuraLabelNode>;
    readonly anchor: (text: string, target: string, options?: AuraAnchorLabelOptions) => AuraNodeBuilder<AuraLabelNode>;
    readonly axisTick: (text: string, options?: AuraLabelOptions) => AuraNodeBuilder<AuraLabelNode>;
    readonly callout: (text: string, target: string, options?: AuraAnchorLabelOptions) => AuraNodeBuilder<AuraLabelNode>;
    readonly hud: (text: string, options?: AuraLabelOptions) => AuraNodeBuilder<AuraLabelNode>;
};
export declare const environments: {
    readonly studio: (options?: AuraEnvironmentOptions) => AuraNodeBuilder<AuraEnvironmentNode>;
    readonly materialLab: (options?: AuraEnvironmentOptions) => AuraNodeBuilder<AuraEnvironmentNode>;
    readonly productHero: (options?: AuraEnvironmentOptions) => AuraNodeBuilder<AuraEnvironmentNode>;
    readonly nightCinematic: (options?: AuraEnvironmentOptions) => AuraNodeBuilder<AuraEnvironmentNode>;
    readonly metalStudio: (options?: AuraEnvironmentOptions) => AuraNodeBuilder<AuraEnvironmentNode>;
    readonly glassStudio: (options?: AuraEnvironmentOptions) => AuraNodeBuilder<AuraEnvironmentNode>;
    readonly presets: () => readonly AuraEnvironmentMapPreset[];
    readonly forMaterial: (materialClass: "metal" | "glass" | "product" | "studio") => AuraNodeBuilder<AuraEnvironmentNode>;
};
export declare const renderer: {
    readonly colorManagementPreset: () => AuraRendererColorManagementPreset;
    readonly exposurePresets: () => Readonly<Record<AuraSceneCategory, AuraSceneExposurePreset>>;
    readonly exposureFor: (category: AuraSceneCategory) => AuraSceneExposurePreset;
    readonly qualityPresets: () => Readonly<Record<"interactive" | "screenshot", AuraRendererQualityPreset>>;
    readonly screenshotQuality: () => AuraRendererQualityPreset;
    readonly diagnostics: (sceneValue: AuraSceneBuilder | AuraSceneSnapshot) => AuraRendererDiagnosticReport;
};
export interface AuraSceneSnapshot {
    readonly schema: "aura3d-scene-snapshot/1.0";
    readonly background: AuraColor;
    readonly camera: AuraCameraSpec;
    readonly timeline?: AuraTimelineSpec;
    readonly physics?: AuraPhysicsSceneSummary;
    readonly nodes: readonly AuraSceneNode[];
    readonly diagnostics: {
        readonly enabled: boolean;
    };
}
export declare class AuraSceneBuilder {
    private readonly nodes;
    private backgroundColor;
    private cameraSpec;
    private timelineSpec;
    private physicsController;
    private diagnosticsEnabled;
    background(color: AuraColor): this;
    add(node: AuraNodeBuilder<AuraSceneNode> | AuraSceneNode): this;
    addMany(nodes: readonly (AuraNodeBuilder<AuraSceneNode> | AuraSceneNode)[]): this;
    camera(next: AuraCameraSpec): this;
    timeline(next: AuraTimelineSpec): this;
    physics(next: AuraPhysicsWorldController): this;
    diagnostics(enabled?: boolean): this;
    toJSON(): AuraSceneSnapshot;
    getPhysicsController(): AuraPhysicsWorldController | undefined;
}
export declare function scene(): AuraSceneBuilder;
type AuraPhysicsBodyOptions = RigidBodyDescriptor & {
    readonly shape?: PhysicsShape;
    readonly sensor?: boolean;
    readonly material?: ColliderDescriptor["material"];
};
declare function resolveAgentPhysicsShape(spec: AuraNodePhysicsSpec): PhysicsShape;
export declare const physics: {
    readonly world: (descriptor?: PhysicsWorldDescriptor) => AuraPhysicsWorldController;
    readonly worldAsync: (descriptor?: PhysicsWorldDescriptor) => Promise<AuraPhysicsWorldController>;
    readonly worldFromScene: (sceneValue: AuraSceneBuilder | AuraSceneSnapshot, descriptor?: PhysicsWorldDescriptor) => AuraPhysicsWorldController;
    readonly worldFromSceneAsync: (sceneValue: AuraSceneBuilder | AuraSceneSnapshot, descriptor?: PhysicsWorldDescriptor) => Promise<AuraPhysicsWorldController>;
    readonly body: (options?: AuraPhysicsBodyOptions) => AuraPhysicsBodyOptions;
    readonly collider: (descriptor: ColliderDescriptor) => ColliderDescriptor;
    readonly box: (x?: number, y?: number, z?: number) => PhysicsShape;
    readonly sphere: (radius?: number) => PhysicsShape;
    readonly capsule: (radius?: number, halfHeight?: number) => PhysicsShape;
    readonly plane: (normal?: AuraVec3, constant?: number) => PhysicsShape;
    readonly constraint: (descriptor: ConstraintDescriptor) => ConstraintDescriptor;
    readonly bindNode: (world: AuraPhysicsWorldController, body: RigidBody | number, node: ScenePhysicsNode, mode?: "dynamic" | "kinematic") => void;
    readonly step: (world: AuraPhysicsWorldController, options?: number | AuraPhysicsStepOptions) => readonly CollisionEvent[];
    readonly contacts: (world: AuraPhysicsWorldController) => readonly Contact[];
    readonly liveContactCount: (world: AuraPhysicsWorldController) => number;
    readonly raycast: (world: AuraPhysicsWorldController, origin: AuraVec3, direction: AuraVec3, options?: RaycastOptions) => RaycastHit | undefined;
    readonly sphereCast: (world: AuraPhysicsWorldController, origin: AuraVec3, radius: number, direction: AuraVec3, options?: RaycastOptions) => SphereCastHit | undefined;
    readonly debug: (world: AuraPhysicsWorldController) => AuraPhysicsDebugSnapshot;
    readonly debugNodes: (world: AuraPhysicsWorldController) => readonly AuraSceneNode[];
    readonly sceneBinding: (node: ScenePhysicsNode) => ScenePhysicsNode;
    readonly nodeSpec: (spec: AuraNodePhysicsSpec) => AuraNodePhysicsSpec;
    readonly resolveShape: typeof resolveAgentPhysicsShape;
};
export type CityBlockTimeOfDay = "day" | "night";
export type AuraCityCameraPreset = "overview" | "street-level" | "cinematic-night";
export interface AuraCityBlockOptions {
    readonly blocks?: number;
    readonly litWindows?: boolean;
    readonly timeOfDay?: CityBlockTimeOfDay;
}
export interface AuraCityStateChangeEvidence {
    readonly from: CityBlockTimeOfDay;
    readonly to: CityBlockTimeOfDay;
    readonly revision: number;
    readonly changedNodeNames: readonly string[];
}
export interface AuraCityInstancingPlan {
    readonly kind: "aura-city-instancing-plan";
    readonly rendererPath: "auraWebGL2PrimitiveBatches";
    readonly windows: number;
    readonly props: number;
    readonly roadMarkings: number;
    readonly lights: number;
    readonly groups: readonly string[];
    readonly instanced: boolean;
}
export interface AuraCityVisualQAResult {
    readonly passes: boolean;
    readonly score: number;
    readonly buildings: number;
    readonly windows: number;
    readonly streets: number;
    readonly crosswalks: number;
    readonly lights: number;
    readonly props: number;
    readonly facadeDetails: number;
    readonly dayNightChanged: boolean;
    readonly instancing: AuraCityInstancingPlan;
    readonly problems: readonly string[];
}
export interface AuraCityStateController {
    readonly kind: "aura-city-state";
    readonly blocks: number;
    readonly litWindows: boolean;
    readonly timeOfDay: CityBlockTimeOfDay;
    readonly revision: number;
    readonly lastChange?: AuraCityStateChangeEvidence;
    setTimeOfDay(next: CityBlockTimeOfDay): readonly AuraSceneNode[];
    toggleTimeOfDay(): readonly AuraSceneNode[];
    scene(): AuraSceneBuilder;
    applyTo(builder: AuraSceneBuilder): AuraSceneBuilder;
    nodes(): readonly AuraSceneNode[];
}
export interface AuraSolarSystemPrefabOptions {
    readonly orbitSegments?: number;
    readonly starCount?: number;
    readonly dustCount?: number;
    readonly capturePhase?: number;
    readonly labels?: "attached" | "none";
}
export type AuraSolarPlanetMaterialPreset = "rocky" | "gas-giant" | "ice" | "moon" | "ringed" | "lava-venus";
export interface AuraSolarVisualQAResult {
    readonly passes: boolean;
    readonly score: number;
    readonly planets: number;
    readonly materialPresets: readonly AuraSolarPlanetMaterialPreset[];
    readonly orbitSegments: number;
    readonly labels: number;
    readonly leaderLines: number;
    readonly stars: number;
    readonly dust: number;
    readonly hasSunCorona: boolean;
    readonly hasBloom: boolean;
    readonly deterministicCapturePhase: boolean;
    readonly problems: readonly string[];
}
export type AuraNeonPalettePreset = "cyan-magenta" | "sunset-grid" | "acid-aurora";
export interface AuraNeonTunnelOptions {
    readonly rings?: number;
    readonly palette?: AuraNeonPalettePreset;
    readonly bloomIntensity?: number;
    readonly captureFrame?: number;
}
export interface AuraNeonVisualQAResult {
    readonly passes: boolean;
    readonly score: number;
    readonly ringCount: number;
    readonly hasFog: boolean;
    readonly hasBloom: boolean;
    readonly hasReflections: boolean;
    readonly hasDepthCues: boolean;
    readonly overexposureRisk: boolean;
    readonly problems: readonly string[];
}
export interface AuraPrimitiveHumanoidPrefabOptions {
    readonly showJoints?: boolean;
    readonly motionTrail?: boolean;
    readonly clip?: AuraCharacterClipName;
    readonly pose?: AuraCharacterPose;
    readonly style?: AuraCharacterStyle;
}
export interface AuraDataBars3DPrefabOptions {
    readonly grid?: number;
    readonly selected?: false | {
        readonly row?: number;
        readonly col?: number;
    };
    readonly dataset?: readonly (readonly number[])[];
    readonly title?: string;
    readonly subtitle?: string;
    readonly units?: string;
    readonly valueRange?: readonly [number, number];
    readonly theme?: AuraChartTheme;
    readonly colorScale?: readonly AuraColor[];
}
export type AuraChartTheme = "dark-analytics" | "light-analytics" | "neon-analytics";
export interface AuraChartVisualQAResult {
    readonly passes: boolean;
    readonly score: number;
    readonly bars: number;
    readonly labels: number;
    readonly legends: number;
    readonly selectedOutlines: number;
    readonly problems: readonly string[];
}
export type AuraProductStageStyle = "hero-clean" | "clean" | "inspection";
export interface AuraProductViewerOptions {
    readonly stageStyle?: AuraProductStageStyle;
    readonly provenanceBadge?: boolean;
    readonly captureFrame?: number;
}
export interface AuraProductPlacement {
    readonly kind: "aura-product-placement";
    readonly assetId: string;
    readonly bounds: AuraVec3;
    readonly position: AuraVec3;
    readonly scale: number;
    readonly plinthSeatY: number;
    readonly centered: boolean;
    readonly seatedOnPlinth: boolean;
    readonly normalizedFromBounds: boolean;
}
export interface AuraProductDiagnostics {
    readonly kind: "aura-product-diagnostics";
    readonly stageStyle: AuraProductStageStyle;
    readonly placement: AuraProductPlacement;
    readonly provenance: AuraAssetProvenance;
    readonly orbitEnabled: boolean;
    readonly turntableEnabled: boolean;
    readonly turntableCaptureFrame: number;
    readonly inspectionGuidesVisible: boolean;
    readonly provenanceBadgeVisible: boolean;
    readonly cleanHeroMode: boolean;
}
export interface AuraProductVisualQAResult {
    readonly passes: boolean;
    readonly score: number;
    readonly modelCount: number;
    readonly softboxes: number;
    readonly reflectionCards: number;
    readonly contactShadows: number;
    readonly materialReadabilityCues: number;
    readonly inspectionGuides: number;
    readonly cleanHeroMode: boolean;
    readonly centeredAndSeated: boolean;
    readonly typedAssetProvenance: boolean;
    readonly problems: readonly string[];
}
declare function solarPlanetMaterial(preset: AuraSolarPlanetMaterialPreset): AuraMaterialSpec;
interface AuraMiniGolfPrefabOptions {
    readonly ballPosition?: AuraVec3;
    readonly shots?: number;
    readonly score?: number;
    readonly collisions?: number;
    readonly contacts?: number;
    readonly cupTriggered?: boolean;
    readonly aimVector?: AuraVec3;
}
export declare const prefabs: {
    readonly particleFountain: (options?: {
        readonly color?: AuraColor;
        readonly count?: number;
        readonly emissionRate?: number;
    }) => readonly AuraSceneNode[];
    readonly cityBlock: (options?: AuraCityBlockOptions) => readonly AuraSceneNode[];
    readonly materialSwatches: () => readonly AuraSceneNode[];
    readonly productStage: (options?: {
        readonly style?: AuraProductStageStyle;
        readonly showStudioRig?: boolean;
    }) => readonly AuraSceneNode[];
    readonly productViewer: (asset: AuraAssetRef<"model">, options?: AuraProductViewerOptions) => readonly AuraSceneNode[];
    readonly physicsRamp: () => readonly AuraSceneNode[];
    readonly physicsPlayground: (options?: {
        readonly cubes?: number;
    }) => readonly AuraSceneNode[];
    readonly solarSystem: (options?: AuraSolarSystemPrefabOptions) => readonly AuraSceneNode[];
    readonly dataBars3D: (options?: AuraDataBars3DPrefabOptions) => readonly AuraSceneNode[];
    readonly neonTunnel: (options?: AuraNeonTunnelOptions) => readonly AuraSceneNode[];
    readonly miniGolfHole: (options?: AuraMiniGolfPrefabOptions) => readonly AuraSceneNode[];
    readonly miniGolfCourse: () => readonly AuraSceneNode[];
    readonly primitiveHumanoid: (options?: AuraPrimitiveHumanoidPrefabOptions) => readonly AuraSceneNode[];
    readonly lowPolyHumanoid: (options?: AuraPrimitiveHumanoidPrefabOptions) => readonly AuraSceneNode[];
};
export interface AuraMiniGolfMetrics {
    readonly physicsBackend: string;
    readonly deterministicReplayId: string;
    readonly replayFrame: number;
    readonly captureTime: number;
    readonly shots: number;
    readonly score: number;
    readonly collisions: number;
    readonly contacts: number;
    readonly cupTriggered: boolean;
    readonly resets: number;
    readonly selected: string;
    readonly aimVector: AuraVec3;
    readonly ballPosition: AuraVec3;
    readonly followCameraTarget: string;
    readonly settled: boolean;
}
export interface AuraMiniGolfStateController {
    readonly kind: "aura-mini-golf-state";
    shoot(options?: {
        readonly vector?: AuraVec3;
        readonly power?: number;
    }): AuraMiniGolfMetrics;
    step(steps?: number): AuraMiniGolfMetrics;
    reset(): AuraMiniGolfMetrics;
    nodes(): readonly AuraSceneNode[];
    snapshot(): AuraMiniGolfMetrics;
}
export interface AuraMiniGolfPointerPoint {
    readonly x: number;
    readonly y: number;
}
export interface AuraMiniGolfShotInput {
    readonly vector: AuraVec3;
    readonly power: number;
}
declare function miniGolfPointerShotFromDrag(start: AuraMiniGolfPointerPoint, end: AuraMiniGolfPointerPoint): AuraMiniGolfShotInput;
export declare const games: {
    readonly miniGolf: () => readonly AuraSceneNode[];
    readonly miniGolfHole: () => readonly AuraSceneNode[];
    readonly miniGolfCourse: () => readonly AuraSceneNode[];
    readonly createMiniGolfState: () => AuraMiniGolfStateController;
    readonly miniGolfPointerShot: typeof miniGolfPointerShotFromDrag;
    readonly miniGolfScene: () => AuraSceneBuilder;
};
declare function collectParticleBudgetDiagnostics(nodes: readonly AuraSceneNode[]): AuraParticleBudgetDiagnostics;
export declare const particles: {
    readonly materialModes: () => readonly AuraParticleMaterialMode[];
    readonly fountain: (options?: {
        readonly color?: AuraColor;
        readonly count?: number;
        readonly emissionRate?: number;
    }) => readonly AuraSceneNode[];
    readonly diagnostics: typeof collectParticleBudgetDiagnostics;
};
declare function validateNeonVisualQA(nodes: readonly AuraSceneNode[]): AuraNeonVisualQAResult;
export declare const neon: {
    readonly tunnel: (options?: AuraNeonTunnelOptions) => readonly AuraSceneNode[];
    readonly palettes: () => readonly AuraNeonPalettePreset[];
    readonly bloomPreset: (intensity?: number) => AuraNodeBuilder<AuraEffectNode>;
    readonly cameraFlythrough: (options?: {
        readonly seconds?: number;
        readonly captureFrame?: number;
    }) => AuraCameraSpec;
    readonly visualQA: typeof validateNeonVisualQA;
};
export declare const charts: {
    readonly barGrid3D: (options?: AuraDataBars3DPrefabOptions) => readonly AuraSceneNode[];
    readonly dataBars3D: (options?: AuraDataBars3DPrefabOptions) => readonly AuraSceneNode[];
    readonly configure: (options?: AuraDataBars3DPrefabOptions) => AuraDataBars3DPrefabOptions;
    readonly withDataset: (dataset: readonly (readonly number[])[], options?: Omit<AuraDataBars3DPrefabOptions, "dataset">) => AuraDataBars3DPrefabOptions;
    readonly themes: () => readonly AuraChartTheme[];
    readonly cameraPreset: (preset?: "readable-6x6" | "dashboard" | "hover-detail") => AuraCameraSpec;
    readonly visualQA: (nodes: readonly AuraSceneNode[]) => AuraChartVisualQAResult;
};
declare function createPrimitiveHumanoidSkeleton(style?: AuraCharacterStyle): AuraCharacterSkeleton;
declare function createProceduralHumanMesh(options?: AuraPrimitiveHumanoidPrefabOptions): AuraProceduralHumanMeshDescriptor;
declare function validatePrimitiveHumanoidVisualQA(nodes: readonly AuraSceneNode[]): AuraCharacterVisualQAResult;
export declare const character: {
    readonly builtInHumanoidAsset: () => AuraAssetRef<"model", "humanoid">;
    readonly skeleton: typeof createPrimitiveHumanoidSkeleton;
    readonly clips: () => readonly AuraCharacterClip[];
    readonly proceduralHumanMesh: typeof createProceduralHumanMesh;
    readonly lowPolyHumanoid: (options?: AuraPrimitiveHumanoidPrefabOptions) => readonly AuraSceneNode[];
    readonly authoredHumanoid: (options?: AuraPrimitiveHumanoidPrefabOptions) => readonly AuraSceneNode[];
    readonly primitiveHumanoid: (options?: AuraPrimitiveHumanoidPrefabOptions) => readonly AuraSceneNode[];
    readonly importedRigRuntime: (options: GLTFSceneAnimationRuntimeOptions) => Promise<GLTFSceneAnimationRuntime>;
    readonly visualQA: typeof validatePrimitiveHumanoidVisualQA;
    readonly validatePrimitiveHumanoid: typeof validatePrimitiveHumanoidVisualQA;
};
declare function cityCameraPreset(preset?: AuraCityCameraPreset, timeOfDay?: CityBlockTimeOfDay): AuraCameraSpec;
declare function cityScene(options?: AuraCityBlockOptions & {
    readonly cameraPreset?: AuraCityCameraPreset;
}): AuraSceneBuilder;
declare function collectCityInstancingPlan(nodes: readonly AuraSceneNode[]): AuraCityInstancingPlan;
declare function validateCityVisualQA(nodes: readonly AuraSceneNode[], options?: {
    readonly changed?: AuraCityStateChangeEvidence;
}): AuraCityVisualQAResult;
declare function createCityStateController(options?: AuraCityBlockOptions): AuraCityStateController;
export interface AuraCityBrowserRuntimeState {
    readonly kind: "aura-city-browser-runtime";
    readonly mounted: true;
    readonly timeOfDay: CityBlockTimeOfDay;
    readonly revision: number;
    readonly changedNodeNames: readonly string[];
}
export interface AuraCityDayNightToggleOptions {
    readonly onChange?: (timeOfDay: CityBlockTimeOfDay, state: AuraCityBrowserRuntimeState) => void;
}
declare function bindCityDayNightToggle(target: AuraUiTarget<HTMLButtonElement>, app: AuraApp, state?: AuraCityStateController, options?: AuraCityDayNightToggleOptions): HTMLButtonElement;
export declare const city: {
    readonly createState: typeof createCityStateController;
    readonly bindDayNightToggle: typeof bindCityDayNightToggle;
    readonly block: (options?: AuraCityBlockOptions) => readonly AuraSceneNode[];
    readonly cityBlock: (options?: AuraCityBlockOptions) => readonly AuraSceneNode[];
    readonly scene: typeof cityScene;
    readonly cameraPreset: typeof cityCameraPreset;
    readonly cameras: (timeOfDay?: CityBlockTimeOfDay) => Record<AuraCityCameraPreset, AuraCameraSpec>;
    readonly instancing: typeof collectCityInstancingPlan;
    readonly visualQA: typeof validateCityVisualQA;
};
declare function productPlacement(asset: AuraAssetRef<"model">): AuraProductPlacement;
declare function productScene(asset: AuraAssetRef<"model">, options?: AuraProductViewerOptions): AuraSceneBuilder;
declare function productDiagnostics(asset: AuraAssetRef<"model">, nodes: readonly AuraSceneNode[], options?: AuraProductViewerOptions): AuraProductDiagnostics;
declare function validateProductVisualQA(nodes: readonly AuraSceneNode[], diagnostics?: AuraProductDiagnostics): AuraProductVisualQAResult;
export declare const product: {
    readonly placement: typeof productPlacement;
    readonly stage: (options?: {
        readonly style?: AuraProductStageStyle;
    }) => readonly AuraSceneNode[];
    readonly viewer: (asset: AuraAssetRef<"model">, options?: AuraProductViewerOptions) => readonly AuraSceneNode[];
    readonly scene: typeof productScene;
    readonly diagnostics: typeof productDiagnostics;
    readonly visualQA: typeof validateProductVisualQA;
};
declare function solarCameraPreset(): AuraCameraSpec;
declare function solarScene(options?: AuraSolarSystemPrefabOptions): AuraSceneBuilder;
declare function validateSolarVisualQA(nodes: readonly AuraSceneNode[]): AuraSolarVisualQAResult;
export declare const solar: {
    readonly system: (options?: AuraSolarSystemPrefabOptions) => readonly AuraSceneNode[];
    readonly scene: typeof solarScene;
    readonly cameraPreset: typeof solarCameraPreset;
    readonly materialPresets: () => readonly AuraSolarPlanetMaterialPreset[];
    readonly planetMaterial: typeof solarPlanetMaterial;
    readonly visualQA: typeof validateSolarVisualQA;
};
export type AuraSceneKitId = "physicsPlayground" | "particleFountain" | "solarSystem" | "neonTunnel" | "dataViz" | "miniGolf" | "materialLab" | "cityBlock" | "humanoidWalk" | "productViewer";
export interface AuraSceneKitCustomizeOptions {
    readonly dataset?: readonly (readonly number[])[];
    readonly colors?: readonly AuraColor[];
    readonly camera?: AuraCameraSpec;
    readonly timeOfDay?: CityBlockTimeOfDay;
    readonly particleCount?: number;
    readonly emissionRate?: number;
    readonly materialSettings?: Partial<AuraMaterialSpec>;
    readonly animationState?: AuraCharacterClipName | string;
    readonly asset?: AuraAssetRef<"model">;
    readonly stageStyle?: AuraProductStageStyle;
    readonly captureFrame?: number;
    readonly blocks?: number;
    readonly cubes?: number;
}
export interface AuraSceneKitDiagnostics {
    readonly kind: "aura-scene-kit-diagnostics";
    readonly id: AuraSceneKitId;
    readonly nodeCount: number;
    readonly lightCount: number;
    readonly effectCount: number;
    readonly interactionCount: number;
    readonly uiCount: number;
    readonly cameraMode: AuraCameraMode;
    readonly structuralScore?: number;
    readonly problems: readonly string[];
    readonly performance: AuraSceneKitPerformanceDiagnostics;
}
export interface AuraSceneKitPerformanceDiagnostics {
    readonly kind: "aura-scene-kit-performance-diagnostics";
    readonly drawCalls: AuraSceneKitDrawCallBudget;
    readonly bundle: AuraSceneKitBundleBudget;
    readonly fps: AuraSceneKitFpsBudget;
    readonly instancing: AuraSceneKitInstancingEvidence;
    readonly lod: AuraSceneKitLodEvidence;
    readonly lazyLoading: AuraSceneKitLazyLoadingPlan;
}
export interface AuraSceneKitDrawCallBudget {
    readonly kind: "aura-scene-kit-draw-call-budget";
    readonly maxDrawCalls: number;
    readonly estimatedDrawCalls: number;
    readonly pass: boolean;
    readonly evidence: string;
}
export interface AuraSceneKitBundleBudget {
    readonly kind: "aura-scene-kit-bundle-budget";
    readonly maxGzipBytes: number;
    readonly estimatedGzipBytes: number;
    readonly pass: boolean;
    readonly evidence: string;
}
export interface AuraSceneKitFpsBudget {
    readonly kind: "aura-scene-kit-fps-budget";
    readonly targetP50Fps: number;
    readonly calibrationRequired: boolean;
    readonly p50Metric: "metrics.p50Fps";
    readonly calibrationSource: "benchmark/runner/fps-calibration.mjs";
}
export interface AuraSceneKitInstancingFamilyEvidence {
    readonly family: string;
    readonly instanceCount: number;
    readonly estimatedDrawCallsWithoutInstancing: number;
    readonly estimatedDrawCallsWithInstancing: number;
    readonly evidence: string;
}
export interface AuraSceneKitInstancingEvidence {
    readonly kind: "aura-scene-kit-instancing-evidence";
    readonly applied: boolean;
    readonly families: readonly AuraSceneKitInstancingFamilyEvidence[];
    readonly estimatedDrawCallsWithoutInstancing: number;
    readonly estimatedDrawCallsWithInstancing: number;
    readonly estimatedDrawCallSavings: number;
}
export interface AuraSceneKitLodEvidence {
    readonly kind: "aura-scene-kit-lod-evidence";
    readonly applied: boolean;
    readonly strategy: "dense-impostors" | "bounded-static-scene";
    readonly levels: readonly string[];
    readonly evidence: string;
}
export type AuraSceneKitLazySystemId = "physics-backend" | "product-gltf-loader" | "postprocess" | "character-rig";
export interface AuraSceneKitLazyLoadingEntry {
    readonly system: AuraSceneKitLazySystemId;
    readonly trigger: string;
    readonly loadedByDefault: false;
    readonly evidence: string;
}
export interface AuraSceneKitLazyLoadingPlan {
    readonly kind: "aura-scene-kit-lazy-loading-plan";
    readonly systems: readonly AuraSceneKitLazyLoadingEntry[];
    readonly allOptional: boolean;
}
export interface AuraLazySystemEvidence {
    readonly kind: "aura-lazy-system-evidence";
    readonly system: AuraSceneKitLazySystemId;
    readonly requested: boolean;
    readonly loaded: boolean;
    readonly requestCount: number;
    readonly loadCount: number;
    readonly lastReason?: string;
    readonly lastLoadMs?: number;
}
export declare function markAuraLazySystemRequested(system: AuraSceneKitLazySystemId, reason?: string): void;
export declare function markAuraLazySystemLoaded(system: AuraSceneKitLazySystemId, loadMs?: number): void;
export declare function collectAuraLazySystemEvidence(): readonly AuraLazySystemEvidence[];
export declare const lazySystems: {
    readonly markRequested: typeof markAuraLazySystemRequested;
    readonly markLoaded: typeof markAuraLazySystemLoaded;
    readonly collect: typeof collectAuraLazySystemEvidence;
};
export interface AuraSceneKit {
    readonly kind: "aura-scene-kit";
    readonly id: AuraSceneKitId;
    readonly nodes: readonly AuraSceneNode[];
    readonly camera: AuraCameraSpec;
    readonly lights: readonly AuraSceneNode[];
    readonly effects: readonly AuraSceneNode[];
    readonly interactions: readonly AuraSceneNode[];
    readonly ui: readonly AuraSceneNode[];
    readonly diagnostics: AuraSceneKitDiagnostics;
    readonly evidence: readonly string[];
    readonly acceptanceEvidence: readonly string[];
    scene(): AuraSceneBuilder;
    toAppOptions(): AuraCreateAppOptions;
    customize(options: AuraSceneKitCustomizeOptions): AuraSceneKit;
}
export interface AuraSceneKitBudgetDefaults {
    readonly maxDrawCalls: number;
    readonly estimatedDrawCalls: number;
    readonly maxGzipBytes: number;
    readonly estimatedGzipBytes: number;
    readonly targetP50Fps: number;
    readonly evidence: string;
}
export declare function sceneKitPerformanceBudget(id: AuraSceneKitId): AuraSceneKitBudgetDefaults;
export declare const sceneKits: {
    readonly physicsPlayground: (options?: AuraSceneKitCustomizeOptions) => AuraSceneKit;
    readonly particleFountain: (options?: AuraSceneKitCustomizeOptions) => AuraSceneKit;
    readonly solarSystem: (options?: AuraSceneKitCustomizeOptions) => AuraSceneKit;
    readonly neonTunnel: (options?: AuraSceneKitCustomizeOptions) => AuraSceneKit;
    readonly dataViz: (options?: AuraSceneKitCustomizeOptions) => AuraSceneKit;
    readonly miniGolf: (options?: AuraSceneKitCustomizeOptions) => AuraSceneKit;
    readonly materialLab: (options?: AuraSceneKitCustomizeOptions) => AuraSceneKit;
    readonly cityBlock: (options?: AuraSceneKitCustomizeOptions) => AuraSceneKit;
    readonly humanoidWalk: (options?: AuraSceneKitCustomizeOptions) => AuraSceneKit;
    readonly productViewer: (asset: AuraAssetRef<"model">, options?: Omit<AuraSceneKitCustomizeOptions, "asset">) => AuraSceneKit;
};
export type AuraPromptSceneType = "product-viewer" | "cinematic-scene" | "mini-game" | "material-studio";
export type AuraPromptEffectId = "rain" | "fog" | "bloom" | "particles" | "wet-reflection" | "motion-trail" | "hud";
export type AuraPromptCameraPreset = "product-orbit" | "cinematic-dolly" | "game-board" | "material-inspection";
export type AuraPromptLightingPreset = "studio-softbox" | "neon-practicals" | "game-readable" | "material-studio";
export type AuraPromptInteractionMode = "orbit" | "keyboard" | "pointer";
export interface AuraPromptPlanSubject {
    readonly asset: AuraAssetRef<"model">;
    readonly label?: string;
}
export interface AuraPromptPlan {
    readonly sceneType: AuraPromptSceneType;
    readonly subject: AuraPromptPlanSubject;
    readonly style?: string;
    readonly environment?: string;
    readonly camera?: {
        readonly preset: AuraPromptCameraPreset;
        readonly note?: string;
    };
    readonly lighting?: {
        readonly preset: AuraPromptLightingPreset;
        readonly note?: string;
    };
    readonly effects?: readonly AuraPromptEffectId[];
    readonly interaction?: AuraPromptInteractionMode;
    readonly acceptanceCriteria: readonly string[];
    readonly negativeCriteria?: readonly string[];
}
export interface AuraPromptPlanReport {
    readonly schema: "aura3d-prompt-plan-report/1.0";
    readonly sceneType: AuraPromptSceneType;
    readonly subjectAssetId: string;
    readonly recipe: AuraPromptSceneType;
    readonly cameraPreset: AuraPromptCameraPreset;
    readonly lightingPreset: AuraPromptLightingPreset;
    readonly effects: readonly AuraPromptEffectId[];
    readonly acceptanceCriteria: readonly string[];
    readonly negativeCriteria: readonly string[];
    readonly warnings: readonly string[];
    readonly visualSystems: readonly string[];
    readonly repairHints: readonly string[];
}
export interface AuraCompiledPromptPlan {
    readonly scene: AuraSceneBuilder;
    readonly report: AuraPromptPlanReport;
}
export declare function definePromptPlan<const TPlan extends AuraPromptPlan>(plan: TPlan): TPlan;
export declare function compilePromptPlan(plan: AuraPromptPlan): AuraCompiledPromptPlan;
export declare function promptPlanToScene(plan: AuraPromptPlan): AuraSceneBuilder;
export declare const promptRecipes: {
    readonly "product-viewer": (asset: AuraAssetRef<"model">, plan: AuraPromptPlan) => AuraSceneBuilder;
    readonly "cinematic-scene": (asset: AuraAssetRef<"model">, plan: AuraPromptPlan) => AuraSceneBuilder;
    readonly "mini-game": (asset: AuraAssetRef<"model">, plan: AuraPromptPlan) => AuraSceneBuilder;
    readonly "material-studio": (asset: AuraAssetRef<"model">, plan: AuraPromptPlan) => AuraSceneBuilder;
};
export type AuraBackend = "webgl2" | "webgpu" | "canvas2d" | "headless";
export interface AuraDiagnostics {
    readonly backend: AuraBackend;
    readonly fps: number;
    readonly drawCalls: number;
    readonly renderSize: readonly [number, number];
    readonly assets: readonly AuraAssetLoadState[];
    readonly evidence?: AuraSceneEvidence;
    readonly renderer?: AuraRendererDiagnosticReport;
    readonly warnings: readonly string[];
    readonly errors: readonly string[];
}
export interface AuraAssetProvenance {
    readonly source: "typed-aura-assets-manifest" | "unsafe-url" | "inline-definition";
    readonly id: string;
    readonly url: string;
    readonly hash?: string;
    readonly bounds?: AuraVec3;
}
export interface AuraAssetLoadState {
    readonly id: string;
    readonly type: AuraAssetType;
    readonly url: string;
    readonly status: "ready" | "optional-missing" | "error";
    readonly hash?: string;
    readonly provenance?: AuraAssetProvenance;
    readonly message?: string;
}
export interface AuraSceneEvidence {
    readonly physics: {
        readonly worldAttached: boolean;
        readonly bodies: number;
        readonly colliders: number;
        readonly contacts: number;
        readonly steps: number;
        readonly resets: number;
        readonly nodesWithPhysics: number;
        readonly sensors: number;
    };
    readonly interactions: {
        readonly modes: readonly AuraInteractionNode["mode"][];
        readonly orbitEnabled: boolean;
        readonly hoverTargets: readonly string[];
        readonly dragTargets: readonly string[];
        readonly impulseTargets: readonly string[];
    };
    readonly camera: {
        readonly mode: AuraCameraMode;
        readonly orbitEnabled: boolean;
        readonly followTarget?: string;
        readonly captureTime?: number;
    };
    readonly animation: {
        readonly animatedNodes: number;
        readonly turntableEnabled: boolean;
        readonly walkEnabled: boolean;
        readonly clips: readonly string[];
    };
    readonly labels: {
        readonly count: number;
        readonly kinds: readonly AuraLabelNode["label"][];
        readonly occlusionAware: number;
        readonly collisionAvoidance: number;
    };
    readonly performance: {
        readonly budgets: readonly AuraHelperPerformanceBudget[];
        readonly helperCount: number;
        readonly nodeBudgetExceeded: readonly AuraHelperBudgetId[];
    };
    readonly rendering: AuraRendererDiagnosticReport;
    readonly assets: readonly AuraAssetProvenance[];
}
export interface AuraApp {
    readonly canvas?: HTMLCanvasElement;
    readonly scene: AuraSceneSnapshot;
    readonly backend: AuraBackend;
    setScene(scene: AuraSceneBuilder | AuraSceneSnapshot): void;
    diagnostics(): AuraDiagnostics;
    screenshot(): AuraScreenshot;
    dispose(): void;
}
export interface AuraCreateAppOptions {
    readonly scene: AuraSceneBuilder | AuraSceneSnapshot;
    readonly diagnostics?: boolean | AuraDiagnosticsOptions;
    readonly pixelRatio?: number;
    readonly autoStart?: boolean;
    readonly resize?: boolean;
}
export interface AuraDiagnosticsOptions {
    readonly overlay?: boolean;
    readonly assetPanel?: boolean;
    readonly performancePanel?: boolean;
}
export interface AuraScreenshot {
    readonly mimeType: "image/png";
    readonly dataUrl: string;
    readonly width: number;
    readonly height: number;
}
export type AuraAppTarget = string | HTMLElement | HTMLCanvasElement | null | undefined;
export declare class AuraRuntimeError extends Error {
    readonly code: "missing-canvas" | "missing-asset" | "failed-glb-load" | "unsupported-texture" | "backend-fallback";
    constructor(code: AuraRuntimeError["code"], message: string);
}
export declare function createAuraApp(target: AuraAppTarget, options: AuraCreateAppOptions): AuraApp;
export declare function createAuraRouteHealthSnapshot(app: AuraApp): {
    readonly status: "ready" | "error";
    readonly diagnostics: AuraDiagnostics;
    readonly scene: AuraSceneSnapshot;
};
export declare function collectAuraSceneEvidence(sceneValue: AuraSceneBuilder | AuraSceneSnapshot): AuraSceneEvidence;
export declare const performance: {
    readonly helperBudgets: () => readonly AuraHelperPerformanceBudget[];
    readonly budgetFor: (helper: AuraHelperBudgetId) => AuraHelperPerformanceBudget | undefined;
    readonly sceneKitBudgets: () => Readonly<Record<AuraSceneKitId, AuraSceneKitBudgetDefaults>>;
    readonly budgetForSceneKit: (id: AuraSceneKitId) => AuraSceneKitBudgetDefaults;
    readonly budgetsForScene: (sceneValue: AuraSceneBuilder | AuraSceneSnapshot) => readonly AuraHelperPerformanceBudget[];
};
export declare function captureAuraScreenshot(target?: HTMLCanvasElement): AuraScreenshot;
export declare function createAuraAssetLoadError(asset: AuraAssetRef<"model">, reason: string): AuraRuntimeError;
//# sourceMappingURL=index.d.ts.map