import { type AsyncWritable } from '../utilities/asyncWritable.js';
type AsyncLoader = {
    loadAsync: (url: string, onProgress?: (event: ProgressEvent) => void) => Promise<any>;
};
type SyncLoader = {
    load: (url: string, onLoad: (data: any) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: unknown) => void) => unknown;
};
export type Loader = AsyncLoader | SyncLoader;
type LoaderProtoWithoutArgs = {
    new (): Loader;
};
type LoaderProtoWithArgs = {
    new (...args: any[]): Loader;
};
export type UseLoaderLoadInput = string | string[] | Record<string, string>;
type LoaderResultType<TLoader extends Loader> = TLoader extends AsyncLoader ? Awaited<ReturnType<TLoader['loadAsync']>> : TLoader extends SyncLoader ? Parameters<TLoader['load']>[1] extends (data: infer Result) => void ? Result : never : never;
export type UseLoaderLoadResult<TLoader extends Loader, Input extends UseLoaderLoadInput, ResultType = LoaderResultType<TLoader>> = Input extends string ? AsyncWritable<ResultType> : Input extends string[] ? AsyncWritable<ResultType[]> : AsyncWritable<Record<keyof Input, ResultType>>;
type UseLoaderLoadTransform<TLoader extends Loader> = (result: LoaderResultType<TLoader>) => any;
export type UseLoaderLoadOptions<TLoader extends Loader> = {
    onProgress?: (event: ProgressEvent) => void;
    transform?: UseLoaderLoadTransform<TLoader>;
};
type ThrelteUseLoader<TLoader extends Loader> = {
    loader: TLoader;
    load: <Input extends UseLoaderLoadInput, Options extends UseLoaderLoadOptions<TLoader> | undefined, ResultType = Options extends UseLoaderLoadOptions<TLoader> ? Options['transform'] extends UseLoaderLoadTransform<TLoader> ? ReturnType<Options['transform']> : LoaderResultType<TLoader> : LoaderResultType<TLoader>>(input: Input, options?: Options) => UseLoaderLoadResult<TLoader, Input, ResultType>;
    clear: <Input extends string | string[] | Record<string, string>>(input: Input) => void;
};
type UseLoaderOptionsWithoutArgs<Proto extends LoaderProtoWithoutArgs> = {
    /**
     * A loader can be extended to add custom
     * functionality, e.g. add DRACO support.
     */
    extend?: (loader: InstanceType<Proto>) => void;
    /**
     * Arguments to pass to the loader.
     */
    args?: ConstructorParameters<Proto>;
};
type UseLoaderOptionsWithArgs<Proto extends LoaderProtoWithArgs> = {
    /**
     * A loader can be extended to add custom
     * functionality, e.g. add DRACO support.
     */
    extend?: (loader: InstanceType<Proto>) => void;
    /**
     * Arguments to pass to the loader.
     */
    args: ConstructorParameters<Proto>;
};
export type UseLoaderOptions<Proto extends LoaderProtoWithoutArgs> = ConstructorParameters<Proto> extends [] ? UseLoaderOptionsWithoutArgs<Proto> : undefined extends ConstructorParameters<Proto>[0] ? UseLoaderOptionsWithoutArgs<Proto> : UseLoaderOptionsWithArgs<Proto>;
export declare function useLoader<Proto extends LoaderProtoWithoutArgs>(Proto: Proto, options?: UseLoaderOptions<Proto>): ThrelteUseLoader<InstanceType<Proto>>;
export declare function useLoader<Proto extends LoaderProtoWithArgs>(Proto: Proto, options: UseLoaderOptions<Proto>): ThrelteUseLoader<InstanceType<Proto>>;
export {};