/// <reference types="node" />
import { AcceptedPlugin, Processor } from 'postcss';
import Packet, { PacketMeta } from './packet';
import Module from './module';
import Bundle, { CompileOptions } from './bundle';
import Cache from './cache';
import { MinifyOptions } from 'uglify-js';
import { ImportOption } from './named_import';
interface FallbackOptions {
    [key: string]: string | false;
}
type ReadResult = [Buffer | Record<string, any> | string, Record<string, any>] | null | undefined;
interface ParseOptions {
    loader: boolean;
}
interface PorterOptions {
    root?: string;
    paths?: string | string[];
    entries?: string[];
    preload?: string[];
    lazyload?: string[];
    cache?: {
        path: string;
        clean: boolean;
    };
    output?: {
        path?: string;
    };
    transpile?: {
        include?: string[];
        typescript?: 'tsc' | 'babel' | 'swc';
    };
    bundle?: {
        exclude?: string[];
    };
    resolve?: {
        import?: ImportOption[];
        alias?: Record<string, boolean | string>;
        fallback?: FallbackOptions;
        suffixes?: string[];
    };
    source?: {
        serve?: boolean;
        inline?: boolean;
        root?: string;
    };
    map?: Record<string, string>;
    lessOptions?: Record<string, any>;
    uglifyOptions?: MinifyOptions & {
        keep_fnames: RegExp;
    };
    postcssPlugins?: AcceptedPlugin[];
    baseUrl?: string;
    lock?: Record<string, any>;
    package?: PacketMeta;
    /**
     * transform javascript and typescript with swc or not, disabled by default
     */
    swc?: boolean;
}
declare class Porter {
    #private;
    moduleCache: Record<string, Module>;
    packetCache: Record<string, Packet>;
    parseCache: Record<string, Promise<Bundle | null> | null>;
    packet: Packet;
    root: string;
    baseUrl: string;
    map?: Record<string, string>;
    timeout: number;
    entries: string[];
    preload: string[];
    lazyload: string[];
    source: {
        serve: boolean;
        inline: boolean;
        root: string;
        mappingURL?: string;
    };
    cache: Cache;
    output: {
        clean: boolean;
        path: string;
    };
    bundle: {
        exclude: string[];
        exists?: (bundle: Bundle) => Promise<boolean>;
    };
    transpile: {
        include: string[];
        typescript: string;
    };
    resolve: {
        import?: ImportOption[];
        fallback: FallbackOptions;
        suffixes: string[];
    };
    cssTranspiler: Processor;
    lessOptions?: Record<string, any>;
    uglifyOptions?: Record<string, any>;
    browsers: string[];
    browserslistrc?: string;
    targets?: {
        [key: string]: number;
    };
    lock?: Record<string, any>;
    swc: boolean;
    constructor(opts: PorterOptions);
    ready(options?: {
        minify: boolean;
    }): any;
    readFilePath(fpath: string | null): Promise<[string | Buffer, Record<string, any>] | undefined>;
    readBuiltinJs(name: string): Promise<[string | Buffer, Record<string, any>] | undefined>;
    pack({ minify }?: {
        minify?: boolean | undefined;
    }): Promise<void>;
    reload(): Promise<void>;
    prepareFiles(files: string[], isEntry?: boolean): Promise<void>[];
    get lazyloads(): Set<Module>;
    prepare({ minify }?: {
        minify?: boolean | undefined;
    }): Promise<void>;
    compilePackets(opts: CompileOptions): Promise<void>;
    compileExclusivePackets(opts: CompileOptions): Promise<void>;
    compileAll({ entries }: {
        entries: string[];
    }): Promise<void>;
    compileEntry(entry: string, opts: CompileOptions): Promise<Bundle | {
        code: string;
        map: import("source-map").RawSourceMap | undefined;
    } | undefined>;
    readRawFile(file: string): Promise<[string | Buffer, Record<string, any>] | undefined>;
    parseId(id: string, options?: ParseOptions): Promise<Bundle | null>;
    _parseId(id: string, { loader }?: {
        loader?: boolean | undefined;
    }): Promise<Bundle | null>;
    readCss(outputPath: string): Promise<ReadResult>;
    readJs(outputPath: string, query: Record<string, any>): Promise<ReadResult>;
    readMap(mapPath: string): Promise<ReadResult>;
    readWasm(outputPath: string): Promise<ReadResult>;
    readFile(file: string, query: Record<string, any>): Promise<ReadResult>;
    destroy(): Promise<void>;
    func(): (req: any, res: any, next: () => {}) => {} | undefined;
    gen(): (this: any, next: GeneratorFunction) => any;
    async(): (ctx: any, next: () => Promise<any>) => Promise<any>;
}
export default Porter;