/**
 * Cassandra Adapter
 *
 * Database adapter for Apache Cassandra using the 'cassandra-driver' library.
 * Implements all methods from BaseAdapter with Cassandra-specific operations.
 *
 * Key Cassandra concepts:
 * - Keyspace (like a database/schema)
 * - Column family/Table
 * - Partition key and clustering columns
 * - No JOINs - denormalized data model
 * - No transactions in the traditional sense (uses lightweight transactions)
 * - Eventual consistency by default
 */
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';
/**
 * Cassandra database adapter
 * Provides Cassandra-specific implementations for all database operations
 */
export declare class CassandraAdapter extends BaseAdapter {
    protected readonly databaseType = DatabaseType.CASSANDRA;
    private cassandraClient;
    private keyspace;
    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 getClusterVersion;
    private buildWhereClause;
    private buildColumnDefinition;
}