import { Store } from 'mem-fs';
import { ParamProvider, ParamProviderFactory } from '../provider/param-provider';
import { PathProvider } from '../provider/path-provider';
import { PhpProvider } from '../provider/php-provider';
export interface Step {
    /**
     * A short string describing what the step does.
     */
    type: string;
    /**
     * Can this step be composed with other steps?
     *
     * This is the case if the step makes no changes to the disk filesystem while running.
     */
    composable: boolean;
    /**
     * A list of names of params that this step exposes to other steps.
     */
    exposes: string[];
    run: (fs: Store, pathProvider: PathProvider, paramProvider: ParamProvider, phpProvider: PhpProvider) => Promise<Store>;
    /**
     * Return an object of exposed params.
     *
     * The pathProvider and paramProvider will be the same objects provided to the `run` method.
     */
    getExposed(pathProvider: PathProvider, paramProvider: ParamProvider): Record<string, unknown>;
}
interface ShouldRunConfig {
    optional?: boolean;
    confirmationMessage?: string;
    default?: boolean;
}
interface StoredStep {
    name?: string;
    step: Step;
    shouldRun: ShouldRunConfig;
    dependencies: StepDependency[];
}
interface StepDependency {
    sourceStep: string;
    exposedName: string;
    consumedName?: string;
    dontRunIfFalsy?: boolean;
}
export declare class StepManager {
    protected steps: Array<StoredStep | AtomicStepManager>;
    protected namedSteps: Map<string, StoredStep>;
    protected exposedParams: Map<string, Record<string, unknown>>;
    /**
     * A step is an incremental operation that updates the filesystem.
     */
    step(step: Step, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[]): this;
    namedStep(name: string, step: Step, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[]): this;
    atomicGroup(callback: (stepManager: AtomicStepManager) => void): this;
    protected validateDependencies(step: Step, dependencies: StepDependency[]): void;
    run(pathProvider: PathProvider, paramProviderFactory: ParamProviderFactory, phpProvider: PhpProvider): Promise<string[]>;
    protected stepShouldRun(storedStep: StoredStep, paramProviderFactory: ParamProviderFactory): Promise<boolean>;
    protected runStep(storedStep: StoredStep, pathProvider: PathProvider, paramProviderFactory: ParamProviderFactory, phpProvider: PhpProvider): Promise<Store>;
    protected commit(fs: Store): Promise<boolean>;
}
declare class AtomicStepManager extends StepManager {
    constructor(parentNamedSteps: Map<string, StoredStep>, parentExposedParams: Map<string, Record<string, unknown>>);
    step(step: Step, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[]): this;
    namedStep(name: string, step: Step, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[]): this;
    atomicGroup(_callback: (stepManager: AtomicStepManager) => void): this;
    run(pathProvider: PathProvider, paramProviderFactory: ParamProviderFactory, phpProvider: PhpProvider): Promise<string[]>;
}
export {};