/**
 * Worker-safe Three.js adapters for the public AssetManager.
 *
 * All Three.js and addon implementations are loaded lazily. Importing this module and
 * creating the adapter runtime performs no DOM access, codec setup, or network work.
 */
import type { ColorSpace, CubeTexture, DataTexture, Texture } from 'three';
import type { GLTF } from 'three/addons/loaders/GLTFLoader.js';
import type { ThreeBlocksCodecRuntimeConfig, ThreeBlocksMeshoptDecoder } from '../vite/types.js';
import { type AssetLoaderRegistry } from './registry.js';
import type { AbortSignalLike, StandardAssetAdapters } from './types.js';
export type ThreeAssetAdapterErrorCode = 'aborted' | 'decode-failed' | 'fetch-failed' | 'invalid-data' | 'missing-codec' | 'runtime-unavailable' | 'unsupported-configuration';
export declare class ThreeAssetAdapterError extends Error {
    readonly code: ThreeAssetAdapterErrorCode;
    readonly url: string | undefined;
    readonly causeValue: unknown;
    constructor(options: {
        readonly code: ThreeAssetAdapterErrorCode;
        readonly message: string;
        readonly url?: string;
        readonly cause?: unknown;
    });
}
export interface ThreeAssetFetchHeaders {
    get(name: string): string | null;
}
export interface ThreeAssetStreamReader {
    read(): PromiseLike<{
        readonly done: boolean;
        readonly value?: Uint8Array;
    }>;
    cancel?(reason?: unknown): PromiseLike<unknown> | unknown;
    releaseLock?(): void;
}
export interface ThreeAssetReadableBody {
    getReader(): ThreeAssetStreamReader;
}
export interface ThreeAssetFetchResponse {
    readonly ok: boolean;
    readonly status: number;
    readonly statusText?: string;
    readonly headers?: ThreeAssetFetchHeaders;
    readonly body?: ThreeAssetReadableBody | null;
    arrayBuffer(): PromiseLike<ArrayBuffer>;
}
export type ThreeAssetFetch = (url: string, init: {
    readonly signal?: unknown;
}) => PromiseLike<ThreeAssetFetchResponse>;
/** Minimal transferable image shape. Browser ImageBitmap satisfies this contract. */
export interface ThreeAssetBitmap {
    readonly width?: number;
    readonly height?: number;
    close?(): void;
}
export type ThreeAssetImageDecoder = (bytes: Uint8Array, options: {
    readonly mimeType: string;
    readonly url: string;
    readonly signal: AbortSignalLike;
}) => PromiseLike<ThreeAssetBitmap>;
export interface ThreeAssetThreeModule {
    readonly Texture: new (image?: unknown) => Texture;
    readonly CubeTexture: new (images?: readonly unknown[]) => CubeTexture;
    readonly SRGBColorSpace: ColorSpace;
}
export interface ThreeAssetGltfPlugin {
    readonly name: string;
    afterRoot?(result: GLTF): PromiseLike<void> | void | null;
}
export interface ThreeAssetGltfLoader {
    setDRACOLoader(loader: ThreeAssetDracoLoader | null): this;
    setKTX2Loader(loader: ThreeAssetKtx2Loader | null): this;
    setMeshoptDecoder(decoder: ThreeBlocksMeshoptDecoder | null): this;
    register(factory: (parser: unknown) => ThreeAssetGltfPlugin): this;
    parseAsync(data: ArrayBuffer | string, path: string): PromiseLike<GLTF>;
}
export interface ThreeAssetDracoLoader {
    setDecoderPath(path: string): this;
    dispose(): unknown;
}
export interface ThreeAssetKtx2Loader {
    setTranscoderPath(path: string): this;
    detectSupport(renderer: unknown): this | PromiseLike<this>;
    parse(buffer: ArrayBuffer, onLoad: (texture: Texture) => void, onError: (error: unknown) => void): void;
    dispose(): unknown;
}
export interface ThreeAssetDataTextureLoader {
    createDataTexture(buffer: ArrayBuffer): DataTexture;
}
export type ThreeAssetCurvePluginFactory = (parser: unknown, extensionName: string) => ThreeAssetGltfPlugin;
export interface ThreeAssetLoaderFactories {
    readonly gltf?: () => ThreeAssetGltfLoader | PromiseLike<ThreeAssetGltfLoader>;
    readonly draco?: () => ThreeAssetDracoLoader | PromiseLike<ThreeAssetDracoLoader>;
    readonly ktx2?: () => ThreeAssetKtx2Loader | PromiseLike<ThreeAssetKtx2Loader>;
    readonly hdr?: () => ThreeAssetDataTextureLoader | PromiseLike<ThreeAssetDataTextureLoader>;
    readonly exr?: () => ThreeAssetDataTextureLoader | PromiseLike<ThreeAssetDataTextureLoader>;
}
export interface CreateThreeAssetAdaptersOptions {
    /** Initialized WebGPU or worker-owned WebGL renderer used for KTX2 capability detection. */
    readonly renderer: unknown;
    /** Pass `threeBlocksConfig.codecs` from `three-blocks/vite/config`. */
    readonly codecs: ThreeBlocksCodecRuntimeConfig;
    readonly fetch?: ThreeAssetFetch;
    /** Decodes encoded image bytes to an ImageBitmap-compatible object. */
    readonly decodeImage?: ThreeAssetImageDecoder;
    /** Override the default lazy `three` module import. */
    readonly loadThree?: () => ThreeAssetThreeModule | PromiseLike<ThreeAssetThreeModule>;
    /** Pass `loadThreeBlocksMeshoptDecoder` or another compatible lazy resolver. */
    readonly loadMeshopt?: () => ThreeBlocksMeshoptDecoder | PromiseLike<ThreeBlocksMeshoptDecoder>;
    readonly createCurvePlugin?: ThreeAssetCurvePluginFactory | PromiseLike<ThreeAssetCurvePluginFactory>;
    readonly loaders?: ThreeAssetLoaderFactories;
}
export interface ThreeStandardAssetResultMap {
    readonly gltf: GLTF;
    readonly glb: GLTF;
    readonly hdr: DataTexture;
    readonly exr: DataTexture;
    readonly image: Texture;
    readonly texture: Texture;
    readonly ktx2: Texture;
    readonly json: unknown;
    readonly binary: ArrayBuffer;
    readonly cubeTexture: CubeTexture;
    readonly audio: ArrayBuffer;
    readonly font: ArrayBuffer;
}
export type ThreeStandardAssetAdapters = StandardAssetAdapters<ThreeStandardAssetResultMap>;
export type ThreeAssetLoaderRegistry = AssetLoaderRegistry<ThreeStandardAssetAdapters>;
export interface ThreeAssetAdapterRuntime {
    readonly adapters: ThreeStandardAssetAdapters;
    readonly registry: ThreeAssetLoaderRegistry;
    readonly disposed: boolean;
    /** Dispose shared Draco/KTX2 worker pools after AssetManager shutdown completes. */
    dispose(): Promise<void>;
}
/** Create the complete standard worker adapter runtime and its typed registry. */
export declare function createThreeAssetAdapters(options: CreateThreeAssetAdaptersOptions): ThreeAssetAdapterRuntime;