@re-shell/cli/dist/utils/lazy-loader.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

/**
 * Lazy loading system for heavy dependencies
 */
interface LazyModule<T> {
    _module?: T;
    _promise?: Promise<T>;
    load(): Promise<T>;
    get(): T | undefined;
}
/**
 * Create a lazy-loaded module
 */
export declare function lazy<T>(loader: () => Promise<T>): LazyModule<T>;
/**
 * Common heavy dependencies with lazy loading
 */
export declare const lazyModules: {
    chalk: LazyModule<import("chalk").Chalk & import("chalk").ChalkFunction & {
        supportsColor: import("chalk").ColorSupport | false;
        Level: import("chalk").Level;
        Color: ("black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright") | ("bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright");
        ForegroundColor: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
        BackgroundColor: "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
        Modifiers: "bold" | "hidden" | "reset" | "dim" | "italic" | "underline" | "inverse" | "strikethrough" | "visible";
        stderr: import("chalk").Chalk & {
            supportsColor: import("chalk").ColorSupport | false;
        };
    }>;
    ora: LazyModule<{
        (options?: import("ora").Options | string): import("ora").Ora;
        promise(action: PromiseLike<unknown>, options?: import("ora").Options | string): import("ora").Ora;
    }>;
    globby: LazyModule<any>;
    rimraf: LazyModule<any>;
    fsExtra: LazyModule<any>;
    chokidar: LazyModule<typeof import("chokidar")>;
    vite: LazyModule<{
        default: typeof import("vite");
        build(inlineConfig?: import("vite").InlineConfig): Promise<import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher>;
        buildErrorMessage(err: import("rollup").RollupError, args?: string[], includeStack?: boolean): string;
        createLogger(level?: import("vite").LogLevel, options?: import("vite").LoggerOptions): import("vite").Logger;
        createServer(inlineConfig?: import("vite").InlineConfig): Promise<import("vite").ViteDevServer>;
        defineConfig(config: import("vite").UserConfig): import("vite").UserConfig;
        defineConfig(config: Promise<import("vite").UserConfig>): Promise<import("vite").UserConfig>;
        defineConfig(config: import("vite").UserConfigFnObject): import("vite").UserConfigFnObject;
        defineConfig(config: import("vite").UserConfigExport): import("vite").UserConfigExport;
        formatPostcssSourceMap(rawMap: import("rollup").ExistingRawSourceMap, file: string): Promise<import("rollup").ExistingRawSourceMap>;
        getDepOptimizationConfig(config: import("vite").ResolvedConfig, ssr: boolean): import("vite").DepOptimizationConfig;
        isDepsOptimizerEnabled(config: import("vite").ResolvedConfig, ssr: boolean): boolean;
        isFileLoadingAllowed(server: import("vite").ViteDevServer, filePath: string): boolean;
        isFileServingAllowed(url: string, server: import("vite").ViteDevServer): boolean;
        loadConfigFromFile(configEnv: import("vite").ConfigEnv, configFile?: string, configRoot?: string, logLevel?: import("vite").LogLevel): Promise<{
            path: string;
            config: import("vite").UserConfig;
            dependencies: string[];
        } | null>;
        loadEnv(mode: string, envDir: string, prefixes?: string | string[]): Record<string, string>;
        mergeAlias(a?: import("vite").AliasOptions, b?: import("vite").AliasOptions): import("vite").AliasOptions | undefined;
        mergeConfig<D extends Record<string, any>, O extends Record<string, any>>(defaults: D extends Function ? never : D, overrides: O extends Function ? never : O, isRoot?: boolean): Record<string, any>;
        normalizePath(id: string): string;
        optimizeDeps(config: import("vite").ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<import("vite").DepOptimizationMetadata>;
        preprocessCSS(code: string, filename: string, config: import("vite").ResolvedConfig): Promise<import("vite").PreprocessCSSResult>;
        preview(inlineConfig?: import("vite").InlineConfig): Promise<import("vite").PreviewServer>;
        resolveBaseUrl(base: string | undefined, isBuild: boolean, logger: import("vite").Logger): string;
        resolveConfig(inlineConfig: import("vite").InlineConfig, command: "build" | "serve", defaultMode?: string, defaultNodeEnv?: string): Promise<import("vite").ResolvedConfig>;
        resolveEnvPrefix({ envPrefix, }: import("vite").UserConfig): string[];
        resolvePackageData(pkgName: string, basedir: string, preserveSymlinks?: boolean, packageCache?: import("vite").PackageCache): import("vite").PackageData | null;
        resolvePackageEntry(id: string, { dir, data, setResolvedCache, getResolvedCache }: import("vite").PackageData, targetWeb: boolean, options: import("vite").InternalResolveOptions): string | undefined;
        searchForWorkspaceRoot(current: string, root?: string): string;
        send(req: import("http").IncomingMessage, res: import("http").ServerResponse, content: string | Buffer, type: string, options: import("vite").SendOptions): void;
        sortUserPlugins(plugins: (import("vite").Plugin | import("vite").Plugin[])[] | undefined): [import("vite").Plugin[], import("vite").Plugin[], import("vite").Plugin[]];
        splitVendorChunk(options?: {
            cache?: import("vite").SplitVendorChunkCache;
        }): import("rollup").GetManualChunk;
        splitVendorChunkPlugin(): import("vite").Plugin;
        transformWithEsbuild(code: string, filename: string, options?: import("esbuild").TransformOptions, inMap?: object): Promise<import("vite").ESBuildTransformResult>;
        Connect: typeof import("vite").Connect;
        createFilter: (include?: import("vite").FilterPattern, exclude?: import("vite").FilterPattern, options?: {
            resolve?: string | false | null;
        }) => (id: string | unknown) => boolean;
        esbuildVersion: string;
        FSWatcher: typeof import("vite").FSWatcher;
        HttpProxy: typeof import("vite").HttpProxy;
        isCSSRequest: (request: string) => boolean;
        ModuleGraph: typeof import("vite").ModuleGraph;
        ModuleNode: typeof import("vite").ModuleNode;
        rollupVersion: string;
        SplitVendorChunkCache: typeof import("vite").SplitVendorChunkCache;
        Terser: typeof import("vite").Terser;
        version: string;
        WebSocket: typeof import("vite").WebSocket;
        WebSocketAlias: typeof import("vite").WebSocket;
    }>;
    yaml: LazyModule<any>;
    ajv: LazyModule<{
        (options?: import("ajv").Options): import("ajv").Ajv;
        new (options?: import("ajv").Options): import("ajv").Ajv;
        ValidationError: {
            new (errors: Array<import("ajv").ErrorObject>): {
                message: string;
                errors: Array<import("ajv").ErrorObject>;
                ajv: true;
                validation: true;
                name: string;
                stack?: string;
            };
            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
            stackTraceLimit: number;
        };
        MissingRefError: {
            new (baseId: string, ref: string, message?: string): {
                message: string;
                missingRef: string;
                missingSchema: string;
                name: string;
                stack?: string;
            };
            message: (baseId: string, ref: string) => string;
            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
            stackTraceLimit: number;
        };
        $dataMetaSchema: object;
    }>;
    handlebars: LazyModule<{
        default: typeof Handlebars;
        registerHelper(name: string, fn: Handlebars.HelperDelegate): void;
        registerHelper(name: Handlebars.HelperDeclareSpec): void;
        unregisterHelper(name: string): void;
        registerPartial(name: string, fn: Handlebars.Template): void;
        registerPartial(spec: {
            [name: string]: HandlebarsTemplateDelegate;
        }): void;
        unregisterPartial(name: string): void;
        registerDecorator(name: string, fn: Function): void;
        unregisterDecorator(name: string): void;
        K(): void;
        createFrame(object: any): any;
        blockParams(obj: any[], ids: any[]): any[];
        log(level: number, obj: any): void;
        parse(input: string, options?: Handlebars.ParseOptions): hbs.AST.Program;
        parseWithoutProcessing(input: string, options?: Handlebars.ParseOptions): hbs.AST.Program;
        compile<T = any>(input: any, options?: CompileOptions): HandlebarsTemplateDelegate<T>;
        precompile(input: any, options?: PrecompileOptions): TemplateSpecification;
        template<T = any>(precompilation: TemplateSpecification): HandlebarsTemplateDelegate<T>;
        create(): typeof Handlebars;
        noConflict(): typeof Handlebars;
        escapeExpression: typeof Handlebars.Utils.escapeExpression;
        logger: Logger;
        templates: HandlebarsTemplates;
        helpers: {
            [name: string]: Handlebars.HelperDelegate;
        };
        partials: {
            [name: string]: any;
        };
        decorators: {
            [name: string]: Function;
        };
        VERSION: string;
        Exception: typeof Handlebars.Exception;
        SafeString: typeof Handlebars.SafeString;
        Utils: typeof Handlebars.Utils;
        AST: typeof Handlebars.AST;
        Visitor: typeof Handlebars.Visitor;
        VM: typeof Handlebars.VM;
    }>;
    ejs: LazyModule<any>;
    lodash: LazyModule<any>;
    dayjs: LazyModule<typeof import("dayjs")>;
    semver: LazyModule<{
        default: typeof import("semver");
        clean: typeof import("semver").clean;
        compare: typeof import("semver").compare;
        compareBuild: typeof import("semver").compareBuild;
        compareLoose: typeof import("semver").compareLoose;
        diff: typeof import("semver").diff;
        inc: typeof import("semver").inc;
        major: typeof import("semver").major;
        minor: typeof import("semver").minor;
        parse: typeof import("semver").parse;
        patch: typeof import("semver").patch;
        prerelease: typeof import("semver").prerelease;
        rcompare: typeof import("semver").rcompare;
        rsort: typeof import("semver").rsort;
        sort: typeof import("semver").sort;
        valid: typeof import("semver").valid;
        cmp: typeof import("semver").cmp;
        coerce: typeof import("semver").coerce;
        eq: typeof import("semver").eq;
        gt: typeof import("semver").gt;
        gte: typeof import("semver").gte;
        lt: typeof import("semver").lt;
        lte: typeof import("semver").lte;
        neq: typeof import("semver").neq;
        subset: typeof import("semver").subset;
        gtr: typeof import("semver").gtr;
        intersects: typeof import("semver").intersects;
        ltr: typeof import("semver").ltr;
        maxSatisfying: typeof import("semver").maxSatisfying;
        minSatisfying: typeof import("semver").minSatisfying;
        minVersion: typeof import("semver").minVersion;
        outside: typeof import("semver").outside;
        satisfies: typeof import("semver").satisfies;
        toComparators: typeof import("semver").toComparators;
        validRange: typeof import("semver").validRange;
        simplifyRange: typeof import("semver").simplifyRange;
        Comparator: typeof import("semver").Comparator;
        Range: typeof import("semver").Range;
        SemVer: typeof import("semver").SemVer;
        compareIdentifiers: typeof import("semver").compareIdentifiers;
        rcompareIdentifiers: typeof import("semver").rcompareIdentifiers;
        SEMVER_SPEC_VERSION: "2.0.0";
        RELEASE_TYPES: import("semver").ReleaseType[];
    }>;
    dockerode: LazyModule<any>;
    simpleGit: LazyModule<import("simple-git").SimpleGitFactory>;
    cliTable3: LazyModule<import("cli-table3")>;
    boxen: LazyModule<typeof import("boxen").default>;
    cosmiconfig: LazyModule<{
        default: typeof import("cosmiconfig");
        cosmiconfig(moduleName: string, options?: Readonly<Partial<import("cosmiconfig").Options>>): import("cosmiconfig").PublicExplorer;
        cosmiconfigSync(moduleName: string, options?: Readonly<Partial<import("cosmiconfig").OptionsSync>>): import("cosmiconfig").PublicExplorerSync;
        getDefaultSearchPlaces: typeof import("cosmiconfig").getDefaultSearchPlaces;
        getDefaultSearchPlacesSync: typeof import("cosmiconfig").getDefaultSearchPlacesSync;
        globalConfigSearchPlaces: string[];
        globalConfigSearchPlacesSync: string[];
        defaultLoaders: Readonly<{
            readonly '.mjs': import("cosmiconfig").Loader;
            readonly '.cjs': import("cosmiconfig").Loader;
            readonly '.js': import("cosmiconfig").Loader;
            readonly '.ts': import("cosmiconfig").Loader;
            readonly '.json': import("cosmiconfig").LoaderSync;
            readonly '.yaml': import("cosmiconfig").LoaderSync;
            readonly '.yml': import("cosmiconfig").LoaderSync;
            readonly noExt: import("cosmiconfig").LoaderSync;
        }>;
        defaultLoadersSync: Readonly<{
            readonly '.cjs': import("cosmiconfig").LoaderSync;
            readonly '.js': import("cosmiconfig").LoaderSync;
            readonly '.ts': import("cosmiconfig").LoaderSync;
            readonly '.json': import("cosmiconfig").LoaderSync;
            readonly '.yaml': import("cosmiconfig").LoaderSync;
            readonly '.yml': import("cosmiconfig").LoaderSync;
            readonly noExt: import("cosmiconfig").LoaderSync;
        }>;
    }>;
    dotenv: LazyModule<{
        default: typeof import("dotenv");
        parse<T extends import("dotenv").DotenvParseOutput = import("dotenv").DotenvParseOutput>(src: string | Buffer): T;
        config(options?: import("dotenv").DotenvConfigOptions): import("dotenv").DotenvConfigOutput;
        configDotenv(options?: import("dotenv").DotenvConfigOptions): import("dotenv").DotenvConfigOutput;
        populate(processEnv: import("dotenv").DotenvPopulateInput, parsed: import("dotenv").DotenvPopulateInput, options?: import("dotenv").DotenvConfigOptions): void;
        decrypt(encrypted: string, keyStr: string): string;
    }>;
};
/**
 * Preload critical modules in background
 */
export declare function preloadCriticalModules(): Promise<void>;
/**
 * Get a lazy module with fallback
 */
export declare function getLazyModule<T>(module: LazyModule<T>, fallback?: T): Promise<T>;
/**
 * Cache for compiled templates and schemas
 */
declare class CompiledCache {
    private cache;
    get(key: string): any;
    set(key: string, value: any): void;
    has(key: string): boolean;
    clear(): void;
}
export declare const compiledCache: CompiledCache;
/**
 * Defer expensive operations until after startup
 */
export declare class DeferredOperations {
    private operations;
    private running;
    add(operation: () => Promise<void>): void;
    private process;
}
export declare const deferredOps: DeferredOperations;
export {};