import { Loader } from 'three';
import type { DataTexture, LoadingManager } from 'three';
import { EXRLoader } from 'three/addons/loaders/EXRLoader.js';
import { AnimationBakeMixer } from './AnimationBakeMixer.cjs';
import type { AnimationBakeMetadata } from './AnimationBakeMixer.cjs';
/** Single or packed mixer result returned by an animation-bake load. */
export type AnimationBakeLoadResult = AnimationBakeMixer | AnimationBakeMixer[];
/** Single or packed normalized metadata paired with an animation-bake result. */
export type AnimationBakeMetadataResult = AnimationBakeMetadata | AnimationBakeMetadata[];
/** Synthetic progress emitted as metadata and texture entries complete. */
export interface AnimationBakeStepProgress {
    loaded: number;
    total: number;
    ratio: number;
}
/** Progress emitted by metadata steps or the underlying EXR request. */
export type AnimationBakeProgressEvent = ProgressEvent<EventTarget> | AnimationBakeStepProgress;
/** Success callback used by {@link AnimationBakeLoader.load}. */
export type AnimationBakeLoadCallback = (result: AnimationBakeLoadResult, metadata: AnimationBakeMetadataResult) => void;
/** Progress callback used by animation-bake loading. */
export type AnimationBakeProgressCallback = (event: AnimationBakeProgressEvent) => void;
/** Error callback used by animation-bake loading. */
export type AnimationBakeErrorCallback = (error: Error) => void;
/** Compact metadata shape containing a shared header and per-texture groups. */
export interface AnimationBakeCompactMetadata {
    header?: AnimationBakeMetadata;
    groups: AnimationBakeMetadata[];
}
interface AnimationBakeResolvedUrls {
    exrUrl: string;
    jsonUrl: string;
}
interface AnimationBakeTextureLoadContext {
    resolvedExrUrl: string;
    jsonBase: string;
    entryIndex: number;
    totalEntries: number;
    stepIndex: number;
    totalSteps: number;
    reportStep: (step: number) => void;
    onProgress: AnimationBakeProgressCallback | undefined;
    textureCache: Map<string, Promise<DataTexture>>;
}
type AnimationBakeMetadataRecord = Record<string, unknown>;
/**
 * Loader for baked animation textures (VAT/OAT). Given a base URL (or a URL ending with .exr or .json),
 * it loads the EXR texture and its paired JSON metadata, then constructs and returns an initialized
 * AnimationBakeMixer.
 *
 * URL resolution rules:
 * - If the URL ends with .exr, the JSON URL is derived by replacing with .json.
 * - If the URL ends with .json, the EXR URL is derived by replacing with .exr.
 * - Otherwise, "<url>.exr" and "<url>.json" are used.
 *
 * This implementation-level API is intentionally internal and has no public package import.
 *
 * @class AnimationBakeLoader
 * @short Loader that fetches EXR + JSON baked animation data and returns an initialized AnimationBakeMixer.
 * @category Animation
 * @extends Loader
 * @tags WebGPU, WebGL
 * @see AnimationBakeMixer
 */
export declare class AnimationBakeLoader extends Loader<AnimationBakeLoadResult> {
    /**
     * @param {THREE.LoadingManager} [manager]
     */
    constructor(manager?: LoadingManager);
    /**
     * Load an EXR and its paired JSON metadata and return an initialized AnimationBakeMixer.
     *
     * @param {string} url - Base URL or .exr/.json URL.
     * @param {AnimationBakeLoadCallback} [onLoad] - Callback fired after the EXR and metadata are loaded.
     * @param {AnimationBakeProgressCallback} [onProgress] - Progress callback invoked with loader events.
     * @param {AnimationBakeErrorCallback} [onError] - Error callback invoked when load fails.
     */
    load(url: string, onLoad?: AnimationBakeLoadCallback, onProgress?: AnimationBakeProgressCallback, onError?: AnimationBakeErrorCallback): void;
    load(url: string, onLoad: (data: AnimationBakeLoadResult) => void, onProgress?: (event: ProgressEvent<EventTarget>) => void, onError?: (error: unknown) => void): void;
    _resolveBaseUrls(url: string): AnimationBakeResolvedUrls;
    _resolveUrlWithManager(target: string): string;
    _normalizeMetaEntry(entry: unknown): AnimationBakeMetadata;
    _expandCompactMeta(compact: AnimationBakeMetadataRecord): AnimationBakeMetadata[];
    _resolveTextureReference(entry: AnimationBakeMetadata, resolvedExrUrl: string, jsonBase: string, entryIndex: number, totalEntries: number): string;
    _loadTextureForEntry(loader: EXRLoader, entry: AnimationBakeMetadata, { resolvedExrUrl, jsonBase, entryIndex, totalEntries, stepIndex, totalSteps, reportStep, onProgress, textureCache }: AnimationBakeTextureLoadContext): Promise<DataTexture>;
    /**
     * Promise-based variant of load.
     * @param {string} url
     * @param {AnimationBakeProgressCallback} [onProgress] - Optional progress callback invoked with loader events.
     * @return {Promise<AnimationBakeLoadResult>} Promise that resolves with one mixer or a packed mixer list.
     */
    loadAsync(url: string, onProgress?: AnimationBakeProgressCallback): Promise<AnimationBakeLoadResult>;
    loadAsync(url: string, onProgress?: (event: ProgressEvent<EventTarget>) => void): Promise<AnimationBakeLoadResult>;
}
export {};