import { AssetLoaderRegistry } from './registry.cjs';
import { AssetHandle, type AbortSignalLike, type AssetCacheEntrySnapshot, type AssetDefinition, type AssetFailure, type AssetLoadOptions, type AssetManifestDiff, type AssetManifestForAdapters, type AssetProgress, type AssetResults, type AssetRetry, type NamedAssetHandles, type NamedAssetPromises } from './types.cjs';
export type AssetSleep = (milliseconds: number, signal: AbortSignalLike) => Promise<void>;
export interface AssetManagerOptions {
    readonly concurrency?: number;
    readonly retry?: AssetRetry;
    readonly device?: 'desktop' | 'mobile';
    readonly includeFonts?: boolean;
    readonly supportedAudioFormats?: readonly string[];
    readonly defaultWeight?: number;
    readonly sleep?: AssetSleep;
    readonly onDisposeError?: (error: unknown) => void;
}
interface InternalLoadRecord {
    readonly name: string;
    readonly type: string;
    readonly required: boolean;
    readonly handle: AssetHandle<unknown>;
}
declare class ProgressTracker {
    #private;
    readonly totalWeight: number;
    constructor(definitions: Readonly<Record<string, AssetDefinition>>, defaultWeight: number, onProgress: ((progress: AssetProgress) => void) | undefined);
    get current(): number;
    update(name: string, progress: number): void;
}
export declare class AssetLoad<TResult extends object> implements PromiseLike<TResult> {
    #private;
    readonly named: NamedAssetPromises<TResult>;
    readonly handles: NamedAssetHandles<TResult>;
    readonly result: Promise<TResult>;
    constructor(records: readonly InternalLoadRecord[], progress: ProgressTracker);
    get progress(): number;
    get optionalFailures(): readonly AssetFailure[];
    get released(): boolean;
    release(): void;
    then<TResult1 = TResult, TResult2 = never>(onfulfilled?: ((value: TResult) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
}
/** A direct-await ownership object that keeps the underlying reference handles reachable. */
export declare class AssetLease<TResult extends object> {
    readonly assets: TResult;
    readonly request: AssetLoad<TResult>;
    constructor(assets: TResult, request: AssetLoad<TResult>);
    get released(): boolean;
    release(): void;
}
/**
 * Scene-lifetime facade used as `context.assets`. It preserves the ergonomic direct-await
 * API while retaining every request until the owning scene is disposed.
 */
export declare class AssetScope<TAdapters extends object> {
    #private;
    constructor(manager: AssetManager<TAdapters>);
    get disposed(): boolean;
    get activeLoads(): number;
    load<const TManifest extends AssetManifestForAdapters<TAdapters>>(manifest: TManifest, options?: AssetLoadOptions): Promise<AssetResults<TManifest, TAdapters>>;
    dispose(): void;
}
export declare class AssetManager<TAdapters extends object> {
    #private;
    readonly registry: AssetLoaderRegistry<TAdapters>;
    constructor(registry: AssetLoaderRegistry<TAdapters>, options?: AssetManagerOptions);
    get disposed(): boolean;
    /** Create one ownership scope per scene or other hot-replaceable lifetime. */
    createScope(): AssetScope<TAdapters>;
    /** Keep the returned request and call release(); use lease() for an explicit direct-await owner. */
    load<const TManifest extends AssetManifestForAdapters<TAdapters>>(manifest: TManifest, options?: AssetLoadOptions): AssetLoad<AssetResults<TManifest, TAdapters>>;
    lease<const TManifest extends AssetManifestForAdapters<TAdapters>>(manifest: TManifest, options?: AssetLoadOptions): Promise<AssetLease<AssetResults<TManifest, TAdapters>>>;
    replace<const TManifest extends AssetManifestForAdapters<TAdapters>>(current: AssetLoad<object>, manifest: TManifest, options?: AssetLoadOptions): AssetLoad<AssetResults<TManifest, TAdapters>>;
    diff(previous: Readonly<Record<string, AssetDefinition>>, next: Readonly<Record<string, AssetDefinition>>): AssetManifestDiff;
    cacheSnapshot(): readonly AssetCacheEntrySnapshot[];
    evict(key: string): boolean;
    shutdown(): Promise<void>;
}
export declare function createAssetManager<TAdapters extends object>(registry: AssetLoaderRegistry<TAdapters>, options?: AssetManagerOptions): AssetManager<TAdapters>;
export {};