@beemo/core/dts/types.d.ts

import { ExecaError, ExecaReturnValue } from 'execa';
import { Arguments, Argv, Command, MapOptionConfig, MapParamConfig, OptionConfigMap, ParserOptions, PrimitiveType } from '@boost/args';
import { Path, PortablePath } from '@boost/common';
import { PluginsSetting } from '@boost/config';
import { Pluggable } from '@boost/plugin';
import type { Context } from './contexts/Context';
import type { ScriptContext } from './contexts/ScriptContext';
import type { Tool } from './Tool';
export type { Arguments, Argv, ParserOptions };
export declare type BeemoTool = Tool;
export interface BeemoProcess<C extends Context = Context> {
    context: C;
    tool: BeemoTool;
}
export declare type UnknownSettings = Record<string, unknown>;
export interface BootstrapFile {
    (tool: BeemoTool): Promise<void> | void;
    bootstrap?: (tool: BeemoTool) => Promise<void> | void;
    default?: (tool: BeemoTool) => Promise<void> | void;
}
export declare type Execution = ExecaReturnValue;
export declare type ExecutionError = ExecaError;
export declare type DriverConfigStrategy = 'copy' | 'create' | 'native' | 'none' | 'reference' | 'template';
export declare type DriverOutputStrategy = 'buffer' | 'none' | 'pipe' | 'stream';
export interface DriverOptions {
    args?: string[];
    configStrategy?: DriverConfigStrategy;
    dependencies?: string[];
    env?: Record<string, string>;
    expandGlobs?: boolean;
    outputStrategy?: DriverOutputStrategy;
    template?: string;
}
export interface DriverMetadata {
    bin: string;
    commandOptions: OptionConfigMap;
    configName: string;
    configOption: string;
    configStrategy: 'copy' | 'create' | 'reference' | 'template';
    dependencies: string[];
    description: string;
    filterOptions: boolean;
    helpOption: string;
    title: string;
    useConfigOption: boolean;
    versionOption: string;
    watchOptions: string[];
    workspaceStrategy: 'copy' | 'reference';
}
export interface DriverOutput {
    stderr: string;
    stdout: string;
}
export interface Driverable extends Pluggable<BeemoTool> {
    metadata: DriverMetadata;
}
export interface DriverCommandConfig<O extends object, P extends PrimitiveType[]> extends Omit<Command, 'category'> {
    allowUnknownOptions?: boolean;
    allowVariadicParams?: boolean | string;
    options?: MapOptionConfig<O>;
    params?: MapParamConfig<P>;
}
export declare type DriverCommandRunner<O extends object, P extends PrimitiveType[]> = (tool: Tool, options: O, params: P, rest: string[]) => Promise<string | undefined | void> | string | undefined | void;
export interface DriverCommandRegistration<O extends object, P extends PrimitiveType[]> {
    path: string;
    config: DriverCommandConfig<O, P>;
    runner: DriverCommandRunner<O, P>;
}
export interface Scriptable<O extends object> extends Pluggable<BeemoTool> {
    parse: () => ParserOptions<O>;
    execute: (context: ScriptContext, args: Arguments<O>) => Promise<unknown>;
}
export interface RoutineOptions {
    tool: BeemoTool;
}
export declare type ConfigExecuteStrategy = DriverOutputStrategy | '';
export interface ConfigFile<T extends object = UnknownSettings> {
    configure: {
        cleanup: boolean;
        parallel: boolean;
    };
    debug: boolean;
    drivers: PluginsSetting;
    execute: {
        concurrency: number;
        graph: boolean;
        output: ConfigExecuteStrategy;
    };
    module: string;
    scripts: PluginsSetting;
    settings: T;
}
export interface BeemoConfig<T extends object = UnknownSettings> {
    configure?: {
        cleanup?: boolean;
        parallel?: boolean;
    };
    debug?: boolean;
    drivers?: PluginsSetting;
    execute?: {
        concurrency?: number;
        graph?: boolean;
        output?: ConfigExecuteStrategy;
    };
    module?: string;
    scripts?: PluginsSetting;
    settings?: T;
}
export declare type ConfigObject = Record<string, unknown>;
export interface ConfigTemplateOptions {
    configModule: string;
    consumerConfigPath: Path | null;
    context: Context;
    driver: Driverable;
    driverConfigPath: Path;
    driverName: string;
    providerConfigPath: Path | null;
    templatePath: Path;
    tool: BeemoTool;
}
export interface ConfigTemplateResult {
    config: ConfigObject | string;
    path?: PortablePath;
}
export declare type ConfigTemplate = (configs: ConfigObject[], options: ConfigTemplateOptions) => ConfigTemplateResult;
declare global {
    namespace NodeJS {
        interface Process {
            beemo: BeemoProcess;
        }
    }
}
//# sourceMappingURL=types.d.ts.map