import { z } from 'zod';
import { EventEmitter } from 'events';
declare const CloudOperationSchema: z.ZodObject<{
    operation: z.ZodEnum<["create", "read", "update", "delete", "query", "scan"]>;
    collection: z.ZodString;
    data: z.ZodOptional<z.ZodAny>;
    filter: z.ZodOptional<z.ZodAny>;
    options: z.ZodOptional<z.ZodObject<{
        consistency: z.ZodDefault<z.ZodEnum<["eventual", "strong"]>>;
        timeout: z.ZodDefault<z.ZodNumber>;
        retries: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        consistency: "strong" | "eventual";
        timeout: number;
        retries: number;
    }, {
        consistency?: "strong" | "eventual" | undefined;
        timeout?: number | undefined;
        retries?: number | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    collection: string;
    operation: "update" | "delete" | "create" | "query" | "read" | "scan";
    filter?: any;
    options?: {
        consistency: "strong" | "eventual";
        timeout: number;
        retries: number;
    } | undefined;
    data?: any;
}, {
    collection: string;
    operation: "update" | "delete" | "create" | "query" | "read" | "scan";
    filter?: any;
    options?: {
        consistency?: "strong" | "eventual" | undefined;
        timeout?: number | undefined;
        retries?: number | undefined;
    } | undefined;
    data?: any;
}>;
export type CloudOperation = z.infer<typeof CloudOperationSchema>;
export declare abstract class CloudDatabaseAdapter extends EventEmitter {
    protected connectionString: string;
    protected isConnected: boolean;
    protected metrics: {
        operations: number;
        errors: number;
        latency: number[];
    };
    constructor(connectionString: string);
    abstract connect(): Promise<void>;
    abstract disconnect(): Promise<void>;
    abstract execute(operation: CloudOperation): Promise<any>;
    abstract healthCheck(): Promise<boolean>;
    protected trackOperation(startTime: number, success: boolean): void;
    getMetrics(): {
        operations: number;
        errors: number;
        errorRate: number;
        averageLatency: number;
        isConnected: boolean;
    };
}
export declare class AWSDynamoDBAdapter extends CloudDatabaseAdapter {
    private client;
    constructor(config: {
        region: string;
        accessKeyId?: string;
        secretAccessKey?: string;
        endpoint?: string;
    });
    private initializeClient;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    execute(operation: CloudOperation): Promise<any>;
    private simulateDynamoDBOperation;
    healthCheck(): Promise<boolean>;
}
export declare class AzureCosmosDBAdapter extends CloudDatabaseAdapter {
    private client;
    constructor(config: {
        endpoint: string;
        key?: string;
        database: string;
    });
    private initializeClient;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    execute(operation: CloudOperation): Promise<any>;
    private simulateCosmosDBOperation;
    healthCheck(): Promise<boolean>;
}
export declare class GCPSpannerAdapter extends CloudDatabaseAdapter {
    private client;
    constructor(config: {
        projectId: string;
        instanceId: string;
        databaseId: string;
        keyFilename?: string;
    });
    private initializeClient;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    execute(operation: CloudOperation): Promise<any>;
    private simulateSpannerOperation;
    healthCheck(): Promise<boolean>;
}
export declare class CloudDatabaseManager extends EventEmitter {
    private adapters;
    private activeConnections;
    constructor();
    private initializeAdapters;
    executeOnCloud(cloud: string, operation: CloudOperation): Promise<any>;
    getAllCloudMetrics(): Promise<Map<string, any>>;
    healthCheckAll(): Promise<Map<string, boolean>>;
    getAvailableClouds(): string[];
}
export declare const cloudDatabaseManager: CloudDatabaseManager;
export {};
//# sourceMappingURL=CloudDatabaseAdapters.d.ts.map