import { ProductionRuntimeRenderer, summarizeProductionProductionProof, type ProductionEnvironmentLightingResources, type ProductionPbrHdrPipeline, type ProductionToneMappingOperator, type ProductionRenderProof, type ContactShadowPassDiagnostics, type ProductionRuntimeRendererBackendPreference, type ProductionRuntimeRendererBackendSelection, type ProductionRuntimeRendererOptions } from "@aura3d/rendering";
import { createProductionGLTFRenderMetadata, loadProductionGLTFRenderPipeline, type GLTFSceneAnimationApplyResult, type GLTFSceneAnimationRuntime, type GLTFSceneAnimationRuntimeSnapshot, type ProductionGLTFRenderMetadata, type ProductionGLTFRenderPipeline } from "@aura3d/assets";
import { AnimationAction, AnimationMixer, type AnimationClip, type AnimationEvent, type AnimationMixerSnapshot, type AnimationTarget } from "@aura3d/animation";
import { PhysicsWorld, type CollisionEvent, type ConstraintType, type PhysicsSnapshot, type RigidBody, type RigidBodyType, type Vec3 } from "@aura3d/physics";
import type { CameraFrameBounds, CameraLike, CollectedLight, EnvironmentLightingOptions, RenderItem, RenderSource, RendererPostProcessOptions, RendererShadowOptions } from "@aura3d/rendering";
import type { GLTFMaterialRenderStateOverride, GLTFRendererInputOptions } from "@aura3d/assets";
export * as productionRendering from "@aura3d/rendering";
export * as productionWorkflows from "@aura3d/workflows";
export declare const productionAssets: {
    createProductionGLTFRenderMetadata: typeof createProductionGLTFRenderMetadata;
    loadProductionGLTFRenderPipeline: typeof loadProductionGLTFRenderPipeline;
};
export declare const AURA3D_ENGINE_PRODUCTION_PRODUCT_SURFACE = "a3d-renderer-production-runtime-sdk";
export declare const A3D_THREEJS_EXAMPLE_PARITY_TARGETS: {
    readonly keyframes: "webgl_animation_keyframes";
    readonly skinningBlending: "webgl_animation_skinning_blending";
    readonly additiveBlending: "webgl_animation_skinning_additive_blending";
    readonly skinningIk: "webgl_animation_skinning_ik";
    readonly skinningMorph: "webgl_animation_skinning_morph";
    readonly multipleAnimations: "webgl_animation_multiple";
    readonly walkCycle: "webgl_animation_walk";
    readonly decals: "webgl_decals";
    readonly parallaxBarrier: "webgl_effects_parallaxbarrier";
    readonly stereo: "webgl_effects_stereo";
};
export interface A3DRendererOptions extends ProductionRuntimeRendererOptions {
    readonly backend?: ProductionRuntimeRendererBackendPreference;
}
export interface A3DRenderResult {
    readonly proof: ProductionRenderProof;
    readonly summary: ReturnType<typeof summarizeProductionProductionProof>;
}
export interface A3DFrameRenderResult {
    readonly backend: "webgl2" | "webgpu";
    readonly diagnostics: ReturnType<ProductionRuntimeRenderer["getDiagnostics"]>;
    readonly features: ReturnType<ProductionRuntimeRenderer["getFeatures"]>;
    readonly timing?: NonNullable<ReturnType<ProductionRuntimeRenderer["renderInteractiveFrame"]>["timing"]>;
}
export interface A3DRenderOptions {
    readonly scene: A3DGltfScene;
    readonly environment?: A3DHdrEnvironment;
    readonly environmentLighting?: EnvironmentLightingOptions;
    readonly renderItems?: Iterable<RenderItem>;
    readonly collectedLights?: Iterable<CollectedLight>;
    readonly shadow?: RendererShadowOptions | boolean;
    readonly camera?: CameraLike;
    readonly viewport?: A3DViewport;
    readonly postprocess?: RendererPostProcessOptions | boolean;
}
export declare class A3DRenderer {
    private readonly renderer;
    private readonly viewport;
    readonly backend: "webgl2" | "webgpu";
    readonly backendSelection: ProductionRuntimeRendererBackendSelection;
    private constructor();
    static create(options: A3DRendererOptions): Promise<A3DRenderer>;
    captureProof(input: A3DRenderOptions): A3DRenderResult;
    render(input: A3DRenderOptions): A3DRenderResult;
    renderInteractiveFrame(input: A3DRenderOptions): A3DFrameRenderResult;
    renderFrame(input: A3DRenderOptions): A3DFrameRenderResult;
    captureProofAsync(input: A3DRenderOptions): Promise<A3DRenderResult>;
    renderAsync(input: A3DRenderOptions): Promise<A3DRenderResult>;
    renderInteractiveFrameAsync(input: A3DRenderOptions): Promise<A3DFrameRenderResult>;
    renderFrameAsync(input: A3DRenderOptions): Promise<A3DFrameRenderResult>;
    getDiagnostics(): import("@aura3d/rendering").RenderDeviceDiagnostics;
    dispose(): void;
    private defaultViewport;
    private metadataForRender;
}
export interface A3DViewport {
    readonly width: number;
    readonly height: number;
}
export type A3DVec3 = readonly [number, number, number];
export interface A3DDirectionalLightOptions {
    readonly name?: string;
    readonly direction?: A3DVec3;
    readonly color?: A3DVec3;
    readonly intensity?: number;
    readonly castsShadow?: boolean;
}
export interface A3DStudioLightingOptions {
    readonly preset?: "product" | "inspection" | "softbox";
    readonly intensityScale?: number;
    readonly shadows?: boolean;
}
export interface A3DGroundedStageOptions {
    readonly labelPrefix?: string;
    readonly floorColor?: readonly [number, number, number, number];
    readonly backdropColor?: readonly [number, number, number, number];
    readonly floorRoughness?: number;
    readonly backdropRoughness?: number;
    readonly floorMetallic?: number;
    readonly contactShadows?: boolean;
    readonly background?: boolean;
    readonly shadowLightDirection?: A3DVec3;
}
export interface A3DGroundedStageSettings {
    readonly backgroundBlur?: number;
    readonly backgroundVisible?: boolean;
}
export interface A3DGroundedStageDiagnostics {
    readonly labelPrefix: string;
    readonly floorY: number;
    readonly floorItemCount: number;
    readonly backgroundItemCount: number;
    readonly contactShadow?: ContactShadowPassDiagnostics;
}
export interface A3DGroundedStage {
    readonly groundingItems: readonly RenderItem[];
    readonly backgroundItems: readonly RenderItem[];
    readonly floorY: number;
    readonly diagnostics: A3DGroundedStageDiagnostics;
    update(settings?: A3DGroundedStageSettings): void;
    renderItems(options?: {
        readonly shadows?: boolean;
        readonly backgroundVisible?: boolean;
    }): readonly RenderItem[];
    dispose(): void;
}
export interface A3DCameraFrameOptions {
    readonly bounds: CameraFrameBounds;
    readonly viewport: A3DViewport;
    readonly preset?: "product-hero" | "asset-inspection" | "material-inspection";
    readonly target?: A3DVec3;
    readonly yawRadians?: number;
    readonly pitchRadians?: number;
    readonly zoom?: number;
    readonly paddingRatio?: number;
}
export interface A3DCameraFrame {
    readonly camera: CameraLike;
    readonly diagnostics: A3DProductViewerCameraDiagnostics;
}
export interface A3DProductionSceneOptions {
    readonly scene: A3DGltfScene;
    readonly environment?: A3DHdrEnvironment;
    readonly viewport: A3DViewport;
    readonly stage?: A3DGroundedStage;
    readonly backgroundVisible?: boolean;
    readonly extraRenderItems?: Iterable<RenderItem>;
    readonly lights?: readonly CollectedLight[];
    readonly camera?: CameraLike;
    readonly cameraFrame?: A3DCameraFrameOptions;
    readonly shadows?: RendererShadowOptions | boolean;
    readonly postprocess?: RendererPostProcessOptions | boolean;
    readonly environmentLighting?: EnvironmentLightingOptions;
}
export declare function createDirectionalLight(options?: A3DDirectionalLightOptions): CollectedLight;
export declare function createStudioLighting(options?: A3DStudioLightingOptions): readonly CollectedLight[];
export declare function createGroundedStage(bounds: CameraFrameBounds, options?: A3DGroundedStageOptions): A3DGroundedStage;
export declare function createCameraFrame(options: A3DCameraFrameOptions): A3DCameraFrame;
export declare function createProductionRenderOptions(options: A3DProductionSceneOptions): A3DRenderOptions;
export type A3DExampleParityTargetId = keyof typeof A3D_THREEJS_EXAMPLE_PARITY_TARGETS;
export interface A3DImportedAnimationRuntime {
    readonly scene: A3DGltfScene;
    readonly runtime: GLTFSceneAnimationRuntime;
    applyClip(name: string, time: number): GLTFSceneAnimationApplyResult;
    blendClips(samples: readonly {
        readonly clipName: string;
        readonly time: number;
        readonly weight?: number;
        readonly additive?: boolean;
    }[]): GLTFSceneAnimationApplyResult;
    solveTwoBoneIK(options: Parameters<GLTFSceneAnimationRuntime["solveImportedSkeletonTwoBoneIK"]>[0]): ReturnType<GLTFSceneAnimationRuntime["solveImportedSkeletonTwoBoneIK"]>;
    snapshot(): GLTFSceneAnimationRuntimeSnapshot;
}
export declare function createImportedAnimationRuntime(scene: A3DGltfScene): A3DImportedAnimationRuntime;
export interface A3DAnimationActionOptions {
    readonly weight?: number;
    readonly timeScale?: number;
    readonly loop?: "once" | "repeat" | "pingpong";
    readonly layer?: string;
    readonly additive?: boolean;
    readonly mask?: readonly string[];
}
export interface A3DAnimationControllerOptions {
    readonly target?: AnimationTarget;
    readonly clips?: readonly AnimationClip[];
    readonly applyRootMotion?: boolean;
    readonly rootMotionTrack?: string;
    readonly rootMotionScale?: number;
}
export interface A3DAnimationControllerSnapshot {
    readonly mixer: AnimationMixerSnapshot;
    readonly registeredClips: readonly string[];
    readonly updateCount: number;
    readonly crossFadeCount: number;
    readonly lastEventCount: number;
    readonly parityTargets: typeof A3D_THREEJS_EXAMPLE_PARITY_TARGETS;
    readonly capabilities: {
        readonly keyframes: true;
        readonly crossFade: true;
        readonly additiveLayers: boolean;
        readonly layerMasks: boolean;
        readonly rootMotion: boolean;
        readonly importedGltfAnimationRuntime: true;
        readonly importedSkinningPaletteRefresh: true;
        readonly importedMorphWeightAnimation: true;
    };
}
export interface A3DAnimationController {
    readonly mixer: AnimationMixer;
    registerClip(clip: AnimationClip): AnimationClip;
    play(clip: string | AnimationClip, options?: A3DAnimationActionOptions): AnimationAction;
    crossFade(from: string | AnimationAction, to: string | AnimationAction | AnimationClip, duration: number): void;
    update(deltaSeconds: number): readonly AnimationEvent[];
    snapshot(): A3DAnimationControllerSnapshot;
    dispose(): void;
}
export declare function createAnimationController(options?: A3DAnimationControllerOptions): A3DAnimationController;
export interface A3DPhysicsSceneOptions {
    readonly gravity?: Vec3;
    readonly fixedDelta?: number;
    readonly solverIterations?: number;
    readonly enableSleeping?: boolean;
}
export interface A3DPhysicsBodyOptions {
    readonly type?: RigidBodyType;
    readonly position?: A3DVec3;
    readonly velocity?: A3DVec3;
    readonly mass?: number;
    readonly restitution?: number;
    readonly friction?: number;
    readonly shape?: {
        readonly kind: "box" | "sphere" | "capsule";
        readonly halfExtents?: A3DVec3;
        readonly radius?: number;
        readonly halfHeight?: number;
    };
    readonly sensor?: boolean;
}
export interface A3DPhysicsConstraintOptions {
    readonly type: ConstraintType;
    readonly bodyA: RigidBody;
    readonly bodyB: RigidBody;
    readonly localAnchorA?: A3DVec3;
    readonly localAnchorB?: A3DVec3;
    readonly restLength?: number;
    readonly stiffness?: number;
    readonly axis?: A3DVec3;
}
export interface A3DPhysicsStepOptions {
    readonly dt?: number;
    readonly steps?: number;
}
export interface A3DPhysicsSceneSnapshot {
    readonly world: PhysicsSnapshot;
    readonly parityTargets: Pick<typeof A3D_THREEJS_EXAMPLE_PARITY_TARGETS, "walkCycle">;
    readonly capabilities: {
        readonly dynamicRigidBodies: true;
        readonly staticColliders: true;
        readonly constraints: true;
        readonly contacts: true;
        readonly raycast: true;
        readonly sphereCast: true;
    };
}
export interface A3DPhysicsScene {
    readonly world: PhysicsWorld;
    createBody(options?: A3DPhysicsBodyOptions): RigidBody;
    createGroundPlane(constant?: number): RigidBody;
    addConstraint(options: A3DPhysicsConstraintOptions): ReturnType<PhysicsWorld["createConstraint"]>;
    step(options?: number | A3DPhysicsStepOptions): readonly CollisionEvent[];
    raycast(origin: A3DVec3, direction: A3DVec3, maxDistance?: number): ReturnType<PhysicsWorld["raycast"]>;
    sphereCast(origin: A3DVec3, radius: number, direction: A3DVec3, maxDistance?: number): ReturnType<PhysicsWorld["sphereCast"]>;
    snapshot(): A3DPhysicsSceneSnapshot;
}
export declare function createPhysicsScene(options?: A3DPhysicsSceneOptions): A3DPhysicsScene;
export interface A3DGltfSceneOptions {
    readonly url: string;
    readonly assetId?: string;
    readonly assetName?: string;
    readonly materialVariant?: string;
    readonly materialRenderStateOverrides?: readonly GLTFMaterialRenderStateOverride[];
    readonly sceneIndex?: number;
    readonly sceneName?: string;
    readonly viewport?: A3DViewport;
    readonly rendererInput?: GLTFRendererInputOptions;
}
export interface A3DGltfRendererInputOptions {
    readonly viewport: A3DViewport;
    readonly environment?: A3DHdrEnvironment;
    readonly environmentLighting?: EnvironmentLightingOptions;
    readonly renderItems?: Iterable<RenderItem>;
    readonly collectedLights?: Iterable<CollectedLight>;
    readonly shadow?: RendererShadowOptions | boolean;
    readonly postprocess?: RendererPostProcessOptions | boolean;
}
export declare class A3DGltfScene {
    private readonly pipeline;
    constructor(pipeline: ProductionGLTFRenderPipeline);
    get asset(): import("@aura3d/assets").GLTFAsset;
    get resources(): import("@aura3d/assets").GLTFRenderResources;
    get metadata(): ProductionGLTFRenderMetadata;
    createRendererInput(options: A3DGltfRendererInputOptions): {
        readonly source: RenderSource;
        readonly camera: CameraLike;
        readonly bounds: CameraFrameBounds;
    };
    dispose(): void;
}
export declare function loadGltfScene(input: string | A3DGltfSceneOptions): Promise<A3DGltfScene>;
export interface A3DHdrEnvironmentOptions {
    readonly url: string;
    readonly id?: string;
    readonly label?: string;
    readonly data?: ArrayBuffer | Uint8Array;
    readonly intensity?: number;
    readonly backgroundIntensity?: number;
    readonly rotation?: number;
    readonly toneMapping?: {
        readonly operator?: ProductionToneMappingOperator;
        readonly exposure?: number;
        readonly whitePoint?: number;
    };
}
export declare class A3DHdrEnvironment {
    readonly id: string;
    readonly label: string;
    readonly url: string;
    readonly pipeline: ProductionPbrHdrPipeline;
    readonly lighting: ProductionEnvironmentLightingResources;
    constructor(options: {
        readonly id: string;
        readonly label: string;
        readonly url: string;
        readonly pipeline: ProductionPbrHdrPipeline;
        readonly lighting: ProductionEnvironmentLightingResources;
    });
    get environmentLighting(): EnvironmentLightingOptions;
    dispose(): void;
}
export declare function loadHdrEnvironment(input: string | A3DHdrEnvironmentOptions): Promise<A3DHdrEnvironment>;
export interface A3DOrbitControlsOptions {
    readonly enabled?: boolean;
    readonly enablePan?: boolean;
    readonly enableZoom?: boolean;
    readonly enableRotate?: boolean;
    readonly target?: readonly [number, number, number];
    readonly position?: readonly [number, number, number];
}
export interface A3DOrbitControlsSnapshot {
    readonly target: readonly [number, number, number];
    readonly position: readonly [number, number, number];
    readonly rotation: readonly [number, number];
    readonly zoom: number;
    readonly enabled: boolean;
}
export interface A3DOrbitControls {
    rotate(deltaX: number, deltaY: number): A3DOrbitControlsSnapshot;
    pan(deltaX: number, deltaY: number): A3DOrbitControlsSnapshot;
    dolly(scale: number): A3DOrbitControlsSnapshot;
    reset(): A3DOrbitControlsSnapshot;
    snapshot(): A3DOrbitControlsSnapshot;
}
export declare function createOrbitControls(options?: A3DOrbitControlsOptions): A3DOrbitControls;
export interface A3DNavigationControlsOptions {
    readonly enabled?: boolean;
    readonly locked?: boolean;
    readonly position?: readonly [number, number, number];
    readonly rotation?: readonly [number, number, number];
    readonly movementSpeed?: number;
}
export interface A3DNavigationControlsSnapshot {
    readonly position: readonly [number, number, number];
    readonly rotation: readonly [number, number, number];
    readonly movementSpeed: number;
    readonly enabled: boolean;
    readonly locked: boolean;
}
export interface A3DFirstPersonControls {
    moveForward(distance: number): A3DNavigationControlsSnapshot;
    strafe(distance: number): A3DNavigationControlsSnapshot;
    look(deltaX: number, deltaY: number): A3DNavigationControlsSnapshot;
    reset(): A3DNavigationControlsSnapshot;
    snapshot(): A3DNavigationControlsSnapshot;
}
export interface A3DMapControls extends A3DOrbitControls {
    truck(deltaX: number, deltaZ: number): A3DOrbitControlsSnapshot;
}
export interface A3DTrackballControls extends A3DOrbitControls {
    roll(delta: number): A3DOrbitControlsSnapshot;
}
export interface A3DPointerLockControls {
    lock(): A3DNavigationControlsSnapshot;
    unlock(): A3DNavigationControlsSnapshot;
    look(deltaX: number, deltaY: number): A3DNavigationControlsSnapshot;
    reset(): A3DNavigationControlsSnapshot;
    snapshot(): A3DNavigationControlsSnapshot;
}
export declare function createFirstPersonControls(options?: A3DNavigationControlsOptions): A3DFirstPersonControls;
export declare function createMapControls(options?: A3DOrbitControlsOptions): A3DMapControls;
export declare function createTrackballControls(options?: A3DOrbitControlsOptions): A3DTrackballControls;
export declare function createPointerLockControls(options?: A3DNavigationControlsOptions): A3DPointerLockControls;
export interface A3DProductViewerOptions {
    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
    readonly asset: A3DGltfScene;
    readonly environment: A3DHdrEnvironment;
    readonly backend?: "webgl2" | "webgpu";
    readonly width?: number;
    readonly height?: number;
    readonly camera?: {
        readonly preset?: "product-hero" | "asset-inspection" | "material-inspection";
        readonly orbit?: boolean;
    };
    readonly lighting?: {
        readonly ibl?: boolean;
        readonly shadows?: boolean;
    };
    readonly postprocess?: {
        readonly toneMapping?: "aces" | "filmic" | "linear" | "reinhard";
        readonly exposure?: number;
        readonly bloom?: boolean;
        readonly ssao?: boolean;
        readonly fxaa?: boolean;
        readonly colorGrade?: boolean;
    };
}
export interface A3DProductViewerSettings {
    readonly exposure: number;
    readonly iblIntensity: number;
    readonly specularIntensity: number;
    readonly environmentRotation: number;
    readonly backgroundVisible: boolean;
    readonly backgroundBlur: number;
    readonly shadows: boolean;
    readonly toneMapping: "aces" | "filmic" | "linear" | "reinhard";
    readonly bloom: boolean;
    readonly ssao: boolean;
    readonly fxaa: boolean;
    readonly colorGrade: boolean;
}
export interface A3DProductViewerCameraDiagnostics {
    readonly preset: "product-hero" | "asset-inspection" | "material-inspection";
    readonly yawRadians: number;
    readonly pitchRadians: number;
    readonly paddingRatio: number;
    readonly cameraPosition: readonly [number, number, number];
    readonly targetOffset: readonly [number, number, number];
    readonly zoom: number;
}
export interface A3DProductViewerStageDiagnostics {
    readonly enabled: boolean;
    readonly itemCount: number;
    readonly floorY: number;
    readonly directionalShadowMap: boolean;
    readonly softFiltering: "pcf-16" | "off";
    readonly depthAwareAmbientOcclusion: boolean;
    readonly contactShadow: ContactShadowPassDiagnostics;
}
export interface A3DProductViewerBackgroundDiagnostics {
    readonly enabled: boolean;
    readonly itemCount: number;
    readonly mode: "visible-hdr-studio-skybox";
    readonly blur: number;
    readonly environmentRotation: number;
}
export interface A3DProductViewer {
    readonly renderer: A3DRenderer;
    readonly asset: A3DGltfScene;
    readonly environment: A3DHdrEnvironment;
    readonly controls: A3DOrbitControls;
    render(): A3DRenderResult;
    renderAsync(): Promise<A3DRenderResult>;
    setSettings(settings: Partial<A3DProductViewerSettings>): A3DProductViewerSettings;
    setEnvironment(environment: A3DHdrEnvironment): A3DHdrEnvironment;
    getSettings(): A3DProductViewerSettings;
    captureScreenshot(type?: "image/png" | "image/jpeg", quality?: number): string | undefined;
    diagnostics(): {
        readonly asset: ProductionGLTFRenderMetadata;
        readonly environment: {
            readonly id: string;
            readonly url: string;
            readonly realRadianceHdr: boolean;
            readonly specularPrefilter: boolean;
            readonly cubemapPMREM: boolean;
            readonly cubemapPMREMShaderSampling: "webgl2-sampler-cube";
            readonly cubemapFaceSize: number;
            readonly cubemapMipCount: number;
            readonly brdfLut: boolean;
        };
        readonly controls: A3DOrbitControlsSnapshot;
        readonly settings: A3DProductViewerSettings;
        readonly camera?: A3DProductViewerCameraDiagnostics;
        readonly stage: A3DProductViewerStageDiagnostics;
        readonly background: A3DProductViewerBackgroundDiagnostics;
    };
    dispose(): void;
}
export declare function createProductViewer(options: A3DProductViewerOptions): Promise<A3DProductViewer>;
//# sourceMappingURL=index.d.ts.map