import { Db } from 'mongodb';
import type { Context } from '../context.js';
type Middleware = (ctx: Context, next: () => Promise<unknown>) => unknown;
interface DatabaseConfig {
    type: 'mongodb' | 'mysql' | 'postgresql' | 'redis' | 'sqlite' | 'mssql' | 'oracle' | 'cassandra' | 'elasticsearch' | 'dynamodb' | 'firebase';
    connection: string | Record<string, unknown>;
    pool?: {
        min?: number;
        max?: number;
        idleTimeoutMillis?: number;
        connectionTimeoutMillis?: number;
    };
    multiTenant?: boolean;
    tenantKey?: string;
    debug?: boolean;
    encryptionKey?: string;
    enableQueryLogging?: boolean;
    enableAuditLog?: boolean;
    maxQueryTime?: number;
}
interface DatabaseConnection {
    type: string;
    client: unknown;
    pool?: unknown;
    multiTenant: boolean;
    encryptionKey?: string;
    queryLogging?: boolean;
    auditLog?: boolean;
}
declare const DB_SECURITY_CONFIG: {
    encryption: {
        algorithm: string;
        keyLength: number;
        ivLength: number;
    };
    sensitiveFields: string[];
    maxQueryLogSize: number;
    enableAuditLog: boolean;
    maxQueryTime: number;
    enableEncryption: boolean;
};
declare const queryLog: Array<{
    timestamp: number;
    connection: string;
    operation: string;
    table?: string;
    collection?: string;
    query?: string;
    duration: number;
    success: boolean;
    clientIP?: string;
    userId?: string;
    error?: string;
}>;
/**
 * Advanced database plugin with connection pooling and multi-tenancy
 *
 * Features:
 * - Connection pooling for optimal performance
 * - Multi-tenant database isolation
 * - Automatic reconnection
 * - Query performance monitoring
 * - Transaction support
 * - Type-safe query builders
 */
export declare function database(name: string, config: DatabaseConfig): Middleware;
/**
 * Type-safe query builder for MongoDB
 */
export interface IMongoQueryBuilder<T = unknown> {
    find(filter?: Partial<T>): Promise<T[]>;
    findOne(filter: Partial<T>): Promise<T | null>;
    insertOne(doc: unknown): Promise<unknown>;
    updateOne(filter: Partial<T>, update: Partial<T>): Promise<unknown>;
    deleteOne(filter: Partial<T>): Promise<unknown>;
    aggregate(pipeline: unknown[]): Promise<unknown[]>;
}
export declare class MongoQueryBuilder<T = unknown> implements IMongoQueryBuilder<T> {
    private db;
    private collection;
    constructor(db: Db, collection: string);
    find(filter?: Partial<T>): Promise<T[]>;
    findOne(filter: Partial<T>): Promise<T | null>;
    insertOne(doc: unknown): Promise<unknown>;
    insertMany(docs: unknown[]): Promise<unknown>;
    updateOne(filter: Partial<T>, update: Partial<T>): Promise<unknown>;
    deleteOne(filter: Partial<T>): Promise<unknown>;
    aggregate(pipeline: unknown[]): Promise<unknown[]>;
}
/**
 * Type-safe query builder for SQL databases
 */
export interface ISQLQueryBuilder<T = unknown> {
    find(where?: Partial<T>): Promise<T[]>;
    findOne(where: Partial<T>): Promise<T | null>;
    insert(data: Partial<T>): Promise<unknown>;
    update(where: Partial<T>, data: Partial<T>): Promise<unknown>;
    delete(where: Partial<T>): Promise<unknown>;
    raw(query: string, values?: unknown[]): Promise<unknown>;
}
export declare class SQLQueryBuilder<T = unknown> implements ISQLQueryBuilder<T> {
    private pool;
    private table;
    private connectionName?;
    private encryptionKey?;
    constructor(pool: unknown, table: string, connectionName?: string | undefined, encryptionKey?: string | undefined);
    /**
     * Validate table name to prevent SQL injection
     */
    private validateTableName;
    /**
     * Safely quote identifier (table or column name)
     */
    private quoteIdentifier;
    find(where?: Partial<T>): Promise<T[]>;
    findOne(where: Partial<T>): Promise<T | null>;
    insert(data: Partial<T>): Promise<unknown>;
    update(where: Partial<T>, data: Partial<T>): Promise<unknown>;
    delete(where: Partial<T>): Promise<unknown>;
    raw(query: string, values?: unknown[]): Promise<unknown>;
    private encryptSensitiveFields;
    private decryptSensitiveFields;
}
/**
 * Cassandra query builder
 */
export interface ICassandraQueryBuilder<T = unknown> {
    find(keyspace: string, table: string, where?: Partial<T>): Promise<T[]>;
    findOne(keyspace: string, table: string, where: Partial<T>): Promise<T | null>;
    insert(keyspace: string, table: string, data: Partial<T>): Promise<unknown>;
    update(keyspace: string, table: string, where: Partial<T>, data: Partial<T>): Promise<unknown>;
    delete(keyspace: string, table: string, where: Partial<T>): Promise<unknown>;
}
export declare class CassandraQueryBuilder<T = unknown> implements ICassandraQueryBuilder<T> {
    private client;
    constructor(client: unknown);
    /**
     * Validate identifier to prevent injection
     */
    private validateIdentifier;
    /**
     * Safely quote identifier (keyspace or table name)
     */
    private quoteIdentifier;
    find(keyspace: string, table: string, where?: Partial<T>): Promise<T[]>;
    findOne(keyspace: string, table: string, where: Partial<T>): Promise<T | null>;
    insert(keyspace: string, table: string, data: Partial<T>): Promise<unknown>;
    update(keyspace: string, table: string, where: Partial<T>, data: Partial<T>): Promise<unknown>;
    delete(keyspace: string, table: string, where: Partial<T>): Promise<unknown>;
}
/**
 * Elasticsearch query builder
 */
