@db-bridge/core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2433 @@
+import { EventEmitter } from 'eventemitter3';
+
+declare const __brand: unique symbol;
+type Brand<T, B> = T & {
+    [__brand]: B;
+};
+type SafeSQL = Brand<string, 'SafeSQL'>;
+type TableName = Brand<string, 'TableName'>;
+type ColumnName = Brand<string, 'ColumnName'>;
+declare function sql(strings: TemplateStringsArray, ..._values: unknown[]): SafeSQL;
+interface HostConnectionConfig {
+    type: 'host';
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+    ssl?: SSLConfig;
+    pool?: StrictPoolConfig;
+}
+interface ConnectionStringConfig {
+    type: 'connectionString';
+    connectionString: string;
+    ssl?: SSLConfig;
+    pool?: StrictPoolConfig;
+}
+type StrictConnectionConfig = HostConnectionConfig | ConnectionStringConfig;
+interface SSLConfig {
+    enabled: boolean;
+    rejectUnauthorized?: boolean;
+    ca?: string | Buffer;
+    cert?: string | Buffer;
+    key?: string | Buffer;
+}
+interface StrictPoolConfig {
+    min: number;
+    max: number;
+    acquireTimeout: number;
+    idleTimeout: number;
+    validateOnBorrow?: boolean;
+    maxLifetime?: number;
+}
+interface BaseQueryResult {
+    duration: number;
+    command: SQLCommand;
+}
+interface SelectResult<T> extends BaseQueryResult {
+    command: 'SELECT';
+    rows: T[];
+    rowCount: number;
+    fields: StrictFieldInfo[];
+}
+interface InsertResult extends BaseQueryResult {
+    command: 'INSERT';
+    insertId: number | bigint;
+    affectedRows: number;
+}
+interface UpdateResult extends BaseQueryResult {
+    command: 'UPDATE';
+    affectedRows: number;
+    changedRows: number;
+}
+interface DeleteResult extends BaseQueryResult {
+    command: 'DELETE';
+    affectedRows: number;
+}
+type StrictQueryResult<T = unknown> = SelectResult<T> | InsertResult | UpdateResult | DeleteResult;
+type SQLCommand = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'CREATE' | 'ALTER' | 'DROP' | 'TRUNCATE' | 'BEGIN' | 'COMMIT' | 'ROLLBACK';
+type FieldType = 'varchar' | 'char' | 'text' | 'mediumtext' | 'longtext' | 'enum' | 'set' | 'int' | 'tinyint' | 'smallint' | 'mediumint' | 'bigint' | 'decimal' | 'float' | 'double' | 'numeric' | 'date' | 'datetime' | 'timestamp' | 'time' | 'year' | 'blob' | 'binary' | 'varbinary' | 'json' | 'jsonb' | 'uuid' | 'boolean' | 'bool' | 'unknown';
+interface StrictFieldInfo {
+    name: string;
+    type: FieldType;
+    nullable: boolean;
+    primaryKey: boolean;
+    autoIncrement: boolean;
+    defaultValue: unknown;
+    maxLength?: number;
+    precision?: number;
+    scale?: number;
+}
+type ComparisonOperator = '=' | '!=' | '<>' | '>' | '<' | '>=' | '<=';
+type LikeOperator = 'LIKE' | 'NOT LIKE' | 'ILIKE';
+type NullOperator = 'IS NULL' | 'IS NOT NULL';
+type InOperator = 'IN' | 'NOT IN';
+type BetweenOperator = 'BETWEEN' | 'NOT BETWEEN';
+type WhereOperator = ComparisonOperator | LikeOperator | NullOperator | InOperator | BetweenOperator;
+type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS';
+type OrderDirection = 'ASC' | 'DESC';
+type AggregateFunction = 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX';
+interface TableSchema<T extends Record<string, unknown>> {
+    name: TableName;
+    columns: {
+        [K in keyof T]: ColumnDefinition<T[K]>;
+    };
+    primaryKey: keyof T;
+}
+interface ColumnDefinition<T> {
+    type: FieldType;
+    nullable: boolean;
+    defaultValue?: T;
+    autoIncrement?: boolean;
+}
+type ExtractRow<T> = T extends SelectResult<infer R> ? R : never;
+type RequireKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
+type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type InsertData<T, AutoFields extends keyof T = never> = Omit<T, AutoFields>;
+type UpdateData<T, IdField extends keyof T> = Partial<Omit<T, IdField>> & Pick<T, IdField>;
+type Nullable<T> = T | null;
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+type DeepRequired<T> = {
+    [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
+};
+declare function isSelectResult<T>(result: StrictQueryResult<T>): result is SelectResult<T>;
+declare function isInsertResult(result: StrictQueryResult): result is InsertResult;
+declare function isUpdateResult(result: StrictQueryResult): result is UpdateResult;
+declare function isDeleteResult(result: StrictQueryResult): result is DeleteResult;
+declare const DEFAULT_POOL_CONFIG: StrictPoolConfig;
+declare const DEFAULT_TIMEOUTS: {
+    readonly connection: 10000;
+    readonly query: 30000;
+    readonly transaction: 60000;
+};
+declare const ISOLATION_LEVELS: {
+    readonly READ_UNCOMMITTED: "READ UNCOMMITTED";
+    readonly READ_COMMITTED: "READ COMMITTED";
+    readonly REPEATABLE_READ: "REPEATABLE READ";
+    readonly SERIALIZABLE: "SERIALIZABLE";
+};
+type StrictIsolationLevel = (typeof ISOLATION_LEVELS)[keyof typeof ISOLATION_LEVELS];
+
+interface ConnectionConfig {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    connectionString?: string;
+    ssl?: boolean | Record<string, unknown>;
+    poolSize?: number;
+    pool?: PoolConfig;
+    connectionTimeout?: number;
+    idleTimeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+    readonly?: boolean;
+}
+interface PoolConfig {
+    min?: number;
+    max?: number;
+    acquireTimeout?: number;
+    idleTimeout?: number;
+    validateOnBorrow?: boolean;
+    maxLifetime?: number;
+    queueLimit?: number;
+    queryTimeout?: number;
+    enableKeepAlive?: boolean;
+    keepAliveInitialDelay?: number;
+}
+interface QueryResult<T = unknown> {
+    rows: T[];
+    rowCount: number;
+    affectedRows?: number;
+    insertId?: number;
+    fields?: FieldInfo[];
+    command?: string;
+    duration?: number;
+}
+interface FieldInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+    defaultValue?: unknown;
+}
+interface TransactionOptions {
+    isolationLevel?: IsolationLevel;
+    readOnly?: boolean;
+    deferrable?: boolean;
+}
+declare enum IsolationLevel {
+    READ_UNCOMMITTED = "READ UNCOMMITTED",
+    READ_COMMITTED = "READ COMMITTED",
+    REPEATABLE_READ = "REPEATABLE READ",
+    SERIALIZABLE = "SERIALIZABLE"
+}
+interface PreparedStatement<T = unknown> {
+    execute(params?: unknown[]): Promise<QueryResult<T>>;
+    release(): Promise<void>;
+    close(): Promise<void>;
+}
+interface CacheOptions$1 {
+    ttl?: number;
+    key?: string;
+    invalidateOn?: string[];
+    compress?: boolean;
+}
+interface QueryOptions {
+    cache?: boolean | CacheOptions$1;
+    timeout?: number;
+    prepare?: boolean;
+    transaction?: Transaction;
+}
+interface Transaction {
+    id: string;
+    isActive: boolean;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    savepoint(name: string): Promise<void>;
+    releaseSavepoint(name: string): Promise<void>;
+    rollbackToSavepoint(name: string): Promise<void>;
+    query<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    execute<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+}
+interface PoolStats {
+    total: number;
+    idle: number;
+    waiting: number;
+    active: number;
+}
+type QueryValue = string | number | boolean | Date | Buffer | null | undefined;
+type QueryParams = QueryValue[] | Record<string, QueryValue>;
+interface LogLevel {
+    ERROR: 'error';
+    WARN: 'warn';
+    INFO: 'info';
+    DEBUG: 'debug';
+}
+interface Logger {
+    error(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+}
+
+declare const CONNECTION_DEFAULTS: {
+    readonly MYSQL_PORT: 3306;
+    readonly POSTGRESQL_PORT: 5432;
+    readonly REDIS_PORT: 6379;
+    readonly MONGODB_PORT: 27017;
+    readonly CONNECTION_TIMEOUT: 10000;
+    readonly IDLE_TIMEOUT: 300000;
+    readonly MAX_PORT: 65535;
+    readonly MIN_PORT: 1;
+};
+declare const POOL_DEFAULTS_LEGACY: {
+    readonly MIN_CONNECTIONS: 2;
+    readonly MAX_CONNECTIONS: 10;
+    readonly ACQUIRE_TIMEOUT: 30000;
+    readonly IDLE_TIMEOUT: 60000;
+    readonly MAX_LIFETIME: 1800000;
+    readonly QUEUE_LIMIT: 0;
+};
+declare const POOL_DEFAULTS: {
+    readonly min: 0;
+    readonly max: 10;
+    readonly acquireTimeout: 30000;
+    readonly idleTimeout: 60000;
+    readonly queueLimit: 100;
+    readonly queryTimeout: 30000;
+};
+declare const QUERY_DEFAULTS: {
+    readonly TIMEOUT: 30000;
+    readonly TRANSACTION_TIMEOUT: 60000;
+    readonly SLOW_QUERY_THRESHOLD: 1000;
+    readonly MAX_TRACES: 10000;
+    readonly VERY_SLOW_QUERY_THRESHOLD: 2000;
+    readonly SLOW_TRANSACTION_THRESHOLD: 5000;
+};
+declare const CACHE_DEFAULTS: {
+    readonly TTL_SECONDS: 3600;
+    readonly TTL_MS: 3600000;
+    readonly ERROR_TTL_SECONDS: 60;
+    readonly CLEANUP_INTERVAL: 60000;
+    readonly MAX_ENTRY_SIZE: number;
+    readonly COMPRESSION_THRESHOLD: 1024;
+    readonly MAX_LATENCIES: 1000;
+};
+declare const RETRY_DEFAULTS: {
+    readonly MAX_RETRIES: 3;
+    readonly BASE_DELAY: 1000;
+    readonly MAX_DELAY: 30000;
+    readonly BACKOFF_MULTIPLIER: 2;
+    readonly CIRCUIT_BREAKER_THRESHOLD: 5;
+    readonly CIRCUIT_BREAKER_RESET: 30000;
+};
+declare const CRYPTO_DEFAULTS: {
+    readonly ALGORITHM: "aes-256-gcm";
+    readonly KEY_LENGTH: 32;
+    readonly IV_LENGTH: 16;
+    readonly CHACHA_IV_LENGTH: 12;
+    readonly SALT_LENGTH: 32;
+    readonly ITERATIONS: 100000;
+    readonly DIGEST: "sha256";
+};
+declare const HEALTH_DEFAULTS: {
+    readonly CHECK_INTERVAL: 30000;
+    readonly CHECK_TIMEOUT: 5000;
+    readonly MAX_WAIT_TIME: 60000;
+    readonly WAIT_INTERVAL: 1000;
+};
+declare const LOGGING_DEFAULTS: {
+    readonly SLOW_QUERY_THRESHOLD: 1000;
+    readonly MAX_SQL_LENGTH: 200;
+    readonly MAX_PARAMS_LENGTH: 100;
+};
+declare const DURATION_BUCKETS: readonly [10, 50, 100, 250, 500, 1000, 2500, 5000, 10000];
+declare const ANALYSIS_DEFAULTS: {
+    readonly WINDOW: 3600000;
+    readonly WARMUP_DELAY: 1000;
+};
+declare const TIME_UNITS: {
+    readonly MS_PER_SECOND: 1000;
+    readonly MS_PER_MINUTE: 60000;
+    readonly MS_PER_HOUR: 3600000;
+    readonly SECONDS_PER_MINUTE: 60;
+    readonly SECONDS_PER_HOUR: 3600;
+};
+declare const SIZE_UNITS: {
+    readonly BYTES_PER_KB: 1024;
+    readonly BYTES_PER_MB: number;
+    readonly BYTES_PER_GB: number;
+};
+
+interface PaginationResult<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        perPage: number;
+        total: number;
+        totalPages: number;
+        hasMore: boolean;
+        from: number;
+        to: number;
+    };
+}
+interface CursorPaginationResult<T> {
+    data: T[];
+    nextCursor: number | string | null;
+    hasMore: boolean;
+}
+interface QueryBuilder<T = unknown> {
+    select(...columns: string[]): QueryBuilder<T>;
+    select(columns: string[]): QueryBuilder<T>;
+    from(table: string, alias?: string): QueryBuilder<T>;
+    table(table: string, alias?: string): QueryBuilder<T>;
+    distinct(): QueryBuilder<T>;
+    join(table: string, on: string, type?: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL'): QueryBuilder<T>;
+    innerJoin(table: string, on: string): QueryBuilder<T>;
+    leftJoin(table: string, on: string): QueryBuilder<T>;
+    rightJoin(table: string, on: string): QueryBuilder<T>;
+    fullJoin(table: string, on: string): QueryBuilder<T>;
+    where(condition: string | Record<string, unknown>, operator?: string, value?: unknown): QueryBuilder<T>;
+    where(column: string, operator: string, value: unknown): QueryBuilder<T>;
+    whereIn(column: string, values: unknown[]): QueryBuilder<T>;
+    whereNotIn(column: string, values: unknown[]): QueryBuilder<T>;
+    whereBetween(column: string, min: unknown, max: unknown): QueryBuilder<T>;
+    whereNull(column: string): QueryBuilder<T>;
+    whereNotNull(column: string): QueryBuilder<T>;
+    orWhere(condition: string | Record<string, unknown>, operator?: string, value?: unknown): QueryBuilder<T>;
+    orWhere(column: string, operator: string, value: unknown): QueryBuilder<T>;
+    whereDate(column: string, operator: string, date: Date | string): QueryBuilder<T>;
+    whereYear(column: string, operator: string, year: number): QueryBuilder<T>;
+    whereMonth(column: string, operator: string, month: number): QueryBuilder<T>;
+    whereDay(column: string, operator: string, day: number): QueryBuilder<T>;
+    whereToday(column: string): QueryBuilder<T>;
+    whereYesterday(column: string): QueryBuilder<T>;
+    whereBetweenDates(column: string, startDate: Date | string, endDate: Date | string): QueryBuilder<T>;
+    whereLastDays(column: string, days: number): QueryBuilder<T>;
+    groupBy(...columns: string[]): QueryBuilder<T>;
+    having(condition: string): QueryBuilder<T>;
+    orderBy(column: string, direction?: 'ASC' | 'DESC'): QueryBuilder<T>;
+    limit(limit: number): QueryBuilder<T>;
+    offset(offset: number): QueryBuilder<T>;
+    insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): QueryBuilder<T>;
+    update(table: string, data: Record<string, unknown>): QueryBuilder<T>;
+    delete(table: string): QueryBuilder<T>;
+    raw(sql: string, bindings?: unknown[]): QueryBuilder<T>;
+    encrypt(...fields: string[]): QueryBuilder<T>;
+    decrypt(...fields: string[]): QueryBuilder<T>;
+    toSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+    execute(options?: QueryOptions): Promise<QueryResult<T>>;
+    first(options?: QueryOptions): Promise<T | null>;
+    count(column?: string, options?: QueryOptions): Promise<number>;
+    sum(column: string, options?: QueryOptions): Promise<number>;
+    avg(column: string, options?: QueryOptions): Promise<number>;
+    min(column: string, options?: QueryOptions): Promise<number | null>;
+    max(column: string, options?: QueryOptions): Promise<number | null>;
+    exists(options?: QueryOptions): Promise<boolean>;
+    paginate(page?: number, perPage?: number, options?: QueryOptions): Promise<PaginationResult<T>>;
+    cursorPaginate(cursorColumn: string, cursor?: number | string | null, limit?: number, options?: QueryOptions): Promise<CursorPaginationResult<T>>;
+    pluck<K = unknown>(column: string, options?: QueryOptions): Promise<K[]>;
+    value<K = unknown>(column: string, options?: QueryOptions): Promise<K | null>;
+    chunk(size: number, callback: (items: T[], page: number) => Promise<void | false>, options?: QueryOptions): Promise<void>;
+}
+
+interface DatabaseAdapter {
+    readonly name: string;
+    readonly version: string;
+    readonly isConnected: boolean;
+    connect(config: ConnectionConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    execute<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    prepare<T = unknown>(sql: string, name?: string): Promise<PreparedStatement<T>>;
+    beginTransaction(options?: TransactionOptions): Promise<Transaction>;
+    getPoolStats(): PoolStats;
+    ping(): Promise<boolean>;
+    escape(value: unknown): string;
+    escapeIdentifier(identifier: string): string;
+    createQueryBuilder<T = unknown>(): QueryBuilder<T>;
+}
+
+interface CacheAdapter {
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    exists(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    mget<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    mset<T = unknown>(items: Array<{
+        key: string;
+        value: T;
+        ttl?: number;
+    }>): Promise<void>;
+    keys(pattern?: string): Promise<string[]>;
+    ttl(key: string): Promise<number>;
+    expire(key: string, ttl: number): Promise<boolean>;
+    increment(key: string, value?: number): Promise<number>;
+    decrement(key: string, value?: number): Promise<number>;
+}
+
+declare class DatabaseError extends Error {
+    code?: string | undefined;
+    cause?: Error | undefined;
+    constructor(message: string, code?: string | undefined, cause?: Error | undefined);
+}
+declare class DBBridgeError extends DatabaseError {
+    code?: string | undefined;
+    cause?: Error | undefined;
+    constructor(message: string, code?: string | undefined, cause?: Error | undefined);
+}
+declare class ConnectionError extends DBBridgeError {
+    constructor(message: string, cause?: Error);
+}
+declare class QueryError extends DBBridgeError {
+    sql?: string | undefined;
+    params?: unknown[] | undefined;
+    constructor(message: string, sql?: string | undefined, params?: unknown[] | undefined, cause?: Error);
+}
+declare class TransactionError extends DBBridgeError {
+    transactionId?: string | undefined;
+    constructor(message: string, transactionId?: string | undefined, cause?: Error);
+}
+declare class TimeoutError extends DBBridgeError {
+    timeout?: number | undefined;
+    constructor(message: string, timeout?: number | undefined, cause?: Error);
+}
+declare class QueryTimeoutError extends TimeoutError {
+    sql: string;
+    timeoutMs: number;
+    constructor(sql: string, timeoutMs: number, cause?: Error);
+}
+declare class PoolExhaustedError extends ConnectionError {
+    poolStats: {
+        active: number;
+        waiting: number;
+        max: number;
+    };
+    waitTimeMs?: number | undefined;
+    constructor(poolStats: {
+        active: number;
+        waiting: number;
+        max: number;
+    }, waitTimeMs?: number | undefined, cause?: Error);
+}
+declare class ValidationError extends DBBridgeError {
+    field?: string | undefined;
+    constructor(message: string, field?: string | undefined, cause?: Error);
+}
+declare class CacheError extends DBBridgeError {
+    key?: string | undefined;
+    constructor(message: string, key?: string | undefined, cause?: Error);
+}
+declare class NotImplementedError extends DBBridgeError {
+    constructor(feature: string);
+}
+
+interface RetryOptions {
+    maxRetries: number;
+    retryDelay: number;
+    backoffMultiplier?: number;
+    maxRetryDelay?: number;
+    shouldRetry?: (error: Error) => boolean;
+}
+declare function retry<T>(fn: () => Promise<T>, options?: Partial<RetryOptions>): Promise<T>;
+declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message?: string): Promise<T>;
+
+declare function validateConnectionConfig(config: ConnectionConfig): void;
+declare function validateSQL(sql: string): void;
+declare function validateTableName(tableName: string): void;
+declare function validateColumnName(columnName: string): void;
+
+declare function generateCacheKey(sql: string, params?: unknown[], prefix?: string): string;
+declare function parseCacheKey(key: string): {
+    prefix: string;
+    hash: string;
+} | null;
+declare function createCacheKeyPattern(prefix?: string, pattern?: string): string;
+declare function sanitizeCacheKey(key: string): string;
+
+declare function generateUUID(): string;
+
+interface CompressionOptions {
+    threshold?: number;
+    level?: number;
+}
+declare function compress(data: string, options?: CompressionOptions): string;
+declare function decompress(data: string): string;
+declare function isCompressed(data: string): boolean;
+declare function getCompressionRatio(original: string, compressed: string): number;
+declare function shouldCompress(data: string, threshold?: 1024): boolean;
+
+interface CryptoConfig {
+    algorithm?: string;
+    keyLength?: number;
+    ivLength?: number;
+    saltLength?: number;
+    iterations?: number;
+    digest?: string;
+}
+interface EncryptionOptions {
+    key?: string;
+    salt?: Buffer;
+    encoding?: BufferEncoding;
+}
+interface EncryptedData {
+    encrypted: string;
+    salt: string;
+    iv: string;
+    authTag?: string;
+}
+declare class CryptoProvider {
+    private readonly config;
+    constructor(config?: CryptoConfig);
+    private deriveKey;
+    encrypt(data: string, options?: EncryptionOptions): EncryptedData;
+    decrypt(encryptedData: EncryptedData, options?: EncryptionOptions): string;
+    encryptField(value: unknown): string;
+    decryptField(encryptedField: string): unknown;
+    generateKey(): string;
+    hash(value: string): string;
+    compareHash(value: string, hash: string): boolean;
+}
+declare const crypto: CryptoProvider;
+declare const CryptoAlgorithms: {
+    readonly AES_256_GCM: "aes-256-gcm";
+    readonly AES_256_CBC: "aes-256-cbc";
+    readonly AES_192_GCM: "aes-192-gcm";
+    readonly AES_192_CBC: "aes-192-cbc";
+    readonly AES_128_GCM: "aes-128-gcm";
+    readonly AES_128_CBC: "aes-128-cbc";
+    readonly CHACHA20_POLY1305: "chacha20-poly1305";
+};
+type CryptoAlgorithm = (typeof CryptoAlgorithms)[keyof typeof CryptoAlgorithms];
+
+interface BaseAdapterOptions {
+    logger?: Logger;
+    cache?: CacheAdapter;
+    crypto?: CryptoProvider;
+    retryOptions?: {
+        maxRetries?: number;
+        retryDelay?: number;
+    };
+}
+declare abstract class BaseAdapter extends EventEmitter implements DatabaseAdapter {
+    protected config?: ConnectionConfig;
+    protected logger?: Logger;
+    protected cache?: CacheAdapter;
+    protected crypto?: CryptoProvider;
+    protected _isConnected: boolean;
+    protected retryOptions: {
+        maxRetries: number;
+        retryDelay: number;
+    };
+    abstract readonly name: string;
+    abstract readonly version: string;
+    get isConnected(): boolean;
+    constructor(options?: BaseAdapterOptions);
+    connect(config: ConnectionConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    execute<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    executeBatch<T = unknown>(sql: string, paramSets: QueryParams[], options?: QueryOptions): Promise<QueryResult<T>[]>;
+    prepare<T = unknown>(_sql: string, _name?: string): Promise<PreparedStatement<T>>;
+    beginTransaction(_options?: TransactionOptions): Promise<Transaction>;
+    getPoolStats(): PoolStats;
+    ping(): Promise<boolean>;
+    escape(_value: unknown): string;
+    escapeIdentifier(_identifier: string): string;
+    abstract createQueryBuilder<T = unknown>(): QueryBuilder<T>;
+    protected abstract doConnect(config: ConnectionConfig): Promise<void>;
+    protected abstract doDisconnect(): Promise<void>;
+    protected abstract doQuery<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    private getCacheKey;
+}
+
+interface QueryBuilderOptions {
+    adapter: DatabaseAdapter;
+    escapeIdentifier?: (identifier: string) => string;
+    parameterPlaceholder?: (index: number) => string;
+    crypto?: CryptoProvider;
+}
+interface WhereClause {
+    type: 'AND' | 'OR';
+    condition: string;
+    bindings: unknown[];
+}
+interface JoinClause {
+    type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
+    table: string;
+    on: string;
+}
+interface OrderByClause {
+    column: string;
+    direction: 'ASC' | 'DESC';
+}
+interface QueryState {
+    selectColumns: string[];
+    fromTable?: string;
+    fromAlias?: string;
+    joins: JoinClause[];
+    whereClauses: WhereClause[];
+    groupByColumns: string[];
+    havingClause?: string;
+    orderByColumns: OrderByClause[];
+    limitValue?: number;
+    offsetValue?: number;
+    bindings: unknown[];
+    isDistinct: boolean;
+    insertTable?: string;
+    insertData?: Record<string, unknown> | Record<string, unknown>[];
+    updateTable?: string;
+    updateData?: Record<string, unknown>;
+    deleteTable?: string;
+    rawSql?: string;
+    rawBindings?: unknown[];
+    encryptedFields: Set<string>;
+    decryptedFields: Set<string>;
+}
+declare function createQueryState(): QueryState;
+
+declare abstract class BaseQueryBuilder<T = unknown> implements QueryBuilder<T> {
+    protected adapter: DatabaseAdapter;
+    protected escapeIdentifierFn: (identifier: string) => string;
+    protected parameterPlaceholderFn: (index: number) => string;
+    protected crypto?: CryptoProvider;
+    protected encryptedFields: Set<string>;
+    protected decryptedFields: Set<string>;
+    protected selectColumns: string[];
+    protected fromTable?: string;
+    protected fromAlias?: string;
+    protected joins: JoinClause[];
+    protected whereClauses: WhereClause[];
+    protected groupByColumns: string[];
+    protected havingClause?: string;
+    protected orderByColumns: Array<{
+        column: string;
+        direction: 'ASC' | 'DESC';
+    }>;
+    protected limitValue?: number;
+    protected offsetValue?: number;
+    protected bindings: unknown[];
+    protected isDistinct: boolean;
+    protected insertTable?: string;
+    protected insertData?: Record<string, unknown> | Record<string, unknown>[];
+    protected updateTable?: string;
+    protected updateData?: Record<string, unknown>;
+    protected deleteTable?: string;
+    protected rawSql?: string;
+    protected rawBindings?: unknown[];
+    constructor(options: QueryBuilderOptions);
+    select(...columns: string[]): QueryBuilder<T>;
+    select(columns: string[]): QueryBuilder<T>;
+    from(table: string, alias?: string): QueryBuilder<T>;
+    table(table: string, alias?: string): QueryBuilder<T>;
+    distinct(): QueryBuilder<T>;
+    join(table: string, on: string, type?: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL'): QueryBuilder<T>;
+    innerJoin(table: string, on: string): QueryBuilder<T>;
+    leftJoin(table: string, on: string): QueryBuilder<T>;
+    rightJoin(table: string, on: string): QueryBuilder<T>;
+    fullJoin(table: string, on: string): QueryBuilder<T>;
+    where(condition: string | Record<string, unknown>, operator?: string, value?: unknown): QueryBuilder<T>;
+    where(column: string, operator: string, value: unknown): QueryBuilder<T>;
+    orWhere(condition: string | Record<string, unknown>, operator?: string, value?: unknown): QueryBuilder<T>;
+    orWhere(column: string, operator: string, value: unknown): QueryBuilder<T>;
+    whereIn(column: string, values: unknown[]): QueryBuilder<T>;
+    whereNotIn(column: string, values: unknown[]): QueryBuilder<T>;
+    whereBetween(column: string, min: unknown, max: unknown): QueryBuilder<T>;
+    whereNull(column: string): QueryBuilder<T>;
+    whereNotNull(column: string): QueryBuilder<T>;
+    whereDate(column: string, operator: string, date: Date | string): QueryBuilder<T>;
+    whereYear(column: string, operator: string, year: number): QueryBuilder<T>;
+    whereMonth(column: string, operator: string, month: number): QueryBuilder<T>;
+    whereDay(column: string, operator: string, day: number): QueryBuilder<T>;
+    whereToday(column: string): QueryBuilder<T>;
+    whereYesterday(column: string): QueryBuilder<T>;
+    whereBetweenDates(column: string, startDate: Date | string, endDate: Date | string): QueryBuilder<T>;
+    whereLastDays(column: string, days: number): QueryBuilder<T>;
+    private getDateFilterContext;
+    groupBy(...columns: string[]): QueryBuilder<T>;
+    having(condition: string): QueryBuilder<T>;
+    orderBy(column: string, direction?: 'ASC' | 'DESC'): QueryBuilder<T>;
+    limit(limit: number): QueryBuilder<T>;
+    offset(offset: number): QueryBuilder<T>;
+    count(column?: string, options?: QueryOptions): Promise<number>;
+    sum(column: string, options?: QueryOptions): Promise<number>;
+    avg(column: string, options?: QueryOptions): Promise<number>;
+    min(column: string, options?: QueryOptions): Promise<number | null>;
+    max(column: string, options?: QueryOptions): Promise<number | null>;
+    exists(options?: QueryOptions): Promise<boolean>;
+    paginate(page?: number, perPage?: number, options?: QueryOptions): Promise<PaginationResult<T>>;
+    cursorPaginate(cursorColumn: string, cursor?: number | string | null, limit?: number, options?: QueryOptions): Promise<CursorPaginationResult<T>>;
+    chunk(size: number, callback: (items: T[], page: number) => Promise<void | false>, options?: QueryOptions): Promise<void>;
+    first(options?: QueryOptions): Promise<T | null>;
+    pluck<K = unknown>(column: string, options?: QueryOptions): Promise<K[]>;
+    value<K = unknown>(column: string, options?: QueryOptions): Promise<K | null>;
+    insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): QueryBuilder<T>;
+    update(table: string, data: Record<string, unknown>): QueryBuilder<T>;
+    delete(table: string): QueryBuilder<T>;
+    raw(sql: string, bindings?: unknown[]): QueryBuilder<T>;
+    encrypt(...fields: string[]): QueryBuilder<T>;
+    decrypt(...fields: string[]): QueryBuilder<T>;
+    toSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+    execute(options?: QueryOptions): Promise<QueryResult<T>>;
+    protected addWhereClause(type: 'AND' | 'OR', condition: string | Record<string, unknown>, operator: string, value?: unknown): void;
+    protected processDataForEncryption(data: Record<string, unknown> | Record<string, unknown>[]): Record<string, unknown> | Record<string, unknown>[];
+    protected encryptRow(row: Record<string, unknown>): Record<string, unknown>;
+    protected processResultsForDecryption(result: QueryResult<T>): Promise<QueryResult<T>>;
+    protected abstract buildSelectSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+    protected abstract buildInsertSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+    protected abstract buildUpdateSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+    protected abstract buildDeleteSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+}
+
+interface DateFilterContext {
+    bindings: unknown[];
+    whereClauses: WhereClause[];
+    escapeIdentifierFn: (identifier: string) => string;
+    parameterPlaceholderFn: (index: number) => string;
+}
+declare function whereDate(ctx: DateFilterContext, column: string, operator: string, date: Date | string): void;
+declare function whereYear(ctx: DateFilterContext, column: string, operator: string, year: number): void;
+declare function whereMonth(ctx: DateFilterContext, column: string, operator: string, month: number): void;
+declare function whereDay(ctx: DateFilterContext, column: string, operator: string, day: number): void;
+declare function whereToday(ctx: DateFilterContext, column: string): void;
+declare function whereYesterday(ctx: DateFilterContext, column: string): void;
+declare function whereBetweenDates(ctx: DateFilterContext, column: string, startDate: Date | string, endDate: Date | string): void;
+declare function whereLastDays(ctx: DateFilterContext, column: string, days: number): void;
+
+interface AggregateContext {
+    adapter: DatabaseAdapter;
+    selectColumns: string[];
+    escapeIdentifierFn: (identifier: string) => string;
+    toSQL: () => {
+        sql: string;
+        bindings: unknown[];
+    };
+}
+declare function count(ctx: AggregateContext, column?: string, options?: QueryOptions): Promise<number>;
+declare function sum(ctx: AggregateContext, column: string, options?: QueryOptions): Promise<number>;
+declare function avg(ctx: AggregateContext, column: string, options?: QueryOptions): Promise<number>;
+declare function min(ctx: AggregateContext, column: string, options?: QueryOptions): Promise<number | null>;
+declare function max(ctx: AggregateContext, column: string, options?: QueryOptions): Promise<number | null>;
+declare function exists(ctx: AggregateContext, options?: QueryOptions): Promise<boolean>;
+
+interface PaginationContext<T> {
+    toSQL: () => {
+        sql: string;
+        bindings: unknown[];
+    };
+    where: (column: string, operator: string, value: unknown) => void;
+    orderBy: (column: string, direction: 'ASC' | 'DESC') => void;
+    count: (column: string, options?: QueryOptions) => Promise<number>;
+    execute: (options?: QueryOptions) => Promise<QueryResult<T>>;
+}
+interface PaginationState {
+    limitValue?: number;
+    offsetValue?: number;
+}
+declare function paginate<T>(ctx: PaginationContext<T>, state: PaginationState, page?: number, perPage?: number, options?: QueryOptions): Promise<PaginationResult<T>>;
+declare function cursorPaginate<T>(ctx: PaginationContext<T>, state: PaginationState, cursorColumn: string, cursor?: number | string | null, limit?: number, options?: QueryOptions): Promise<CursorPaginationResult<T>>;
+declare function chunk<T>(ctx: PaginationContext<T>, state: PaginationState, size: number, callback: (items: T[], page: number) => Promise<void | false>, options?: QueryOptions): Promise<void>;
+
+interface EncryptionContext {
+    crypto?: CryptoProvider;
+    encryptedFields: Set<string>;
+    decryptedFields: Set<string>;
+}
+declare function processDataForEncryption(ctx: EncryptionContext, data: Record<string, unknown> | Record<string, unknown>[]): Record<string, unknown> | Record<string, unknown>[];
+declare function encryptRow(ctx: EncryptionContext, row: Record<string, unknown>): Record<string, unknown>;
+declare function processResultsForDecryption<T>(ctx: EncryptionContext, result: QueryResult<T>): Promise<QueryResult<T>>;
+
+interface HealthCheckResult {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    latency: number;
+    timestamp: Date;
+    details: {
+        connectionPool?: {
+            total: number;
+            active: number;
+            idle: number;
+            waiting: number;
+        };
+        lastError?: string;
+        uptime?: number;
+        version?: string;
+    };
+}
+interface HealthCheckOptions {
+    interval?: number;
+    timeout?: number;
+    retries?: number;
+    onHealthChange?: (result: HealthCheckResult) => void;
+    logger?: Logger;
+}
+declare class HealthChecker {
+    private adapter;
+    private options;
+    private intervalId?;
+    private lastResult?;
+    private startTime;
+    private consecutiveFailures;
+    constructor(adapter: DatabaseAdapter, options?: HealthCheckOptions);
+    check(): Promise<HealthCheckResult>;
+    start(): void;
+    stop(): void;
+    getLastResult(): HealthCheckResult | undefined;
+    isHealthy(): boolean;
+    getUptime(): number;
+    getConsecutiveFailures(): number;
+    waitForHealthy(maxWaitTime?: number): Promise<void>;
+}
+
+interface QueryMetrics {
+    totalQueries: number;
+    successfulQueries: number;
+    failedQueries: number;
+    averageLatency: number;
+    minLatency: number;
+    maxLatency: number;
+    queriesPerSecond: number;
+    cacheHitRate: number;
+    slowQueries: number;
+    queryDistribution: Record<string, number>;
+}
+interface ConnectionMetrics {
+    totalConnections: number;
+    activeConnections: number;
+    idleConnections: number;
+    connectionErrors: number;
+    averageConnectionTime: number;
+    connectionReuse: number;
+}
+interface TransactionMetrics {
+    totalTransactions: number;
+    committedTransactions: number;
+    rolledBackTransactions: number;
+    averageTransactionDuration: number;
+    activeTransactions: number;
+    deadlocks: number;
+}
+interface SystemMetrics {
+    memoryUsage: NodeJS.MemoryUsage;
+    cpuUsage: NodeJS.CpuUsage;
+    uptime: number;
+    timestamp: Date;
+}
+interface MetricsSnapshot {
+    query: QueryMetrics;
+    connection: ConnectionMetrics;
+    transaction: TransactionMetrics;
+    system: SystemMetrics;
+    custom: Record<string, unknown>;
+}
+declare class MetricsCollector extends EventEmitter {
+    private queryMetrics;
+    private connectionMetrics;
+    private transactionMetrics;
+    private queryLatencies;
+    private connectionTimes;
+    private transactionDurations;
+    private startTime;
+    private slowQueryThreshold;
+    private customMetrics;
+    private interval?;
+    constructor(options?: {
+        slowQueryThreshold?: number;
+        collectionInterval?: number;
+    });
+    private createEmptyQueryMetrics;
+    private createEmptyConnectionMetrics;
+    private createEmptyTransactionMetrics;
+    recordQuery(command: string, latency: number, success: boolean, cacheHit?: boolean): void;
+    recordConnection(connected: boolean, connectionTime?: number): void;
+    recordTransaction(action: 'start' | 'commit' | 'rollback', duration?: number, isDeadlock?: boolean): void;
+    updateConnectionPool(stats: {
+        total: number;
+        active: number;
+        idle: number;
+    }): void;
+    setCustomMetric(key: string, value: unknown): void;
+    incrementCustomMetric(key: string, value?: number): void;
+    getSnapshot(): MetricsSnapshot;
+    reset(): void;
+    private calculateAverage;
+    private startCollection;
+    stop(): void;
+    exportPrometheus(): string;
+}
+
+interface Migration {
+    id: string;
+    version: number;
+    name: string;
+    up: (adapter: DatabaseAdapter) => Promise<void>;
+    down: (adapter: DatabaseAdapter) => Promise<void>;
+    timestamp: Date;
+}
+interface MigrationHistory {
+    id: string;
+    version: number;
+    name: string;
+    executedAt: Date;
+    duration: number;
+    checksum: string;
+}
+interface MigrationRunnerOptions {
+    tableName?: string;
+    logger?: Logger;
+    validateChecksums?: boolean;
+    dryRun?: boolean;
+}
+declare class MigrationRunner {
+    private adapter;
+    private migrations;
+    private options;
+    constructor(adapter: DatabaseAdapter, options?: MigrationRunnerOptions);
+    initialize(): Promise<void>;
+    addMigration(migration: Migration): void;
+    addMigrations(migrations: Migration[]): void;
+    getExecutedMigrations(): Promise<MigrationHistory[]>;
+    getPendingMigrations(): Promise<Migration[]>;
+    private calculateChecksum;
+    up(targetVersion?: number): Promise<void>;
+    down(targetVersion: number): Promise<void>;
+    latest(): Promise<void>;
+    rollback(steps?: number): Promise<void>;
+    reset(): Promise<void>;
+    refresh(): Promise<void>;
+    private runMigration;
+    status(): Promise<{
+        executed: MigrationHistory[];
+        pending: Migration[];
+        current: number | null;
+    }>;
+    validate(): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+}
+
+interface PerformanceTrace$1 {
+    id: string;
+    operation: string;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    metadata: Record<string, unknown>;
+    status: 'started' | 'completed' | 'failed';
+    error?: Error;
+    parent?: string;
+    children: string[];
+}
+interface QueryPlan$1 {
+    query: string;
+    plan: string;
+    cost: number;
+    rows: number;
+    width: number;
+    actualTime?: number;
+    actualRows?: number;
+}
+interface PerformanceReport$1 {
+    slowQueries: Array<{
+        query: string;
+        duration: number;
+        timestamp: Date;
+        params?: unknown[];
+    }>;
+    queryPlans: QueryPlan$1[];
+    bottlenecks: Array<{
+        operation: string;
+        averageDuration: number;
+        count: number;
+        impact: number;
+    }>;
+    recommendations: string[];
+}
+declare class PerformanceMonitor extends EventEmitter {
+    private traces;
+    private slowQueries;
+    private queryPlans;
+    private slowQueryThreshold;
+    private maxTraces;
+    private adapter;
+    private enabled;
+    constructor(adapter: DatabaseAdapter, options?: {
+        slowQueryThreshold?: number;
+        maxTraces?: number;
+        enabled?: boolean;
+    });
+    startTrace(operation: string, metadata?: Record<string, unknown>, parent?: string): string;
+    endTrace(id: string, error?: Error): void;
+    explainQuery(sql: string, params?: QueryParams): Promise<QueryPlan$1 | null>;
+    private parseExplainResult;
+    analyzePerformance(duration?: number): Promise<PerformanceReport$1>;
+    wrapAdapter(adapter: DatabaseAdapter): DatabaseAdapter;
+    reset(): void;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    private generateTraceId;
+    getTraces(filter?: {
+        operation?: string;
+        status?: PerformanceTrace$1['status'];
+        minDuration?: number;
+        parent?: string;
+    }): PerformanceTrace$1[];
+    getSlowQueries(limit?: number): typeof this.slowQueries;
+    exportTraces(): string;
+    importTraces(data: string): void;
+}
+
+interface PerformanceTrace {
+    id: string;
+    operation: string;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    metadata: Record<string, unknown>;
+    status: 'started' | 'completed' | 'failed';
+    error?: Error;
+    parent?: string;
+    children: string[];
+}
+declare class TraceBaseTrait extends EventEmitter {
+    protected traces: Map<string, PerformanceTrace>;
+    protected enabled: boolean;
+    protected maxTraces: number;
+    constructor(maxTraces?: number, enabled?: boolean);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    protected generateTraceId(): string;
+    getTraces(filter?: {
+        operation?: string;
+        status?: PerformanceTrace['status'];
+        minDuration?: number;
+        parent?: string;
+    }): PerformanceTrace[];
+    exportTraces(): string;
+    importTraces(data: string): void;
+    reset(): void;
+}
+
+declare class TraceManagementTrait extends TraceBaseTrait {
+    startTrace(operation: string, metadata?: Record<string, unknown>, parent?: string): string;
+    endTrace(id: string, error?: Error): void;
+    protected cleanupOldTraces(): void;
+    getTrace(id: string): PerformanceTrace | undefined;
+    getChildTraces(parentId: string): PerformanceTrace[];
+    getTraceHierarchy(rootId: string): PerformanceTrace | null;
+}
+
+interface QueryPlan {
+    query: string;
+    plan: string;
+    cost: number;
+    rows: number;
+    width: number;
+    actualTime?: number;
+    actualRows?: number;
+}
+declare class QueryAnalysisTrait extends TraceManagementTrait {
+    protected adapter: DatabaseAdapter;
+    protected slowQueryThreshold: number;
+    protected slowQueries: Array<{
+        query: string;
+        duration: number;
+        timestamp: Date;
+        params?: unknown[];
+    }>;
+    protected queryPlans: Map<string, QueryPlan>;
+    constructor(adapter: DatabaseAdapter, slowQueryThreshold?: number, maxTraces?: number, enabled?: boolean);
+    endTrace(id: string, error?: Error): void;
+    explainQuery(sql: string, params?: QueryParams): Promise<QueryPlan | null>;
+    protected parseExplainResult(result: Record<string, unknown>): QueryPlan | null;
+    getSlowQueries(limit?: number): typeof this.slowQueries;
+    reset(): void;
+}
+
+interface PerformanceReport {
+    slowQueries: Array<{
+        query: string;
+        duration: number;
+        timestamp: Date;
+        params?: unknown[];
+    }>;
+    queryPlans: any[];
+    bottlenecks: Array<{
+        operation: string;
+        averageDuration: number;
+        count: number;
+        impact: number;
+    }>;
+    recommendations: string[];
+}
+declare class PerformanceAnalysisTrait extends QueryAnalysisTrait {
+    analyzePerformance(duration?: number): Promise<PerformanceReport>;
+    protected generateRecommendations(traces: any[]): string[];
+    getBottlenecks(limit?: number): Array<{
+        operation: string;
+        avgDuration: number;
+        count: number;
+    }>;
+}
+
+declare class AdapterWrapperTrait extends PerformanceAnalysisTrait {
+    wrapAdapter(adapter: DatabaseAdapter): DatabaseAdapter;
+    protected wrapMethod(adapter: any, methodName: string, operationType: string): void;
+    unwrapAdapter(adapter: DatabaseAdapter): void;
+}
+
+declare class ModularPerformanceMonitor extends AdapterWrapperTrait {
+    constructor(adapter: DatabaseAdapter, options?: {
+        slowQueryThreshold?: number;
+        maxTraces?: number;
+        enabled?: boolean;
+    });
+}
+
+type CacheKeyPattern = 'table' | 'table:id' | 'table:query' | 'table:field' | 'custom';
+interface CacheKeyOptions {
+    namespace?: string;
+    table?: string;
+    id?: string | number;
+    field?: string;
+    value?: unknown;
+    query?: string;
+    params?: unknown[];
+    parts?: string[];
+    tags?: string[];
+}
+declare class CacheKeyGenerator {
+    private readonly namespace;
+    private readonly separator;
+    private readonly hashAlgorithm;
+    private readonly hashLength;
+    private currentOptions;
+    constructor(options?: {
+        namespace?: string;
+        separator?: string;
+        hashAlgorithm?: string;
+        hashLength?: number;
+    });
+    forTable(table: string): this;
+    withId(id: string | number): this;
+    withField(field: string, value: unknown): this;
+    withTags(...tags: string[]): this;
+    forQuery(sql: string, params?: unknown[]): this;
+    forCustom(...parts: string[]): this;
+    inNamespace(namespace: string): this;
+    build(): string;
+    buildWithTags(): {
+        key: string;
+        tags: string[];
+    };
+    tableId(table: string, id: string | number): string;
+    tableField(table: string, field: string, value: unknown): string;
+    query(sql: string, params?: unknown[]): string;
+    pattern(table: string, pattern?: '*' | 'id:*' | 'field:*'): string;
+    tag(tagName: string): string;
+    private hashQuery;
+    private hashValue;
+    private hash;
+    withNamespace(namespace: string): CacheKeyGenerator;
+}
+declare const cacheKey: CacheKeyGenerator;
+
+interface CacheEntry<T = unknown> {
+    data: T;
+    cachedAt: number;
+    expiresAt?: number;
+    tags?: string[];
+}
+interface CacheStats {
+    hits: number;
+    misses: number;
+    sets: number;
+    deletes: number;
+    invalidations: number;
+    hitRate: number;
+}
+interface CacheManagerOptions {
+    adapter: CacheAdapter;
+    defaultTTL?: number;
+    namespace?: string;
+    enableStats?: boolean;
+    keyPrefix?: string;
+}
+interface CacheSetOptions {
+    ttl?: number;
+    tags?: string[];
+    skipIfExists?: boolean;
+}
+declare class CacheManager {
+    private readonly adapter;
+    private readonly defaultTTL;
+    private readonly enableStats;
+    private readonly keyPrefix;
+    readonly key: CacheKeyGenerator;
+    private stats;
+    constructor(options: CacheManagerOptions);
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, data: T, options?: CacheSetOptions): Promise<void>;
+    getOrSet<T = unknown>(key: string, fetchFn: () => Promise<T>, options?: CacheSetOptions): Promise<T>;
+    delete(key: string): Promise<boolean>;
+    deleteMany(keys: string[]): Promise<number>;
+    exists(key: string): Promise<boolean>;
+    invalidateByTag(tag: string): Promise<number>;
+    invalidateByTags(tags: string[]): Promise<number>;
+    invalidateTable(table: string): Promise<number>;
+    invalidateRecord(table: string, id: string | number): Promise<boolean>;
+    clear(): Promise<void>;
+    getStats(): CacheStats;
+    resetStats(): void;
+    getTTL(key: string): Promise<number>;
+    extendTTL(key: string, ttl: number): Promise<boolean>;
+    scope(namespace: string): CacheManager;
+    private getFullKey;
+    private addKeyToTags;
+    private recordHit;
+    private recordMiss;
+    private recordSet;
+    private recordDelete;
+    private recordInvalidation;
+}
+
+interface CacheStrategy {
+    shouldCache(sql: string, result: QueryResult): boolean;
+    getCacheTTL(sql: string, options?: QueryCacheOptions): number;
+    getCacheKey(sql: string, params?: unknown[], options?: QueryCacheOptions): string;
+    getInvalidationPatterns(sql: string): string[];
+}
+interface QueryCacheOptions {
+    ttl?: number;
+    key?: string;
+    tags?: string[];
+    invalidateOn?: string[];
+    compress?: boolean;
+    cacheEmpty?: boolean;
+    cacheErrors?: boolean;
+}
+declare class DefaultCacheStrategy implements CacheStrategy {
+    private readonly cacheableCommands;
+    private readonly defaultTTL;
+    shouldCache(sql: string, result: QueryResult): boolean;
+    getCacheTTL(sql: string, options?: QueryCacheOptions): number;
+    getCacheKey(sql: string, params?: unknown[], options?: QueryCacheOptions): string;
+    getInvalidationPatterns(sql: string): string[];
+    protected extractTableNames(sql: string): string[];
+}
+declare class SmartCacheStrategy extends DefaultCacheStrategy {
+    private queryPatterns;
+    shouldCache(sql: string, result: QueryResult): boolean;
+    getCacheTTL(sql: string, options?: QueryCacheOptions): number;
+    recordQueryExecution(sql: string, duration: number): void;
+    private normalizeQuery;
+}
+
+interface CacheInvalidateOptions {
+    tables?: string | string[];
+    tags?: string | string[];
+}
+interface CacheWarmupQuery {
+    sql: string;
+    params?: unknown[];
+    ttl?: number;
+    tags?: string[];
+}
+interface CacheAPIStats {
+    hits: number;
+    misses: number;
+    sets: number;
+    deletes: number;
+    invalidations: number;
+    hitRate: number;
+    size: number;
+    memoryUsage?: number;
+}
+interface CacheAPIOptions {
+    adapter: CacheAdapter;
+    namespace?: string;
+    logger?: Logger;
+    onHit?: (key: string, sql: string) => void;
+    onMiss?: (key: string, sql: string) => void;
+    onError?: (error: Error, key: string) => void;
+}
+declare class CacheAPI {
+    private adapter;
+    private keyGenerator;
+    private logger?;
+    private stats;
+    private tableKeyMap;
+    private tagKeyMap;
+    onHit?: (key: string, sql: string) => void;
+    onMiss?: (key: string, sql: string) => void;
+    onError?: (error: Error, key: string) => void;
+    constructor(options: CacheAPIOptions);
+    invalidate(options: CacheInvalidateOptions): Promise<number>;
+    clear(): Promise<void>;
+    warmup(queries: CacheWarmupQuery[], executor: (sql: string, params?: unknown[]) => Promise<unknown>): Promise<{
+        success: number;
+        failed: number;
+    }>;
+    getStats(): CacheAPIStats;
+    resetStats(): void;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, options?: {
+        ttl?: number;
+        tags?: string[];
+        tables?: string[];
+    }): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    exists(key: string): Promise<boolean>;
+    generateKey(sql: string, params?: unknown[]): string;
+    key(): CacheKeyGenerator;
+    private extractTables;
+    private updateHitRate;
+    private handleError;
+}
+interface CacheConfig {
+    redis?: string | CacheAdapter;
+    global?: boolean;
+    ttl?: number;
+    namespace?: string;
+    cacheableCommands?: string[];
+    autoInvalidate?: boolean;
+    cacheEmpty?: boolean;
+    warmup?: CacheWarmupQuery[];
+    onHit?: (key: string, sql: string) => void;
+    onMiss?: (key: string, sql: string) => void;
+    onError?: (error: Error, key: string) => void;
+}
+interface QueryCacheConfig {
+    enabled?: boolean;
+    ttl?: number;
+    key?: string;
+    tags?: string[];
+    autoInvalidate?: boolean;
+}
+type CacheOption = boolean | QueryCacheConfig;
+
+interface CacheStatistics {
+    hits: number;
+    misses: number;
+    hitRate: number;
+    totalCached: number;
+    totalEvicted: number;
+    avgHitTime: number;
+    avgMissTime: number;
+    memoryUsage?: number;
+}
+declare class CacheBaseTrait extends EventEmitter {
+    protected cache: CacheAdapter;
+    protected logger?: Logger;
+    protected enabled: boolean;
+    protected statistics: CacheStatistics;
+    constructor(cache: CacheAdapter, logger?: Logger, enabled?: boolean);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    getStatistics(): CacheStatistics;
+    resetStatistics(): void;
+    protected updateStatistics(type: 'hit' | 'miss', duration: number): void;
+}
+
+interface CachedQuery {
+    key: string;
+    sql: string;
+    result: QueryResult;
+    timestamp: Date;
+    ttl: number;
+    hits: number;
+    tags: string[];
+    size: number;
+}
+declare class CacheOperationsTrait extends CacheBaseTrait {
+    protected strategy: CacheStrategy;
+    protected queryCache: Map<string, CachedQuery>;
+    protected tagIndex: Map<string, Set<string>>;
+    setStrategy(strategy: CacheStrategy): void;
+    get<T = unknown>(sql: string, params?: unknown[], options?: QueryCacheOptions): Promise<QueryResult<T> | null>;
+    set<T = unknown>(sql: string, params: unknown[] | undefined, result: QueryResult<T>, options?: QueryCacheOptions): Promise<void>;
+    getCachedQueries(): CachedQuery[];
+    getCacheSize(): {
+        entries: number;
+        approximateSize: number;
+    };
+    protected registerInvalidation(key: string, patterns: string[]): Promise<void>;
+}
+
+declare class CacheInvalidationTrait extends CacheOperationsTrait {
+    invalidate(patterns: string[]): Promise<number>;
+    invalidateByTable(table: string): Promise<number>;
+    invalidateAll(): Promise<void>;
+}
+
+declare class CacheMaintenanceTrait extends CacheInvalidationTrait {
+    private cleanupInterval?;
+    warmUp(queries: Array<{
+        sql: string;
+        params?: unknown[];
+        options?: QueryCacheOptions;
+    }>): Promise<void>;
+    startCleanupTimer(intervalMs?: number): void;
+    stopCleanupTimer(): void;
+    destroy(): void;
+}
+
+declare class ModularCacheManager extends CacheMaintenanceTrait {
+    constructor(cache: CacheAdapter, options?: {
+        strategy?: CacheStrategy;
+        logger?: Logger;
+        enabled?: boolean;
+    });
+}
+
+interface CachedAdapterOptions {
+    adapter: DatabaseAdapter;
+    cache: CacheAdapter;
+    strategy?: CacheStrategy;
+    logger?: Logger;
+    enabled?: boolean;
+    cacheableCommands?: string[];
+    defaultTTL?: number;
+    cacheEmptyResults?: boolean;
+    cacheErrors?: boolean;
+    warmupQueries?: Array<{
+        sql: string;
+        params?: unknown[];
+        ttl?: number;
+    }>;
+}
+declare class CachedAdapter extends EventEmitter implements DatabaseAdapter {
+    private adapter;
+    private cacheManager;
+    private cacheableCommands;
+    private defaultTTL;
+    private cacheEmptyResults;
+    private cacheErrors;
+    private logger?;
+    private warmupQueries?;
+    constructor(options: CachedAdapterOptions);
+    get name(): string;
+    get version(): string;
+    get isConnected(): boolean;
+    connect(config: ConnectionConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    beginTransaction(options?: TransactionOptions): Promise<Transaction>;
+    prepare<T = unknown>(sql: string, name?: string): Promise<PreparedStatement<T>>;
+    getPoolStats(): PoolStats;
+    ping(): Promise<boolean>;
+    escape(value: unknown): string;
+    escapeIdentifier(identifier: string): string;
+    execute<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    createQueryBuilder<T = unknown>(): QueryBuilder<T>;
+    getCacheManager(): ModularCacheManager;
+    warmupCache(): Promise<void>;
+    private performWarmup;
+    private shouldCache;
+    private shouldCacheResult;
+    private extractCommand;
+    private isWriteCommand;
+    private invalidateRelatedCache;
+    private extractTableNames;
+}
+declare function createCachedAdapter(adapter: DatabaseAdapter, cache: CacheAdapter, options?: Partial<CachedAdapterOptions>): CachedAdapter;
+
+interface DialectConfig {
+    identifierQuote: string;
+    namedParameters: boolean;
+    concatOperator: string;
+    booleanLiterals: {
+        true: string;
+        false: string;
+    };
+    dateFunctions: {
+        now: string;
+        currentDate: string;
+        currentTime: string;
+        dateFormat: (column: string, format: string) => string;
+    };
+    limitStyle: 'LIMIT_OFFSET' | 'FETCH_FIRST' | 'TOP';
+    jsonOperators: {
+        extract: (column: string, path: string) => string;
+        contains: (column: string, value: string) => string;
+    };
+}
+declare abstract class SQLDialect {
+    abstract readonly name: string;
+    abstract readonly config: DialectConfig;
+    private parameterIndex;
+    resetParameters(): void;
+    abstract getParameterPlaceholder(): string;
+    escapeIdentifier(identifier: string): string;
+    abstract escapeValue(value: unknown): string;
+    buildSelect(components: SelectComponents): BuiltSQL;
+    buildInsert(components: InsertComponents): BuiltSQL;
+    buildUpdate(components: UpdateComponents): BuiltSQL;
+    buildDelete(components: DeleteComponents): BuiltSQL;
+    protected buildWhereClause(conditions: WhereCondition[], bindings: unknown[]): string;
+    protected appendLimitOffset(parts: string[], limit?: number, offset?: number): void;
+    protected nextParameterIndex(): number;
+}
+interface BuiltSQL {
+    sql: string;
+    bindings: unknown[];
+}
+interface WhereCondition {
+    type: 'AND' | 'OR';
+    sql: string;
+    bindings: unknown[];
+}
+interface JoinDefinition {
+    type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS';
+    table: string;
+    alias?: string;
+    condition: string;
+    bindings: unknown[];
+}
+interface OrderByDefinition {
+    column: string;
+    direction: 'ASC' | 'DESC';
+    raw?: boolean;
+}
+interface SelectComponents {
+    columns: string[];
+    distinct?: boolean;
+    from?: string;
+    fromAlias?: string;
+    joins: JoinDefinition[];
+    where: WhereCondition[];
+    groupBy: string[];
+    having?: {
+        condition: string;
+        bindings: unknown[];
+    };
+    orderBy: OrderByDefinition[];
+    limit?: number;
+    offset?: number;
+}
+interface InsertComponents {
+    table: string;
+    data: Record<string, unknown>[];
+    returning?: string[];
+}
+interface UpdateComponents {
+    table: string;
+    data: Record<string, unknown>;
+    where: WhereCondition[];
+    returning?: string[];
+}
+interface DeleteComponents {
+    table: string;
+    where: WhereCondition[];
+    returning?: string[];
+}
+
+declare class MySQLDialect extends SQLDialect {
+    readonly name = "mysql";
+    readonly config: DialectConfig;
+    getParameterPlaceholder(): string;
+    escapeValue(value: unknown): string;
+    buildUpsert(table: string, data: Record<string, unknown>, conflictColumns: string[]): {
+        sql: string;
+        bindings: unknown[];
+    };
+    buildReplace(table: string, data: Record<string, unknown>): {
+        sql: string;
+        bindings: unknown[];
+    };
+    getLastInsertIdSQL(): string;
+    protected appendLimitOffset(parts: string[], limit?: number, offset?: number): void;
+}
+
+declare class PostgreSQLDialect extends SQLDialect {
+    readonly name = "postgresql";
+    readonly config: DialectConfig;
+    getParameterPlaceholder(): string;
+    escapeValue(value: unknown): string;
+    buildUpsert(table: string, data: Record<string, unknown>, conflictColumns: string[], updateColumns?: string[]): {
+        sql: string;
+        bindings: unknown[];
+    };
+    buildWithCTE(cteName: string, cteQuery: string, mainQuery: string, recursive?: boolean): string;
+    buildReturning(columns: string[]): string;
+    buildArrayContains(column: string, value: unknown): string;
+    buildArrayOverlap(column: string, values: unknown[]): string;
+    buildTextSearch(column: string, query: string, config?: string): string;
+    buildJsonPath(column: string, path: string[]): string;
+    buildJsonPathText(column: string, path: string[]): string;
+}
+
+type DialectDatabaseType = 'mysql' | 'mariadb' | 'postgresql' | 'postgres';
+declare class DialectFactory {
+    static getDialect(type: DialectDatabaseType): SQLDialect;
+    static createDialect(type: DialectDatabaseType): SQLDialect;
+    private static normalizeType;
+    static isSupported(type: string): type is DialectDatabaseType;
+    static clearCache(): void;
+}
+
+interface ExecuteResult {
+    affectedRows: number;
+    insertId?: number | bigint;
+    changedRows?: number;
+}
+interface QueryExecutor {
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    execute(sql: string, params?: unknown[]): Promise<ExecuteResult>;
+}
+interface QueryContextCacheConfig {
+    adapter: CacheAdapter;
+    defaultTTL: number;
+    maxTTL: number;
+    prefix: string;
+    global: boolean;
+    warnOnLargeResult: number;
+    maxCacheableRows: number;
+    logger?: {
+        warn: (message: string) => void;
+    };
+}
+declare class QueryContext {
+    readonly dialect: SQLDialect;
+    readonly executor: QueryExecutor;
+    readonly crypto?: CryptoProvider | undefined;
+    readonly cacheConfig?: QueryContextCacheConfig;
+    constructor(dialect: SQLDialect, executor: QueryExecutor, crypto?: CryptoProvider | undefined, cacheConfig?: QueryContextCacheConfig);
+    executeQuery<T>(sql: string, bindings: unknown[]): Promise<QueryResult<T>>;
+    executeWrite(sql: string, bindings: unknown[]): Promise<ExecuteResult>;
+    encrypt(value: string): string;
+    decrypt(value: string): string;
+    get hasCrypto(): boolean;
+    get hasCache(): boolean;
+    generateCacheKey(sql: string, bindings: unknown[]): string;
+    executeCachedQuery<T>(sql: string, bindings: unknown[], options?: {
+        ttl?: number;
+        key?: string;
+    }): Promise<QueryResult<T>>;
+    invalidateCache(pattern?: string): Promise<void>;
+}
+
+interface CacheOptions {
+    ttl?: number;
+    key?: string;
+    tags?: string[];
+}
+interface CacheState {
+    enabled: boolean;
+    ttl?: number;
+    key?: string;
+    tags?: string[];
+}
+
+declare class SelectBuilder<T = unknown> {
+    private readonly ctx;
+    private _columns;
+    private _distinct;
+    private _table?;
+    private _tableAlias?;
+    private _joins;
+    private _groupBy;
+    private _having?;
+    private _orderBy;
+    private _limit?;
+    private _offset?;
+    private _whereBuilder;
+    private _encryptFields;
+    private _decryptFields;
+    private _cacheEnabled;
+    private _cacheTTL?;
+    private _cacheKey?;
+    private _cacheTags?;
+    constructor(ctx: QueryContext);
+    select(...columns: string[]): this;
+    addSelect(...columns: string[]): this;
+    distinct(): this;
+    from(table: string, alias?: string): this;
+    table(table: string, alias?: string): this;
+    where(column: string, value: unknown): this;
+    where(column: string, operator: string, value: unknown): this;
+    where(conditions: Record<string, unknown>): this;
+    orWhere(column: string, value: unknown): this;
+    orWhere(column: string, operator: string, value: unknown): this;
+    orWhere(conditions: Record<string, unknown>): this;
+    whereNull(column: string): this;
+    whereNotNull(column: string): this;
+    whereIn(column: string, values: unknown[]): this;
+    whereNotIn(column: string, values: unknown[]): this;
+    whereBetween(column: string, from: unknown, to: unknown): this;
+    whereLike(column: string, pattern: string): this;
+    whereRaw(sql: string, bindings?: unknown[]): this;
+    join(table: string, condition: string, bindings?: unknown[]): this;
+    innerJoin(table: string, condition: string, bindings?: unknown[]): this;
+    leftJoin(table: string, condition: string, bindings?: unknown[]): this;
+    rightJoin(table: string, condition: string, bindings?: unknown[]): this;
+    fullJoin(table: string, condition: string, bindings?: unknown[]): this;
+    crossJoin(table: string): this;
+    leftJoinAs(table: string, alias: string, condition: string, bindings?: unknown[]): this;
+    innerJoinAs(table: string, alias: string, condition: string, bindings?: unknown[]): this;
+    groupBy(...columns: string[]): this;
+    having(condition: string, bindings?: unknown[]): this;
+    orderBy(column: string, direction?: 'ASC' | 'DESC'): this;
+    orderByDesc(column: string): this;
+    orderByAsc(column: string): this;
+    orderByRaw(expression: string): this;
+    clearOrder(): this;
+    reorder(column: string, direction?: 'ASC' | 'DESC'): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    skip(count: number): this;
+    take(count: number): this;
+    paginate(page: number, perPage: number): this;
+    forPage(page: number, perPage?: number): this;
+    encrypt(...fields: string[]): this;
+    decrypt(...fields: string[]): this;
+    cache(options?: number | CacheOptions): this;
+    noCache(): this;
+    cacheTTL(seconds: number): this;
+    cacheKey(key: string): this;
+    cacheTags(...tags: string[]): this;
+    getCacheState(): CacheState;
+    toSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+    get(): Promise<T[]>;
+    first(): Promise<T | null>;
+    firstOrFail(): Promise<T>;
+    sole(): Promise<T>;
+    count(column?: string): Promise<number>;
+    exists(): Promise<boolean>;
+    doesntExist(): Promise<boolean>;
+    aggregate(fn: 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'COUNT', column: string): Promise<number | null>;
+    sum(column: string): Promise<number | null>;
+    avg(column: string): Promise<number | null>;
+    min(column: string): Promise<number | null>;
+    max(column: string): Promise<number | null>;
+    pluck<V = unknown>(column: string): Promise<V[]>;
+    pluckKeyValue<K extends string | number, V = unknown>(valueColumn: string, keyColumn: string): Promise<Map<K, V>>;
+    chunk(size: number, callback: (rows: T[], chunkNumber: number) => Promise<boolean | void> | boolean | void): Promise<void>;
+    lazy(chunkSize?: number): AsyncGenerator<T, void, unknown>;
+    private processResults;
+    clone(): SelectBuilder<T>;
+    dump(): this;
+    dd(): Promise<T[]>;
+}
+
+declare class InsertBuilder<T = unknown> {
+    private readonly ctx;
+    private _table?;
+    private _data;
+    private _returning;
+    private _encryptFields;
+    private _ignore;
+    constructor(ctx: QueryContext);
+    into(table: string): this;
+    table(table: string): this;
+    values(data: Record<string, unknown> | Record<string, unknown>[]): this;
+    encrypt(...fields: string[]): this;
+    returning(...columns: string[]): this;
+    ignore(): this;
+    toSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+    execute(): Promise<ExecuteResult>;
+    getInsertId(): Promise<number | bigint | undefined>;
+    getInserted<R = T>(): Promise<R | null>;
+    private processDataForEncryption;
+}
+
+declare class UpdateBuilder<T = unknown> {
+    private readonly ctx;
+    private _table?;
+    private _data;
+    private _whereBuilder;
+    private _returning;
+    private _encryptFields;
+    constructor(ctx: QueryContext);
+    table(table: string): this;
+    set(data: Record<string, unknown>): this;
+    encrypt(...fields: string[]): this;
+    returning(...columns: string[]): this;
+    where(column: string, value: unknown): this;
+    where(column: string, operator: string, value: unknown): this;
+    where(conditions: Record<string, unknown>): this;
+    orWhere(column: string, value: unknown): this;
+    orWhere(column: string, operator: string, value: unknown): this;
+    orWhere(conditions: Record<string, unknown>): this;
+    whereNull(column: string): this;
+    whereNotNull(column: string): this;
+    whereIn(column: string, values: unknown[]): this;
+    whereNotIn(column: string, values: unknown[]): this;
+    whereBetween(column: string, from: unknown, to: unknown): this;
+    whereLike(column: string, pattern: string): this;
+    whereRaw(sql: string, bindings?: unknown[]): this;
+    toSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+    execute(): Promise<ExecuteResult>;
+    getAffectedRows(): Promise<number>;
+    getUpdated<R = T>(): Promise<R | null>;
+    getAllUpdated<R = T>(): Promise<R[]>;
+    private processDataForEncryption;
+}
+
+declare class DeleteBuilder<T = unknown> {
+    private readonly ctx;
+    private _table?;
+    private _whereBuilder;
+    private _returning;
+    private _force;
+    constructor(ctx: QueryContext);
+    from(table: string): this;
+    table(table: string): this;
+    returning(...columns: string[]): this;
+    force(): this;
+    where(column: string, value: unknown): this;
+    where(column: string, operator: string, value: unknown): this;
+    where(conditions: Record<string, unknown>): this;
+    orWhere(column: string, value: unknown): this;
+    orWhere(column: string, operator: string, value: unknown): this;
+    orWhere(conditions: Record<string, unknown>): this;
+    whereNull(column: string): this;
+    whereNotNull(column: string): this;
+    whereIn(column: string, values: unknown[]): this;
+    whereNotIn(column: string, values: unknown[]): this;
+    whereBetween(column: string, from: unknown, to: unknown): this;
+    whereLike(column: string, pattern: string): this;
+    whereRaw(sql: string, bindings?: unknown[]): this;
+    toSQL(): {
+        sql: string;
+        bindings: unknown[];
+    };
+    execute(): Promise<ExecuteResult>;
+    getAffectedRows(): Promise<number>;
+    getDeleted<R = T>(): Promise<R | null>;
+    getAllDeleted<R = T>(): Promise<R[]>;
+    truncate(): Promise<void>;
+}
+
+type WhereConditionInput = {
+    type: 'simple';
+    column: string;
+    operator: string;
+    value: unknown;
+} | {
+    type: 'object';
+    data: Record<string, unknown>;
+} | {
+    type: 'raw';
+    sql: string;
+    bindings: unknown[];
+} | {
+    type: 'null';
+    column: string;
+    not: boolean;
+} | {
+    type: 'in';
+    column: string;
+    values: unknown[];
+    not: boolean;
+} | {
+    type: 'between';
+    column: string;
+    from: unknown;
+    to: unknown;
+    not: boolean;
+} | {
+    type: 'like';
+    column: string;
+    pattern: string;
+    not: boolean;
+};
+declare class WhereBuilder {
+    private readonly dialect;
+    private conditions;
+    constructor(dialect: SQLDialect);
+    where(column: string, value: unknown): this;
+    where(column: string, operator: string, value: unknown): this;
+    where(conditions: Record<string, unknown>): this;
+    orWhere(column: string, value: unknown): this;
+    orWhere(column: string, operator: string, value: unknown): this;
+    orWhere(conditions: Record<string, unknown>): this;
+    whereNull(column: string): this;
+    whereNotNull(column: string): this;
+    whereIn(column: string, values: unknown[]): this;
+    whereNotIn(column: string, values: unknown[]): this;
+    whereBetween(column: string, from: unknown, to: unknown): this;
+    whereNotBetween(column: string, from: unknown, to: unknown): this;
+    whereLike(column: string, pattern: string): this;
+    whereNotLike(column: string, pattern: string): this;
+    whereRaw(sql: string, bindings?: unknown[]): this;
+    build(): WhereCondition[];
+    hasConditions(): boolean;
+    clear(): void;
+    clone(): WhereBuilder;
+    private cloneInput;
+    private parseWhereArgs;
+    private buildCondition;
+    private buildSimpleCondition;
+    private buildObjectCondition;
+    private buildInCondition;
+    private buildBetweenCondition;
+}
+
+interface QueryBuilderCacheConfig {
+    adapter: CacheAdapter;
+    defaultTTL?: number;
+    maxTTL?: number;
+    prefix?: string;
+    global?: boolean;
+    warnOnLargeResult?: number;
+    maxCacheableRows?: number;
+    logger?: {
+        warn: (message: string) => void;
+    };
+}
+interface ModularQueryBuilderOptions {
+    dialect: SQLDialect;
+    executor: QueryExecutor;
+    crypto?: CryptoProvider;
+    cache?: QueryBuilderCacheConfig;
+}
+interface ModularQueryBuilder {
+    select<T = unknown>(...columns: string[]): SelectBuilder<T>;
+    insert<T = unknown>(): InsertBuilder<T>;
+    update<T = unknown>(): UpdateBuilder<T>;
+    delete<T = unknown>(): DeleteBuilder<T>;
+    getContext(): QueryContext;
+    raw<T = unknown>(sql: string, bindings?: unknown[]): Promise<T[]>;
+    rawExecute(sql: string, bindings?: unknown[]): Promise<{
+        affectedRows: number;
+    }>;
+    table<T = unknown>(name: string, alias?: string): SelectBuilder<T>;
+}
+declare function createModularQueryBuilder(options: ModularQueryBuilderOptions): ModularQueryBuilder;
+type InferQueryResult<T> = T extends SelectBuilder<infer R> ? R : never;
+
+interface TransactionConnection {
+    release(): void | Promise<void>;
+}
+declare abstract class BaseTransaction<TConnection extends TransactionConnection> implements Transaction {
+    protected readonly connection: TConnection;
+    protected readonly options?: TransactionOptions | undefined;
+    readonly id: string;
+    protected _isActive: boolean;
+    protected readonly savepoints: Set<string>;
+    constructor(connection: TConnection, options?: TransactionOptions | undefined);
+    get isActive(): boolean;
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    savepoint(name: string): Promise<void>;
+    releaseSavepoint(name: string): Promise<void>;
+    rollbackToSavepoint(name: string): Promise<void>;
+    query<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    execute<T = unknown>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    getConnection(): TConnection;
+    protected abstract doBegin(): Promise<void>;
+    protected abstract doCommit(): Promise<void>;
+    protected abstract doRollback(): Promise<void>;
+    protected abstract doSavepoint(name: string): Promise<void>;
+    protected abstract doReleaseSavepoint(name: string): Promise<void>;
+    protected abstract doRollbackToSavepoint(name: string): Promise<void>;
+    protected abstract doQuery<T>(sql: string, params?: QueryParams, options?: QueryOptions): Promise<QueryResult<T>>;
+    protected abstract setIsolationLevel(level: IsolationLevel): Promise<void>;
+    protected abstract escapeIdentifier(identifier: string): string;
+    protected applyTransactionOptions(): Promise<void>;
+    protected releaseConnection(): Promise<void>;
+    protected ensureActive(operation: string): void;
+    protected ensureSavepointExists(name: string): void;
+    protected validateSavepointName(name: string): void;
+    protected sanitizeSavepointName(name: string): string;
+    protected removeNewerSavepoints(name: string): void;
+    protected normalizeParams(params?: QueryParams): unknown[];
+}
+
+interface QueryMiddlewareContext {
+    sql: string;
+    params: unknown[];
+    options?: QueryOptions;
+    startTime: number;
+    metadata: Record<string, unknown>;
+}
+interface QueryMiddlewareResult<T = unknown> {
+    result: QueryResult<T>;
+    cached?: boolean;
+    retries?: number;
+    duration?: number;
+}
+type NextMiddleware<T = unknown> = (context: QueryMiddlewareContext) => Promise<QueryMiddlewareResult<T>>;
+type QueryMiddleware<T = unknown> = (context: QueryMiddlewareContext, next: NextMiddleware<T>) => Promise<QueryMiddlewareResult<T>>;
+interface MiddlewareConfig {
+    name: string;
+    enabled?: boolean;
+    order?: number;
+}
+interface CacheMiddlewareOptions {
+    adapter: MiddlewareCacheAdapter;
+    defaultTTL?: number;
+    keyPrefix?: string;
+    shouldCache?: (sql: string, params: unknown[]) => boolean;
+}
+interface RetryMiddlewareOptions {
+    maxRetries?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    retryOn?: (error: Error) => boolean;
+    backoffMultiplier?: number;
+}
+interface TimeoutMiddlewareOptions {
+    defaultTimeout?: number;
+    onTimeout?: (sql: string, elapsed: number) => void;
+}
+interface LoggingMiddlewareOptions {
+    logger?: MiddlewareLogger;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    logParams?: boolean;
+    logResults?: boolean;
+    slowQueryThreshold?: number;
+}
+interface MiddlewareLogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+interface MiddlewareCacheAdapter {
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+}
+
+declare class MiddlewareChain<T = unknown> {
+    private middlewares;
+    use(middleware: QueryMiddleware<T>): this;
+    remove(middleware: QueryMiddleware<T>): this;
+    clear(): this;
+    get length(): number;
+    execute(context: QueryMiddlewareContext, finalHandler: NextMiddleware<T>): Promise<QueryMiddlewareResult<T>>;
+    static createContext(sql: string, params: unknown[], options?: QueryMiddlewareContext['options']): QueryMiddlewareContext;
+}
+declare function composeMiddleware<T = unknown>(...middlewares: QueryMiddleware<T>[]): QueryMiddleware<T>;
+
+declare function createCacheMiddleware<T = unknown>(options: CacheMiddlewareOptions): QueryMiddleware<T>;
+declare function createCacheInvalidationMiddleware<T = unknown>(_adapter: MiddlewareCacheAdapter, _keyPrefix?: string): QueryMiddleware<T>;
+
+declare function createRetryMiddleware<T = unknown>(options?: RetryMiddlewareOptions): QueryMiddleware<T>;
+declare function createCircuitBreakerMiddleware<T = unknown>(options?: {
+    failureThreshold?: number;
+    resetTimeout?: number;
+    halfOpenRequests?: number;
+}): QueryMiddleware<T>;
+
+declare function createTimeoutMiddleware<T = unknown>(options?: TimeoutMiddlewareOptions): QueryMiddleware<T>;
+declare function createDeadlineMiddleware<T = unknown>(options?: {
+    getDeadline?: (context: QueryMiddlewareContext) => number | undefined;
+}): QueryMiddleware<T>;
+
+declare function createLoggingMiddleware<T = unknown>(options?: LoggingMiddlewareOptions): QueryMiddleware<T>;
+declare function createMetricsMiddleware<T = unknown>(options?: {
+    onQuery?: (metrics: MiddlewareQueryMetrics) => void;
+    buckets?: number[];
+}): QueryMiddleware<T>;
+interface MiddlewareQueryMetrics {
+    sql: string;
+    duration: number;
+    success: boolean;
+    cached: boolean;
+    rowCount: number;
+    retries: number;
+    bucket: number;
+    timestamp: Date;
+}
+
+interface ClientOptions {
+    provider: 'mysql' | 'postgresql' | 'postgres';
+    url?: string;
+    connection?: ConnectionConfig & {
+        poolMin?: number;
+        poolMax?: number;
+        poolIdleTimeout?: number;
+        poolAcquireTimeout?: number;
+        charset?: string;
+        timezone?: string;
+        multipleStatements?: boolean;
+        dateStrings?: boolean;
+        supportBigNumbers?: boolean;
+        bigNumberStrings?: boolean;
+        schema?: string;
+        searchPath?: string[];
+        statement_timeout?: number;
+        query_timeout?: number;
+        application_name?: string;
+    };
+    cache?: boolean | {
+        provider: 'redis';
+        url?: string;
+        connection?: ConnectionConfig & {
+            db?: number;
+            sentinels?: Array<{
+                host: string;
+                port: number;
+            }>;
+            name?: string;
+            sentinelPassword?: string;
+            retryStrategy?: (times: number) => number;
+            maxRetriesPerRequest?: number;
+            enableReadyCheck?: boolean;
+            enableOfflineQueue?: boolean;
+            cluster?: Array<{
+                host: string;
+                port: number;
+            }>;
+        };
+    };
+    encryption?: boolean | {
+        algorithm?: string;
+        key?: string;
+        keyRotationInterval?: number;
+        autoEncryptFields?: Record<string, string[]>;
+    };
+    logger?: boolean | Console | {
+        level?: string;
+        prettyPrint?: boolean;
+        customLogger?: (level: string, message: string, meta?: any) => void;
+    };
+    monitoring?: {
+        enabled?: boolean;
+        slowQueryThreshold?: number;
+        captureStackTrace?: boolean;
+        metricsCollector?: (metric: any) => void;
+    };
+    healthCheck?: {
+        enabled?: boolean;
+        interval?: number;
+        timeout?: number;
+        retries?: number;
+    };
+    multiTenant?: {
+        enabled?: boolean;
+        tenantIdField?: string;
+        tenantIdHeader?: string;
+        isolationLevel?: 'schema' | 'database' | 'row';
+        tenantResolver?: (context: any) => Promise<string>;
+    };
+    migrations?: {
+        directory?: string;
+        tableName?: string;
+        strategy?: 'safe' | 'force' | 'dry-run';
+        beforeMigrate?: (migration: any) => Promise<void>;
+        afterMigrate?: (migration: any) => Promise<void>;
+        rollbackOnError?: boolean;
+        validateChecksum?: boolean;
+    };
+    typeMappings?: {
+        pg_to_js?: Record<string, (value: any) => any>;
+        js_to_pg?: Record<string, (value: any) => any>;
+    };
+    poolSize?: number;
+    ssl?: boolean | any;
+}
+declare class DBBridge$2 {
+    private static instances;
+    private adapter;
+    private connected;
+    readonly options: ClientOptions;
+    constructor(options: ClientOptions);
+    static create(options: ClientOptions): DBBridge$2;
+    static getInstance(name: string, options?: ClientOptions): DBBridge$2;
+    static fromUrl(url: string, options?: Partial<ClientOptions>): DBBridge$2;
+    private static parseProvider;
+    private createAdapter;
+    private parseConnectionUrl;
+    connect(): Promise<void>;
+    from<T = any>(table: string, alias?: string): QueryBuilder<T>;
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    insert<T = any>(table: string, data: Record<string, any> | Record<string, any>[]): Promise<QueryResult<T>>;
+    update<T = any>(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<T>>;
+    delete<T = any>(table: string, where: Record<string, any>): Promise<QueryResult<T>>;
+    transaction(): Promise<Transaction>;
+    disconnect(): Promise<void>;
+    getAdapter(): DatabaseAdapter;
+    isConnected(): boolean;
+    ping(): Promise<boolean>;
+}
+
+declare enum DatabaseType$2 {
+    MySQL = "mysql",
+    PostgreSQL = "postgresql",
+    Postgres = "postgres",
+    Redis = "redis"
+}
+type DatabaseTypeString = 'mysql' | 'postgresql' | 'postgres' | 'redis';
+interface DBBridgeConfig$1 {
+    type: DatabaseType$2 | DatabaseTypeString;
+    connection: ConnectionConfig;
+    options?: {
+        logging?: boolean;
+        logger?: any;
+        autoConnect?: boolean;
+        pool?: {
+            min?: number;
+            max?: number;
+        };
+    };
+}
+declare class DBBridge$1 {
+    private adapter?;
+    private readonly config;
+    private _dialect?;
+    private _queryBuilder?;
+    constructor(config: DBBridgeConfig$1);
+    static mysql(connection: ConnectionConfig, options?: any): DBBridge$1;
+    static createMySQL(connection: ConnectionConfig, options?: any, autoConnect?: boolean): Promise<DBBridge$1>;
+    static postgresql(connection: ConnectionConfig, options?: any): DBBridge$1;
+    static createPostgreSQL(connection: ConnectionConfig, options?: any, autoConnect?: boolean): Promise<DBBridge$1>;
+    static redis(connection?: ConnectionConfig, options?: any): DBBridge$1;
+    static createRedis(connection?: ConnectionConfig, options?: any, autoConnect?: boolean): Promise<DBBridge$1>;
+    static create(config: DBBridgeConfig$1, autoConnect?: boolean): Promise<DBBridge$1>;
+    connect(): Promise<void>;
+    private loadAdapter;
+    private loadRedisAdapter;
+    private loadMySQLAdapter;
+    private loadPostgreSQLAdapter;
+    disconnect(): Promise<void>;
+    query<T = any>(sql: string, params?: any[]): Promise<{
+        rows: T[];
+        fields?: any[];
+    }>;
+    execute(sql: string, params?: any[]): Promise<any>;
+    table<T = any>(tableName: string): QueryBuilder<T>;
+    private configureQueryBuilder;
+    from<T = any>(tableName: string): QueryBuilder<T>;
+    transaction<T>(callback: (trx: any) => Promise<T>): Promise<T>;
+    prepare(sql: string, options?: any): Promise<any>;
+    private ensureConnected;
+    getAdapter(): DatabaseAdapter | undefined;
+    getDialect(): SQLDialect;
+    qb(): ModularQueryBuilder;
+    getDatabaseType(): DatabaseType$2 | DatabaseTypeString;
+}
+
+type DatabaseType$1 = 'mysql' | 'postgresql' | 'postgres' | 'redis';
+interface CachedDBBridgeConfig {
+    type: DatabaseType$1;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    connectionString?: string;
+    cache?: CacheConfig;
+    options?: {
+        logging?: boolean;
+        logger?: any;
+        pool?: {
+            min?: number;
+            max?: number;
+        };
+    };
+}
+declare class CacheableQuery<T = unknown> implements PromiseLike<QueryResult<T>> {
+    private readonly sql;
+    private readonly params;
+    private readonly executor;
+    private executed;
+    private cacheConfig;
+    private result;
+    constructor(sql: string, params: QueryParams | undefined, executor: (sql: string, params?: QueryParams, cache?: QueryCacheConfig | null) => Promise<QueryResult<T>>, globalCache: boolean);
+    $withCache(options?: boolean | QueryCacheConfig): this;
+    cache(options?: boolean | QueryCacheConfig): this;
+    execute(): Promise<QueryResult<T>>;
+    then<TResult1 = QueryResult<T>, TResult2 = never>(onfulfilled?: ((value: QueryResult<T>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+declare class CachedDBBridge extends EventEmitter {
+    private adapter?;
+    private cacheAdapter?;
+    private cacheAPI?;
+    private keyGenerator;
+    private readonly config;
+    constructor(config: CachedDBBridgeConfig);
+    static mysql(config: Omit<CachedDBBridgeConfig, 'type'> & {
+        host?: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database?: string;
+    }): CachedDBBridge;
+    static postgresql(config: Omit<CachedDBBridgeConfig, 'type'> & {
+        host?: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database?: string;
+    }): CachedDBBridge;
+    static postgres(config: Omit<CachedDBBridgeConfig, 'type'>): CachedDBBridge;
+    get $cache(): {
+        invalidate: CacheAPI['invalidate'];
+        clear: CacheAPI['clear'];
+        warmup: (queries: Array<{
+            sql: string;
+            params?: unknown[];
+            ttl?: number;
+        }>) => Promise<{
+            success: number;
+            failed: number;
+        }>;
+        stats: () => ReturnType<CacheAPI['getStats']>;
+        resetStats: () => void;
+        key: () => CacheKeyGenerator;
+    };
+    get isCacheEnabled(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = unknown>(sql: string, params?: QueryParams): CacheableQuery<T>;
+    execute<T = unknown>(sql: string, params?: QueryParams): Promise<QueryResult<T>>;
+    table<T = unknown>(tableName: string): QueryBuilder<T>;
+    from<T = unknown>(tableName: string): QueryBuilder<T>;
+    transaction<T>(callback: (trx: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    getAdapter(): DatabaseAdapter | undefined;
+    getCacheAdapter(): CacheAdapter | undefined;
+    ping(): Promise<boolean>;
+    get isConnected(): boolean;
+    private setupCache;
+    private loadAdapter;
+    private loadMySQLAdapter;
+    private loadPostgreSQLAdapter;
+    private loadRedisAdapter;
+    private configureQueryBuilder;
+    private ensureConnected;
+    private extractTables;
+}
+
+type DatabaseType = 'mysql' | 'postgresql' | 'postgres';
+interface DBBridgeConfig {
+    type: DatabaseType;
+    connection: ConnectionConfig;
+    options?: {
+        logging?: boolean;
+        logger?: any;
+        pool?: {
+            min?: number;
+            max?: number;
+        };
+    };
+}
+interface AdapterFactory {
+    createAdapter(config: DBBridgeConfig): DatabaseAdapter;
+}
+declare function registerAdapterFactory(type: DatabaseType, factory: AdapterFactory): void;
+declare function createAdapter(config: DBBridgeConfig): DatabaseAdapter;
+declare class DBBridge {
+    private adapter?;
+    private readonly config;
+    constructor(config: DBBridgeConfig);
+    static mysql(connection: ConnectionConfig, options?: any): DBBridge;
+    static postgresql(connection: ConnectionConfig, options?: any): DBBridge;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(sql: string, params?: any[]): Promise<{
+        rows: T[];
+        fields?: any[];
+    }>;
+    execute(sql: string, params?: any[]): Promise<any>;
+    table<T = any>(tableName: string): QueryBuilder<T>;
+    private configureQueryBuilder;
+    from<T = any>(tableName: string): QueryBuilder<T>;
+    transaction<T>(callback: (trx: any) => Promise<T>): Promise<T>;
+    prepare(sql: string, options?: any): Promise<any>;
+    private ensureConnected;
+    getAdapter(): DatabaseAdapter | undefined;
+}
+
+export { ANALYSIS_DEFAULTS, type AdapterFactory, type AggregateContext, type AggregateFunction, BaseAdapter, type BaseAdapterOptions, BaseQueryBuilder, BaseTransaction, type BetweenOperator, CACHE_DEFAULTS, CONNECTION_DEFAULTS, CRYPTO_DEFAULTS, CacheAPI, type CacheAPIOptions, type CacheAPIStats, type CacheAdapter, type CacheConfig, type CacheEntry, CacheError, type CacheInvalidateOptions, CacheKeyGenerator, type CacheKeyOptions, type CacheKeyPattern, CacheManager, type CacheManagerOptions, type CacheMiddlewareOptions, type CacheOption, type CacheOptions$1 as CacheOptions, type CacheSetOptions, type CacheStats, type CacheStrategy, type CacheWarmupQuery, CacheableQuery, CachedAdapter, type CachedAdapterOptions, CachedDBBridge, type CachedDBBridgeConfig, DBBridge$2 as Client, type ClientOptions, type ColumnDefinition, type ColumnName, type ComparisonOperator, type CompressionOptions, type ConnectionConfig, ConnectionError, type ConnectionMetrics, type ConnectionStringConfig, type CryptoAlgorithm, CryptoAlgorithms, type CryptoConfig, CryptoProvider, type CursorPaginationResult, DBBridge$1 as DBBridge, type DBBridgeConfig$1 as DBBridgeConfig, DBBridgeError, DBBridge as DBBridgeFactory, DEFAULT_POOL_CONFIG, DEFAULT_TIMEOUTS, DURATION_BUCKETS, type DatabaseAdapter, DatabaseError, DatabaseType$2 as DatabaseType, type DateFilterContext, type DeepPartial, type DeepRequired, DefaultCacheStrategy, DeleteBuilder, type DeleteResult, type DialectConfig, type DialectDatabaseType, DialectFactory, type EncryptedData, type EncryptionContext, type EncryptionOptions, type ExecuteResult, type ExtractRow, type FieldInfo, type FieldType, HEALTH_DEFAULTS, type HealthCheckOptions, type HealthCheckResult, HealthChecker, type HostConnectionConfig, ISOLATION_LEVELS, type InOperator, type InferQueryResult, InsertBuilder, type InsertData, type InsertResult, IsolationLevel, type JoinClause, type JoinType, LOGGING_DEFAULTS, type LikeOperator, type LogLevel, type Logger, type LoggingMiddlewareOptions, MetricsCollector, type MetricsSnapshot, type MiddlewareCacheAdapter, MiddlewareChain, type MiddlewareConfig, type MiddlewareLogger, type MiddlewareQueryMetrics, type Migration, type MigrationHistory, MigrationRunner, type MigrationRunnerOptions, ModularCacheManager, ModularPerformanceMonitor, type ModularQueryBuilder, type ModularQueryBuilderOptions, MySQLDialect, type NextMiddleware, NotImplementedError, type NullOperator, type Nullable, type OptionalKeys, type OrderByClause, type OrderDirection, POOL_DEFAULTS, POOL_DEFAULTS_LEGACY, type PaginationContext, type PaginationResult, type PaginationState, PerformanceMonitor, type PerformanceReport$1 as PerformanceReport, type PerformanceTrace$1 as PerformanceTrace, type PoolConfig, PoolExhaustedError, type PoolStats, PostgreSQLDialect, type PreparedStatement, QUERY_DEFAULTS, type QueryBuilder, type QueryBuilderCacheConfig, type QueryBuilderOptions, type QueryCacheConfig, type QueryCacheOptions, QueryContext, type QueryContextCacheConfig, QueryError, type QueryExecutor, type QueryMetrics, type QueryMiddleware, type QueryMiddlewareContext, type QueryMiddlewareResult, type QueryOptions, type QueryParams, type QueryPlan$1 as QueryPlan, type QueryResult, type QueryState, QueryTimeoutError, type QueryValue, RETRY_DEFAULTS, type RequireKeys, type RetryMiddlewareOptions, type RetryOptions, SIZE_UNITS, type SQLCommand, SQLDialect, type SSLConfig, type SafeSQL, SelectBuilder, type SelectResult, SmartCacheStrategy, type StrictConnectionConfig, type StrictFieldInfo, type StrictIsolationLevel, type StrictPoolConfig, type StrictQueryResult, type SystemMetrics, TIME_UNITS, type TableName, type TableSchema, TimeoutError, type TimeoutMiddlewareOptions, type Transaction, type TransactionConnection, TransactionError, type TransactionMetrics, type TransactionOptions, UpdateBuilder, type UpdateData, type UpdateResult, ValidationError, WhereBuilder, type WhereClause, type WhereConditionInput, type WhereOperator, avg, cacheKey, chunk, composeMiddleware, compress, count, createAdapter, createCacheInvalidationMiddleware, createCacheKeyPattern, createCacheMiddleware, createCachedAdapter, createCircuitBreakerMiddleware, createDeadlineMiddleware, createLoggingMiddleware, createMetricsMiddleware, createModularQueryBuilder, createQueryState, createRetryMiddleware, createTimeoutMiddleware, crypto, cursorPaginate, decompress, encryptRow, exists, generateCacheKey, generateUUID, getCompressionRatio, isCompressed, isDeleteResult, isInsertResult, isSelectResult, isUpdateResult, max, min, paginate, parseCacheKey, processDataForEncryption, processResultsForDecryption, registerAdapterFactory, retry, sanitizeCacheKey, shouldCompress, sql, sum, validateColumnName, validateConnectionConfig, validateSQL, validateTableName, whereBetweenDates, whereDate, whereDay, whereLastDays, whereMonth, whereToday, whereYear, whereYesterday, withTimeout };