import { SynthesizedStack } from "./synth-stack";
import { CdktfStack, StackUpdate } from "./cdktf-stack";
import { TerraformPlan } from "./models/terraform";
import { NestedTerraformOutputs } from "./output";
declare type MultiStackApprovalUpdate = {
    type: "waiting for approval";
    stackName: string;
    plan: TerraformPlan;
    approve: () => void;
    dismiss: () => void;
    stop: () => void;
};
export declare type ProjectUpdate = {
    type: "synthesizing";
} | {
    type: "synthesized";
    stacks: SynthesizedStack[];
    errorMessage?: string;
} | StackUpdate | MultiStackApprovalUpdate;
export declare function getMultipleStacks(stacks: SynthesizedStack[], patterns?: string[], targetAction?: string): SynthesizedStack[];
export declare function getStackWithNoUnmetDependencies(stackExecutors: CdktfStack[]): Promise<CdktfStack | undefined>;
export declare type SingleStackOptions = {
    stackName?: string;
};
export declare type MultipleStackOptions = {
    stackNames?: string[];
};
export declare type ExecutionOptions = MultipleStackOptions & {
    autoApprove?: boolean;
    ignoreMissingStackDependencies?: boolean;
    parallelism?: number;
};
declare type LogMessage = {
    stackName: string;
    messageWithConstructPath?: string;
    message: string;
};
export declare type CdktfProjectOptions = {
    synthCommand: string;
    outDir: string;
    onUpdate: (update: ProjectUpdate) => void;
    onLog?: (log: LogMessage) => void;
    workingDirectory?: string;
};
export declare class CdktfProject {
    stacks?: SynthesizedStack[];
    hardAbort: () => void;
    private synthCommand;
    private outDir;
    private workingDirectory;
    private onUpdate;
    private onLog?;
    private abortSignal;
    stacksToRun: CdktfStack[];
    private stopAllStacksThatCanNotRunWithout;
    private waitingForApproval;
    private eventBuffer;
    constructor({ synthCommand, outDir, onUpdate, onLog, workingDirectory, }: CdktfProjectOptions);
    private stopAllStacks;
    private waitForApproval;
    private resumeAfterApproval;
    private handleApprovalProcess;
    private bufferWhileWaitingForApproval;
    getStackExecutor(stack: SynthesizedStack, opts?: ExecutionOptions): CdktfStack;
    get outputsByConstructId(): NestedTerraformOutputs;
    synth(): Promise<SynthesizedStack[]>;
    diff(opts?: SingleStackOptions): Promise<TerraformPlan>;
    private execute;
    deploy(opts?: ExecutionOptions): Promise<void>;
    destroy(opts?: ExecutionOptions): Promise<void>;
    fetchOutputs(opts: MultipleStackOptions): Promise<NestedTerraformOutputs>;
}
export {};