export interface IElasticsearchQueryBuilder<T = unknown> {
    search(index: string, query?: Record<string, unknown>): Promise<T[]>;
    get(index: string, id: string): Promise<T | null>;
    index(index: string, document: T): Promise<unknown>;
    update(index: string, id: string, document: Partial<T>): Promise<unknown>;
    delete(index: string, id: string): Promise<unknown>;
}
export declare class ElasticsearchQueryBuilder<T = unknown> implements IElasticsearchQueryBuilder<T> {
    private client;
    constructor(client: unknown);
    search(index: string, query?: Record<string, unknown>): Promise<T[]>;
    get(index: string, id: string): Promise<T | null>;
    index(index: string, document: T): Promise<unknown>;
    update(index: string, id: string, document: Partial<T>): Promise<unknown>;
    delete(index: string, id: string): Promise<unknown>;
}
/**
 * DynamoDB query builder
 */
export interface IDynamoDBQueryBuilder<T = unknown> {
    scan(tableName: string): Promise<T[]>;
    query(tableName: string, keyCondition: Record<string, unknown>): Promise<T[]>;
    get(tableName: string, key: Record<string, unknown>): Promise<T | null>;
    put(tableName: string, item: T): Promise<unknown>;
    update(tableName: string, key: Record<string, unknown>, updateExpression: string, expressionAttributeValues: Record<string, unknown>): Promise<unknown>;
    delete(tableName: string, key: Record<string, unknown>): Promise<unknown>;
}
export declare class DynamoDBQueryBuilder<T = unknown> implements IDynamoDBQueryBuilder<T> {
    private client;
    constructor(client: unknown);
    scan(tableName: string): Promise<T[]>;
    query(tableName: string, keyCondition: Record<string, unknown>): Promise<T[]>;
    get(tableName: string, key: Record<string, unknown>): Promise<T | null>;
    put(tableName: string, item: T): Promise<unknown>;
    update(tableName: string, key: Record<string, unknown>, updateExpression: string, expressionAttributeValues: Record<string, unknown>): Promise<unknown>;
    delete(tableName: string, key: Record<string, unknown>): Promise<unknown>;
}
/**
 * Firebase query builder
 */
export interface IFirebaseQueryBuilder<T = unknown> {
    get(collection: string, docId?: string): Promise<T | T[] | null>;
    set(collection: string, docId: string, data: T): Promise<unknown>;
    update(collection: string, docId: string, data: Partial<T>): Promise<unknown>;
    delete(collection: string, docId: string): Promise<unknown>;
    query(collection: string, where?: [string, any, any][]): Promise<T[]>;
}
export declare class FirebaseQueryBuilder<T = unknown> implements IFirebaseQueryBuilder<T> {
    private db;
    constructor(db: unknown);
    get(collection: string, docId?: string): Promise<T | T[] | null>;
    set(collection: string, docId: string, data: T): Promise<unknown>;
    update(collection: string, docId: string, data: Partial<T>): Promise<unknown>;
    delete(collection: string, docId: string): Promise<unknown>;
    query(collection: string, where?: [string, any, any][]): Promise<T[]>;
}
/**
 * Redis cache adapter
 */
export interface IRedisCache {
    get<T = unknown>(key: string): Promise<T | null>;
    set(key: string, value: unknown, ttl?: number): Promise<void>;
    delete(key: string): Promise<void>;
    exists(key: string): Promise<boolean>;
    increment(key: string): Promise<number>;
    expire(key: string, seconds: number): Promise<void>;
    keys(pattern: string): Promise<string[]>;
    flushAll(): Promise<void>;
}
export declare class RedisCache implements IRedisCache {
    private client;
    constructor(client: unknown);
    get<T = unknown>(key: string): Promise<T | null>;
    set(key: string, value: unknown, ttl?: number): Promise<void>;
    delete(key: string): Promise<void>;
    exists(key: string): Promise<boolean>;
    increment(key: string): Promise<number>;
    expire(key: string, seconds: number): Promise<void>;
    keys(pattern: string): Promise<string[]>;
    flushAll(): Promise<void>;
}
/**
 * Close all database connections
 */
export declare function closeAllConnections(): Promise<void>;
export declare function getQueryLogs(limit?: number): typeof queryLog;
export declare function clearQueryLogs(): void;
export declare function getSecurityConfig(): typeof DB_SECURITY_CONFIG;
export declare function healthCheck(connectionName: string): Promise<{
    status: 'healthy' | 'unhealthy';
    latency: number;
    connections?: number;
    error?: string;
}>;
export { type DatabaseConfig, type DatabaseConnection };
//# sourceMappingURL=database.d.ts.map