/// <reference types="node" />
import { EventEmitter } from 'events';
import type { Logger } from '../logger';
import type { ILogger } from '../logger/constants';
import type { MaterialsManager } from '../materials';
import { FsMaterial } from '../materials/FsMaterial';
import { fs } from '@modern-js/codesmith-utils/fs-extra';
import type { GeneratorContext } from './constants';
interface ICreateOptions {
    logger: Logger;
    materialsManager: MaterialsManager;
    outputPath: string;
}
export declare class GeneratorCore {
    logger: ILogger;
    materialsManager: MaterialsManager;
    outputPath: string;
    basePath: string;
    output: {
        fs: (file: string | number, data: any, options?: fs.WriteFileOptions | string) => Promise<void>;
    };
    _context: GeneratorContext;
    event: EventEmitter;
    constructor({ logger, materialsManager, outputPath }: ICreateOptions);
    private get lifeCycleMethod();
    private setConfig;
    addMaterial(key: string, material: FsMaterial): void;
    private setCurrent;
    private setOutputPath;
    private setbasePath;
    private loadLocalGenerator;
    private loadRemoteGenerator;
    handleForged(generatorName: string, context: {
        materials: {
            default: {
                basePath: string;
            };
        };
        data: Record<string, unknown>;
        config: Record<string, unknown>;
    }, needWait?: boolean, projectPath?: string): Promise<unknown>;
    loadGenerator(generator: string): Promise<{
        materialKey?: undefined;
        generatorPkg?: undefined;
        generatorScript?: undefined;
    } | {
        materialKey: string;
        generatorPkg: FsMaterial;
        generatorScript: any;
    }>;
    runGenerator(generator: string, config?: Record<string, unknown>): Promise<void>;
    runSubGenerator(subGenerator: string, relativePwdPath?: string, config?: Record<string, any>): Promise<void>;
    prepareGenerators(generators: string[]): Promise<void>;
    prepareGlobal(): Promise<void>;
}
export {};