import type { JsonValue } from '../control-plane';
import type { RegionalProviderDriver, RegionalTarget, RegionalTopology, RegionalTrafficRoute, ReplicationChannel } from './types';
export interface AwsRegionalTransport {
    applyCloudFormation(input: {
        region: string;
        stackId?: string;
        revision: string;
        manifest: JsonValue;
    }): Promise<{
        stackId: string;
    }>;
    deleteCloudFormation(input: {
        region: string;
        stackId: string;
        retainData: boolean;
    }): Promise<void>;
    stackHealth(input: {
        region: string;
        stackId: string;
    }): Promise<{
        healthy: boolean;
        evidence: Record<string, JsonValue>;
    }>;
    configureS3Replication(input: {
        sourceRegion: string;
        targetRegion: string;
        config: Record<string, JsonValue>;
    }): Promise<{
        checkpoint: string;
        lagSeconds: number;
    }>;
    configureDynamoGlobalTable(input: {
        sourceRegion: string;
        targetRegion: string;
        config: Record<string, JsonValue>;
    }): Promise<{
        checkpoint: string;
        lagSeconds: number;
    }>;
    replicateSecrets(input: {
        sourceRegion: string;
        targetRegion: string;
        config: Record<string, JsonValue>;
    }): Promise<{
        checkpoint: string;
        lagSeconds: number;
    }>;
    verifyReplication(input: {
        kind: ReplicationChannel['kind'];
        sourceRegion: string;
        targetRegion: string;
        checkpoint?: string;
    }): Promise<{
        healthy: boolean;
        checkpoint: string;
        lagSeconds: number;
    }>;
    applyEdge(input: {
        hostname: string;
        weights: Record<string, number>;
        route53: boolean;
        cloudFront: boolean;
        waf: boolean;
    }): Promise<{
        providerState: Record<string, JsonValue>;
    }>;
}
export declare class AwsRegionalDriver implements RegionalProviderDriver {
    private transport;
    readonly provider = "aws";
    constructor(transport: AwsRegionalTransport);
    applyStack({ target, revision, manifest, }: {
        target: RegionalTarget;
        revision: string;
        manifest: JsonValue;
        signal: AbortSignal;
    }): Promise<{
        stackId: string;
    }>;
    deleteStack({ target, retainData, }: {
        target: RegionalTarget;
        retainData: boolean;
        signal: AbortSignal;
    }): Promise<void>;
    health({ target, }: {
        target: RegionalTarget;
    }): Promise<{
        healthy: boolean;
        evidence: Record<string, JsonValue>;
    }>;
    configureReplication({ channel, }: {
        channel: ReplicationChannel;
        topology: RegionalTopology;
    }): Promise<{
        checkpoint: string;
        lagSeconds: number;
    }>;
    verifyReplication({ channel, }: {
        channel: ReplicationChannel;
        topology: RegionalTopology;
    }): Promise<{
        healthy: boolean;
        checkpoint: string;
        lagSeconds: number;
    }>;
    applyTraffic({ route, weights, }: {
        route: RegionalTrafficRoute;
        topology: RegionalTopology;
        weights: Record<string, number>;
    }): Promise<{
        providerState: Record<string, JsonValue>;
    }>;
}
export declare class UnavailableRegionalDriver implements RegionalProviderDriver {
    readonly provider: string;
    private reason;
    constructor(provider: string, reason?: string);
    private fail;
    applyStack(): Promise<{
        stackId: string;
    }>;
    deleteStack(): Promise<void>;
    health(): Promise<{
        healthy: boolean;
        evidence: Record<string, JsonValue>;
    }>;
    configureReplication(): Promise<{
        checkpoint: string;
        lagSeconds: number;
    }>;
    verifyReplication(): Promise<{
        healthy: boolean;
        checkpoint: string;
        lagSeconds: number;
    }>;
    applyTraffic(): Promise<{
        providerState: Record<string, JsonValue>;
    }>;
}
