/// <reference types="node" />
import { FSWatcher } from 'fs';
import Module from './module';
import Bundle, { CompileOptions } from './bundle';
import Porter from './porter';
import { LoaderConfig, PartiallyRequired } from './defs';
export interface PacketMeta {
    name: string;
    version: string;
    main: string;
    module: string;
    browserify: Record<string, any>;
    browser: string | Record<string, string | boolean>;
    babel: Record<string, any>;
    exports: Record<string, string | string[] | Record<string, string | Record<string, string>>>;
}
interface PacketOptions {
    app: Porter;
    dir: string;
    name?: string;
    paths?: string[];
    parent?: Packet;
    packet?: PacketMeta;
    alias?: Record<string, string | boolean>;
}
type PacketConstructor = PartiallyRequired<PacketOptions, 'packet'>;
interface FakeEntryOptions {
    entry: string;
    deps?: string[];
    imports?: string[];
    code: string;
}
export default class Packet {
    app: Porter;
    dir: string;
    name: string;
    version: string;
    paths: string[];
    parent?: Packet;
    dependencies: Record<string, Packet>;
    entries: Record<string, Module>;
    bundles: Record<string, Bundle>;
    files: Record<string, Module>;
    folder: Record<string, true>;
    browser: Record<string, string | false>;
    exports: Record<string, string | string[] | Record<string, string | Record<string, string>>>;
    browserify: Record<string, any>;
    depPaths: string[];
    isolated: boolean;
    alias: Record<string, string | boolean>;
    transpiler: string;
    transpilerVersion: string;
    transpilerOpts: Record<string, any>;
    lessPlugin?: {
        install: (less: any, pluginManager: any) => {};
        minVersion: number[];
    };
    main: string;
    watchers?: FSWatcher[];
    lazyloaded?: boolean;
    fake: boolean;
    static create(options: PacketConstructor): Packet;
    static findOrCreate({ name, dir, parent, app }: PacketOptions): Promise<Packet>;
    constructor({ app, dir, paths, parent, packet, alias }: PacketConstructor);
    get rootPacket(): Packet;
    get bundle(): Bundle;
    /**
     * check if packet should be bundled and were not bundled yet
     */
    get bundleable(): boolean;
    get all(): Iterable<Packet>;
    /**
     * Find packet by name or by name and version in the packet tree.
     * @param {Object} opts
     * @param {string} opts.name
     * @param {string} opts.version
     */
    find({ name, version }: {
        name?: string;
        version?: string;
    }): Packet | null;
    findAll({ name }: {
        name: string;
    }): Packet[];
    parseDepPaths(): Promise<void>;
    findTranspiler(): Promise<void>;
    prepareTranspiler(): Promise<void>;
    prepare(): Promise<void>;
    watch(): void;
    onChange(eventType: string, filename: string | null): Promise<void>;
    reload(eventType: string, filename: string): Promise<void>;
    tryRequire(name: string): any;
    normalizeFile(file: string): string | false;
    parseModule(file: string): Promise<false | Module | undefined>;
    parseEntry(entry: string): Promise<false | Module | undefined>;
    parseFile(file: string): Promise<false | Module | undefined>;
    /**
     * Parse an entry that has code or deps (or both) specified already.
     */
    parseFakeEntry(options: FakeEntryOptions): Promise<Module>;
    parsePacket({ name, entry }: {
        name: string;
        entry: string;
    }): Promise<false | Module | undefined>;
    resolve(file: string): Promise<string[]>;
    get lock(): any;
    get copy(): Record<string, any>;
    get loaderConfig(): {
        alias: Record<string, string | boolean>;
        baseUrl: string;
        map: Record<string, string> | undefined;
        preload: string[];
        package: {
            name: string;
            version: string;
            main: string;
        };
        timeout: number;
    };
    parseLoader(loaderConfig: LoaderConfig): Promise<{
        sourceContent: string;
        code: string;
    }>;
    pack({ minify }?: {
        minify?: boolean | undefined;
    }): Promise<void>;
    compileAll(opts: CompileOptions): Promise<void>;
    compile(entries: string | string[], opts: CompileOptions): Promise<Bundle | {
        code: string;
        map: import("source-map").RawSourceMap | undefined;
    } | undefined>;
    destroy(): Promise<void>;
}
export {};