/** Shared, renderer-agnostic asset contracts. */
export type AssetDevice = 'desktop' | 'mobile';
export type AssetUrl = string | readonly string[];
export interface AssetSource {
    readonly url: string;
    readonly format?: string;
    readonly bytes?: number;
}
export interface AssetVariant<TUrl extends AssetUrl = AssetUrl, TSource extends AssetSource = AssetSource> {
    readonly url?: TUrl;
    readonly bytes?: number;
    readonly sources?: readonly TSource[];
    readonly disabled?: boolean;
}
export interface AssetVariants<TUrl extends AssetUrl = AssetUrl, TSource extends AssetSource = AssetSource> {
    readonly desktop?: AssetVariant<TUrl, TSource>;
    readonly mobile?: AssetVariant<TUrl, TSource>;
}
export interface AssetRetryContext {
    readonly attempt: number;
    readonly error: unknown;
    readonly definition: AssetDefinition;
}
export interface AssetRetryPolicy {
    /** Retry count after the initial attempt. */
    readonly retries: number;
    readonly delayMs?: number | ((context: AssetRetryContext) => number);
    readonly shouldRetry?: (context: AssetRetryContext) => boolean;
}
export type AssetRetry = number | AssetRetryPolicy;
export interface AssetDefinition<TType extends string = string, TUrl extends AssetUrl = AssetUrl, TSource extends AssetSource = AssetSource> {
    readonly type: TType;
    readonly url?: TUrl;
    readonly bytes?: number;
    readonly required?: boolean;
    readonly persistent?: boolean;
    readonly cacheKey?: string;
    readonly variants?: AssetVariants<TUrl, TSource>;
    readonly retry?: AssetRetry;
    readonly metadata?: Readonly<Record<string, unknown>>;
}
export interface GltfCodecConfiguration {
    readonly draco?: false | {
        readonly decoderPath?: string;
    };
    readonly ktx2?: false | {
        readonly transcoderPath?: string;
    };
    readonly meshopt?: boolean;
    readonly gltfCurve?: boolean | {
        readonly extensionName?: string;
    };
}
export interface GltfAssetDefinition extends AssetDefinition<'gltf', string, never> {
    readonly url: string;
    readonly codecs?: GltfCodecConfiguration;
}
export interface GlbAssetDefinition extends AssetDefinition<'glb', string, never> {
    readonly url: string;
    readonly codecs?: GltfCodecConfiguration;
}
export interface HdrAssetDefinition extends AssetDefinition<'hdr', string, never> {
    readonly url: string;
}
export interface ExrAssetDefinition extends AssetDefinition<'exr', string, never> {
    readonly url: string;
}
export type ImageAssetFormat = 'png' | 'jpeg' | 'webp' | 'avif';
export interface ImageAssetDefinition extends AssetDefinition<'image', string, never> {
    readonly url: string;
    readonly format?: ImageAssetFormat;
    readonly colorSpace?: string;
}
export interface TextureAssetDefinition extends AssetDefinition<'texture', string, never> {
    readonly url: string;
    readonly format?: ImageAssetFormat | 'ktx2';
    readonly colorSpace?: string;
}
export interface Ktx2AssetDefinition extends AssetDefinition<'ktx2', string, never> {
    readonly url: string;
    readonly transcoderPath?: string;
}
export interface JsonAssetDefinition extends AssetDefinition<'json', string, never> {
    readonly url: string;
}
export interface BinaryAssetDefinition extends AssetDefinition<'binary', string, never> {
    readonly url: string;
}
export interface CubeTextureAssetDefinition extends AssetDefinition<'cubeTexture', readonly [string, string, string, string, string, string], never> {
    readonly url: readonly [string, string, string, string, string, string];
    readonly colorSpace?: string;
}
export interface AudioAssetDefinition extends AssetDefinition<'audio', string, AssetSource> {
    readonly url?: string;
    readonly sources?: readonly AssetSource[];
    readonly preferredFormats?: readonly string[];
    /** Set by AssetManager after supported-format fallback selection. */
    readonly selectedFormat?: string;
}
export interface FontAssetDefinition extends AssetDefinition<'font', string, never> {
    readonly url: string;
    readonly family?: string;
}
export type StandardAssetDefinition = GltfAssetDefinition | GlbAssetDefinition | HdrAssetDefinition | ExrAssetDefinition | ImageAssetDefinition | TextureAssetDefinition | Ktx2AssetDefinition | JsonAssetDefinition | BinaryAssetDefinition | CubeTextureAssetDefinition | AudioAssetDefinition | FontAssetDefinition;
/** The standard vocabulary; concrete renderer/decoder adapters remain explicit dependencies. */
export interface StandardAssetDefinitionMap {
    readonly gltf: GltfAssetDefinition;
    readonly glb: GlbAssetDefinition;
    readonly hdr: HdrAssetDefinition;
    readonly exr: ExrAssetDefinition;
    readonly image: ImageAssetDefinition;
    readonly texture: TextureAssetDefinition;
    readonly ktx2: Ktx2AssetDefinition;
    readonly json: JsonAssetDefinition;
    readonly binary: BinaryAssetDefinition;
    readonly cubeTexture: CubeTextureAssetDefinition;
    readonly audio: AudioAssetDefinition;
    readonly font: FontAssetDefinition;
}
export type StandardAssetResultMap = {
    readonly [TType in keyof StandardAssetDefinitionMap]: unknown;
};
export type StandardAssetAdapters<TResultMap extends StandardAssetResultMap> = {
    readonly [TType in keyof StandardAssetDefinitionMap]: AssetAdapter<StandardAssetDefinitionMap[TType], TResultMap[TType]>;
};
export interface AbortSignalLike {
    readonly aborted: boolean;
    readonly reason?: unknown;
    addEventListener(type: 'abort', listener: () => void, options?: {
        readonly once?: boolean;
    }): void;
    removeEventListener(type: 'abort', listener: () => void): void;
}
export interface AssetLoadContext {
    readonly signal: AbortSignalLike;
    readonly attempt: number;
    readonly reportProgress: (progress: number) => void;
}
export interface AssetDisposeContext {
    readonly reason: 'zero-references' | 'evicted' | 'shutdown';
}
export interface AssetAdapterCapabilities {
    readonly formats?: readonly string[];
    readonly codecs?: {
        readonly draco?: boolean;
        readonly ktx2?: boolean;
        readonly meshopt?: boolean;
        readonly gltfCurve?: boolean;
    };
    readonly workerSafe?: boolean;
    readonly notes?: string;
}
export interface AssetAdapter<TDefinition extends AssetDefinition = AssetDefinition, TResult = unknown> {
    readonly type: TDefinition['type'];
    readonly capabilities?: AssetAdapterCapabilities;
    load(definition: TDefinition, context: AssetLoadContext): TResult | PromiseLike<TResult>;
    dispose?(value: TResult, context: AssetDisposeContext): void | PromiseLike<void>;
}
export type AssetAdapterDefinition<TAdapter> = TAdapter extends AssetAdapter<infer TDefinition, infer _TResult> ? TDefinition : never;
export type AssetAdapterResult<TAdapter> = TAdapter extends AssetAdapter<infer _TDefinition, infer TResult> ? TResult : never;
export type AssetAdapterRecord = Readonly<Record<string, AssetAdapter<AssetDefinition, unknown>>>;
export type AssetDefinitionForAdapters<TAdapters extends object> = {
    [TKey in keyof TAdapters]: AssetAdapterDefinition<TAdapters[TKey]>;
}[keyof TAdapters];
export type AssetManifestForAdapters<TAdapters extends object> = Readonly<Record<string, AssetDefinitionForAdapters<TAdapters>>>;
type AdapterForDefinition<TDefinition, TAdapters extends object> = TDefinition extends {
    readonly type: infer TType;
} ? TType extends keyof TAdapters ? TAdapters[TType] : never : never;
export type AssetValueForDefinition<TDefinition, TAdapters extends object> = AssetAdapterResult<AdapterForDefinition<TDefinition, TAdapters>>;
type AssetRequiredFlag<TDefinition> = 'required' extends keyof TDefinition ? TDefinition[Extract<'required', keyof TDefinition>] : true;
export type AssetResultForDefinition<TDefinition, TAdapters extends object> = false extends AssetRequiredFlag<TDefinition> ? AssetValueForDefinition<TDefinition, TAdapters> | undefined : AssetValueForDefinition<TDefinition, TAdapters>;
export type AssetResults<TManifest extends object, TAdapters extends object> = {
    -readonly [TName in keyof TManifest]: AssetResultForDefinition<TManifest[TName], TAdapters>;
};
export type NamedAssetPromises<TResult extends object> = {
    readonly [TName in keyof TResult]: Promise<TResult[TName]>;
};
export type NamedAssetHandles<TResult extends object> = {
    readonly [TName in keyof TResult]: AssetHandle<TResult[TName]>;
};
export interface AssetProgress {
    readonly progress: number;
    readonly loadedWeight: number;
    readonly totalWeight: number;
    readonly asset?: string;
}
export interface AssetLoadOptions {
    readonly signal?: AbortSignalLike;
    readonly onProgress?: (progress: AssetProgress) => void;
}
export type AssetLoadErrorCode = 'aborted' | 'adapter-error' | 'filtered-optional' | 'filtered-required' | 'invalid-definition' | 'manager-disposed' | 'missing-adapter' | 'no-audio-source';
export declare class AssetLoadError extends Error {
    readonly code: AssetLoadErrorCode;
    readonly assetName: string;
    readonly assetType: string;
    readonly attempts: number;
    readonly causeValue: unknown;
    constructor(options: {
        readonly code: AssetLoadErrorCode;
        readonly assetName: string;
        readonly assetType: string;
        readonly message: string;
        readonly attempts?: number;
        readonly cause?: unknown;
    });
}
export interface AssetFailure {
    readonly assetName: string;
    readonly assetType: string;
    readonly required: boolean;
    readonly error: AssetLoadError;
}
export declare class AssetAggregateError extends Error {
    readonly failures: readonly AssetFailure[];
    readonly optionalFailures: readonly AssetFailure[];
    constructor(failures: readonly AssetFailure[], optionalFailures?: readonly AssetFailure[]);
}
export interface AssetManifestDiff {
    readonly added: readonly string[];
    readonly removed: readonly string[];
    readonly changed: readonly string[];
    readonly unchanged: readonly string[];
}
export interface AssetCacheEntrySnapshot {
    readonly key: string;
    readonly type: string;
    readonly status: 'queued' | 'loading' | 'ready';
    readonly references: number;
    readonly persistent: boolean;
    readonly progress: number;
}
export declare class AssetHandle<TValue> {
    #private;
    readonly name: string;
    readonly promise: Promise<TValue>;
    constructor(name: string, promise: Promise<TValue>, release: () => void);
    get released(): boolean;
    release(): void;
}
export {};