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 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;
    message: 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, }: {
        synthCommand: string;
        outDir: string;
        onUpdate: (update: ProjectUpdate) => void;
        onLog?: (log: LogMessage) => void;
        workingDirectory?: string;
    });
    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 | undefined>;
    private execute;
    deploy(opts?: ExecutionOptions): Promise<void>;
    destroy(opts?: ExecutionOptions): Promise<void>;
    fetchOutputs(opts?: SingleStackOptions): Promise<{
        [key: string]: import("./models/terraform").TerraformOutput;
    } | {
        [key: string]: NestedTerraformOutputs;
    } | undefined>;
}
export {};
