export interface ILogger {
    debug: (...args: any[]) => any;
    trace: (...args: any[]) => any;
    error: (...args: any[]) => any;
}
export declare namespace Metro {
    enum ResolutionType {
        ASSET = "asset",
        SOURCE_FILE = "sourceFile"
    }
    type CustomResolver = (metro: IResolverConfig, moduleName: string, platform: string) => IResolution | null;
    interface IResolution {
        type: ResolutionType;
        filePath: string;
    }
    interface IConfig {
        projectRoot?: string;
        watchFolders: string[];
        resolver: {
            resolveRequest?: CustomResolver;
            extraNodeModules?: {
                [moduleName: string]: string;
            };
        };
        sourceExts?: string[];
        getTransformModulePath?: () => any;
    }
    interface IResolverConfig {
        originModulePath: string;
        sourceExts: string[];
        assetExts?: string[];
        mainFields: string[];
    }
}
export interface IMonorepoInfo {
    root: string;
    project: {
        root: string;
    };
    packages: Array<{
        root: string;
    }>;
}
declare type FMonorepoFinder = (projectRoot: string, helper: MetroConfigHelper) => IMonorepoInfo | null;
interface IMetroConfigHelperOptions {
    logger?: ILogger;
    defaultConfig?: Partial<Metro.IConfig>;
    monorepoFinders?: FMonorepoFinder[];
    projectRoot?: string;
}
interface ITypeScriptConfig {
    transformerModuleName: string;
    fileExtensions: string[];
}
declare class MetroConfigHelper {
    private monorepoFinders_;
    private logger_;
    private defaultConfig_?;
    private monorepo_?;
    private projectRoot_?;
    private watchFolders_;
    private customResolver_?;
    private config_?;
    private typeScript_;
    constructor(options?: IMetroConfigHelperOptions);
    projectRoot(): string;
    projectRoot(newProjectRoot: string): this;
    monorepoFinder(...finder: FMonorepoFinder[]): this;
    findMonorepo(): IMonorepoInfo | undefined;
    logger(): ILogger;
    logger(newLogger: ILogger): this;
    defaultConfig(): Partial<Metro.IConfig>;
    defaultConfig(newDefaultConfig: Partial<Metro.IConfig>): this;
    monorepo(): IMonorepoInfo;
    monorepo(newMonorepoInfo: IMonorepoInfo): this;
    typeScript(): false | ITypeScriptConfig;
    typeScript(enabled: boolean | string | Partial<ITypeScriptConfig>): this;
    watchFolder(...folder: string[]): this;
    packageRoots(): string[];
    watchFolders(): string[];
    customResolver(): Metro.CustomResolver;
    customResolver(newResolver: Metro.CustomResolver): this;
    createCustomResolver(): Metro.CustomResolver;
    config(): Metro.IConfig;
    config(newConfig: Metro.IConfig): this;
    generate(): Metro.IConfig;
    private readonly mapByFolderFollowingSymlink;
    private readonly filterByNonEmptyString;
    private resolveInProject;
    private fileModuleExists;
    private isDirectory;
    private generateComplementaryExtensions;
    private isTypeScriptConfig;
}
export declare function findLernaMonorepo(projectRoot: string, helper: MetroConfigHelper): IMonorepoInfo | null;
export declare function findYarnMonorepo(projectRoot: string, helper: MetroConfigHelper): IMonorepoInfo | null;
export declare const nullLogger: ILogger;
export declare const consoleLogger: ILogger;
export declare const defaultHelperOptions: {
    logger: {
        trace: (...args: any[]) => any;
        debug: (...args: any[]) => any;
        error: (...args: any[]) => any;
    };
    monorepoFinders: (typeof findLernaMonorepo)[];
};
export declare const defaultTypeScriptConfig: ITypeScriptConfig;
export declare function metroConfigHelper(projectRoot: string, options?: IMetroConfigHelperOptions): MetroConfigHelper;
export declare function metroConfig(projectRoot: string): Metro.IConfig;
export default metroConfig;