import { Resolver, Resolution } from './Resolver';
import { VersionRanges } from './VersionRanges';
import { Fetcher } from './Fetcher';
export declare function createPolestar(options?: PolestarOptions): Polestar;
export interface PolestarOptions {
    fetcher?: Fetcher;
    resolver?: Resolver;
    /**
     * Each key in this object will be injected as a global in the module, allowing
     * you to supply overrides for `window`, `history`, `global`, etc.
     */
    globals?: object;
    /**
     * The object that will be available under `this` within the module.
     */
    moduleThis?: any;
    /**
     * If supplied, this will be called when the first entry point module
     * is executed.
     */
    onEntry?: () => void;
    /**
     * Will be called with each unique error that is encountered. Once this has
     * been called, any in-progress loads will be halted.
     */
    onError?: (error: any) => void;
}
export declare class Polestar {
    private loads;
    private resolver;
    private error?;
    private errorDetail?;
    private hasCalledOnEntry;
    private nextEntryId;
    options: PolestarOptions;
    moduleWrappers: {
        [id: string]: ModuleWrapper;
    };
    constructor(options: PolestarOptions);
    evaluate(dependencies: string[], code: string, dependencyVersionRanges?: VersionRanges, id?: string): Promise<Module>;
    require(request: string): Promise<Module>;
    resolve(request: string, parentId?: string, defaultPackageVersionRanges?: VersionRanges): Resolution;
    loadWrapper(url: string, requiredBy?: ModuleWrapper, originalRequest?: string): Promise<ModuleWrapper>;
    unload(id: string): Promise<void>;
    clearError(): Promise<void>;
    private handleFetchResult;
    /**
     * Preload modules and cache before evaluate.
     * @param id id you want to preload, ex. 'npm://react'
     * @param preloadedModule preloaded module, ex. React
     * @param css css code
     */
    preloadModule(id: string, preloadedModule: any, css?: string): Promise<ModuleWrapper>;
    private prepareModuleWrapper;
    private handleUnrequiredPrepared;
    private setError;
}
export interface RequireFunction {
    (request: string): any;
    resolve: (url: string) => string;
}
export declare type ModuleFunction = (require: RequireFunction, module: Module, exports: any) => any;
export interface Module {
    exports: any;
    id: string;
    loaded: boolean;
    require: RequireFunction;
}
export declare class ModuleWrapper {
    module: Module;
    dependencyVersionRanges: VersionRanges;
    polestar: Polestar;
    fn: ModuleFunction;
    isPrepared: boolean;
    preparedPromise: Promise<ModuleWrapper>;
    rejectPrepared: (error: any) => void;
    resolvePrepared: (moduleWrapper: ModuleWrapper) => void;
    requiredBy: Set<ModuleWrapper>;
    waitingFor: string[];
    dynamicImports: Map<string, Promise<ModuleWrapper>>;
    constructor(loader: Polestar, id: string, dependencyVersionRanges: {
        [name: string]: string;
    }, fn: ModuleFunction);
    execute(): void;
    prepare(dependencyRequests?: string[], requiredByWrappers?: ModuleWrapper[]): Promise<ModuleWrapper>;
    addToRequiredBy(requiredByWrappers: ModuleWrapper[]): void;
    private stopWaitingFor;
    private addRequiredBy;
}