/**
 * DynamoDB Adapter
 *
 * Database adapter for AWS DynamoDB using the '@aws-sdk/client-dynamodb' and
 * '@aws-sdk/lib-dynamodb' libraries.
 * Implements all methods from BaseAdapter with DynamoDB-specific operations.
 *
 * Note: DynamoDB is a NoSQL key-value store with different concepts:
 * - Tables have a partition key (and optional sort key)
 * - No traditional transactions (uses TransactWriteItems/TransactGetItems)
 * - No savepoints
 * - Different query patterns than SQL databases
 */
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';
/**
 * DynamoDB database adapter
 * Provides DynamoDB-specific implementations for all database operations
 */
export declare class DynamoDBAdapter extends BaseAdapter {
    protected readonly databaseType = DatabaseType.DYNAMODB;
    private dynamoClient;
    private docClient;
    private region;
    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;
    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 buildFilterExpression;
    private buildUpdateExpression;
    /**
     * Extract key condition from where clause if partition key is present.
     * This enables using Query instead of Scan for better performance.
     */
    private extractKeyCondition;
    /**
     * Get simple value from where clause for a specific field
     */
    private getWhereValue;
    /**
     * Get operator and value from where clause for a specific field
     */
    private getWhereOperator;
    private getTableKey;
    private waitForTableActive;
    private mapToDynamoType;
    private mapFromDynamoType;
    private chunkArray;
    private formatBytes;
}