/**
 * PostgreSQL Adapter
 *
 * Database adapter for PostgreSQL databases using the 'pg' library.
 * Implements all methods from BaseAdapter with PostgreSQL-specific optimizations.
 */
import { BaseAdapter, DatabaseFeature } from './base.adapter';
import { DatabaseType, IsolationLevel } from '../types/enums';
import { IAdapterConnectionOptions, IAdapterConnectionResult } from '../types/connection.interface';
import { IQueryResult, IRawQueryOptions, IRawQueryResult, IBuiltQuery } from '../types/query.interface';
import { IInsertOptions, IInsertResult, IUpdateOptions, IUpdateResult, IDeleteOptions, IDeleteResult, IUpsertOptions, IUpsertResult } from '../types/write.interface';
import { ITransactionContext, ISavepoint } from '../types/transaction.interface';
import { ICountOptions, ISumOptions, IAvgOptions, IMinMaxOptions, IAggregateResult, IGroupByResult, IBuiltAggregation } from '../types/aggregation.interface';
import { ITableDefinition, IAlterTableOperation, ITableSchema, ITableInfo, IIndexDefinition, IIndexInfo, IIndexStatistics, ICreateTableOptions } from '../types/schema.interface';
/**
 * PostgreSQL database adapter
 * Provides PostgreSQL-specific implementations for all database operations
 */
export declare class PostgreSQLAdapter extends BaseAdapter {
    protected readonly databaseType = DatabaseType.POSTGRESQL;
    private pool;
    connect(options: IAdapterConnectionOptions): Promise<IAdapterConnectionResult>;
    testConnection(options: IAdapterConnectionOptions): Promise<IAdapterConnectionResult>;
    disconnect(): Promise<void>;
    query<T = any>(query: IBuiltQuery): Promise<IQueryResult<T>>;
    raw<T = any>(options: IRawQueryOptions): Promise<IRawQueryResult<T>>;
    insert<T = any>(options: IInsertOptions): Promise<IInsertResult<T>>;
    update<T = any>(options: IUpdateOptions): Promise<IUpdateResult<T>>;
    delete(options: IDeleteOptions): Promise<IDeleteResult>;
    upsert<T = any>(options: IUpsertOptions): Promise<IUpsertResult<T>>;
    count(options: ICountOptions): Promise<number>;
    sum(options: ISumOptions): Promise<number>;
    avg(options: IAvgOptions): Promise<number>;
    min(options: IMinMaxOptions): Promise<any>;
    max(options: IMinMaxOptions): Promise<any>;
    aggregate(builtAggregation: IBuiltAggregation): Promise<IAggregateResult>;
    groupBy<T = any>(builtGroupBy: IBuiltAggregation): Promise<IGroupByResult<T>[]>;
    beginTransaction(isolationLevel?: IsolationLevel, readOnly?: boolean, timeout?: number): Promise<ITransactionContext>;
    commitTransaction(context: ITransactionContext): Promise<void>;
    rollbackTransaction(context: ITransactionContext): Promise<void>;
    createSavepoint(context: ITransactionContext, name: string): Promise<ISavepoint>;
    releaseSavepoint(context: ITransactionContext, savepoint: ISavepoint): Promise<void>;
    rollbackToSavepoint(context: ITransactionContext, savepoint: ISavepoint): Promise<void>;
    supportsSavepoints(): boolean;
    createTable(definition: ITableDefinition, options?: ICreateTableOptions): Promise<void>;
    alterTable(tableName: string, operations: IAlterTableOperation[]): Promise<void>;
    dropTable(tableName: string, ifExists?: boolean, cascade?: boolean): Promise<void>;
    listTables(): Promise<string[]>;
    listTablesWithInfo(): Promise<ITableInfo[]>;
    tableExists(tableName: string): Promise<boolean>;
    getTableSchema(tableName: string): Promise<ITableSchema>;
    createIndex(index: IIndexDefinition, ifNotExists?: boolean, concurrent?: boolean): Promise<void>;
    dropIndex(tableName: string, indexName: string, ifExists?: boolean, concurrent?: boolean, cascade?: boolean): Promise<void>;
    listIndexes(tableName: string, includeSystem?: boolean): Promise<IIndexInfo[]>;
    getIndexStatistics(tableName: string, indexName?: string): Promise<IIndexStatistics[]>;
    escapeIdentifier(identifier: string): string;
    /**
     * Format a field reference for use in WHERE clauses.
     * Handles JSON path notation (e.g., "metadata.role" becomes "metadata"->>'role')
     */
    private formatFieldRef;
    escapeValue(value: any): string;
    /**
     * Check if value is an update operator object
     * Supports both lowercase (new) and uppercase (legacy) operators
     */
    private isUpdateOperator;
    getParameterPlaceholder(index: number): string;
    getColumnTypeString(columnType: string, options?: {
        minLength?: number;
        maxLength?: number;
        precision?: number;
        scale?: number;
        enumValues?: string[];
        arrayType?: string;
    }): string;
    getSupportedFeatures(): DatabaseFeature[];
    parseError(error: any): {
        type: string;
        message: string;
        code?: string;
        details?: Record<string, any>;
    };
    private ensureConnected;
    private buildWhereClause;
    private buildCountQuery;
    private buildColumnDefinition;
    private buildConstraintDefinition;
    /**
     * Detect whether SSL should be enabled based on the connection URL and explicit option.
     *
     * Auto-enables for managed cloud PostgreSQL services that enforce SSL:
     *   Azure  — *.postgres.database.azure.com
     *   GCP    — *.sql.goog  (Cloud SQL Private Service Connect)
     *            *.cloudsql.google.com  (Cloud SQL with custom DNS)
     *   AWS    — *.rds.amazonaws.com (RDS/Aurora)
     *
     * Users can also opt in explicitly via ?ssl=true or ?sslmode=require in the URL.
     * Note: pg natively reads ?sslmode from the connection string, but the pool-level
     * ssl config is still needed for consistent behaviour across pg versions.
     */
    private detectSsl;
    private mapIsolationLevel;
}