import { ModuleType } from './Module';
import { Package } from './Package';
import { Record, DepRef, ModuleFormat } from './Record';
import { FetchResponse } from './fetch';
import { LoaderConfig, SystemDeclaration } from './LoaderBase';
export declare type SystemFactory = (exports?: any, module?: ModuleType) => SystemDeclaration;
export interface BuiltSpec {
    name: string;
    root: string;
    main: string;
    map: {
        [key: string]: string;
    };
    files: [string, ModuleFormat, {
        [importKey: string]: number;
    }, any][];
}
export declare class Loader {
    config?: LoaderConfig | undefined;
    constructor(config?: LoaderConfig | undefined);
    /** @param key Name of module or file to import, may be a relative path.
      * @param parent Resolved URL of a possible parent module. */
    import(importKey: string, parent?: string): Promise<any>;
    getPackage(key: string): Package | undefined;
    resolveSync(key: string, callerKey?: string, ref?: DepRef): string;
    resolve(key: string, callerKey?: string, ref?: DepRef): Promise<string>;
    fetch(url: string): Promise<FetchResponse>;
    fetchRecord(record: Record): Promise<void>;
    /** Resolve and translate an imported dependency and its recursive dependencies.
      *
      * @param importKey Dependency name (module or file), may be a relative path.
      * @param record Import record of module referencing the dependency.
      * @param base Dependency hierarchy root to instantiate and return from
      * original import() call. */
    discoverImport(importKey: string, record: Record, instantiate: boolean, base: Record): Promise<Record | undefined>;
    /** Recursively fetch and translate a file and all its dependencies.
      *
      * @param resolvedKey Resolved URL address to fetch.
      * @param importKey Dependency name before resolving.
      * @param base Dependency hierarchy root to instantiate and return from
      * original import() call. */
    discoverRecursive(resolvedKey: string, importKey: string, ref: DepRef, instantiate: boolean, base?: Record): Promise<Record>;
    discover(record: Record): Promise<void> | void;
    translate(record: Record): Promise<void> | void;
    instantiate(record: Record): any;
    register(deps: string[], factory: SystemFactory): void;
    wrap(record: Record): void;
    build(importKey: string, parent?: string): Promise<string>;
    built(version: number, specList: BuiltSpec[]): void;
    package: Package;
    packageNameTbl: {
        [name: string]: Package | false | Promise<Package | false>;
    };
    packageConfTbl: {
        [resolvedRoot: string]: Package | false | Promise<Package | false>;
    };
    /** Map resolved keys to containing packages (keys not corresponding to a package root
      * resolve to the same result as their parent directory does). */
    packageRootTbl: {
        [resolvedRoot: string]: Package | false | Promise<Package | false>;
    };
    repoTbl: {
        [resolvedPath: string]: true;
    };
    registry: {
        [resolvedKey: string]: ModuleType;
    };
    /** Pending imports. */
    records: {
        [resolvedKey: string]: Record;
    };
    latestRecord?: Record;
    cwd: string;
    baseURL?: string;
    plugins: {
        [name: string]: Loader;
    };
}