import { QueryHookPlugin, QueryHookContext, QueryExecutionContext } from '../index';
/**
 * SQL Query Types
 */
export type QueryType = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'CREATE' | 'ALTER' | 'DROP' | 'TRUNCATE' | 'BEGIN' | 'COMMIT' | 'ROLLBACK' | 'WITH' | 'OTHER';
/**
 * Context for query type detection
 */
export interface QueryTypeContext {
    builder: any;
    sql: string;
    timestamp: Date;
    parameters?: any[];
    queryType: QueryType;
    methodName?: string;
    executionTime?: number;
}
/**
 * Configuration options for QueryTypeDetector plugin
 */
export interface QueryTypeDetectorOptions {
    /**
     * Called when any query is detected
     */
    onQueryType?: (context: QueryTypeContext) => void;
    /**
     * Called specifically for SELECT queries
     */
    onSelect?: (context: QueryTypeContext) => void;
    /**
     * Called specifically for INSERT queries
     */
    onInsert?: (context: QueryTypeContext) => void;
    /**
     * Called specifically for UPDATE queries
     */
    onUpdate?: (context: QueryTypeContext) => void;
    /**
     * Called specifically for DELETE queries
     */
    onDelete?: (context: QueryTypeContext) => void;
    /**
     * Called for DDL operations (CREATE, ALTER, DROP, TRUNCATE)
     */
    onDDL?: (context: QueryTypeContext) => void;
    /**
     * Called for transaction control (BEGIN, COMMIT, ROLLBACK)
     */
    onTransaction?: (context: QueryTypeContext) => void;
    /**
     * Enable logging of query types
     */
    enableLogging?: boolean;
    /**
     * Only monitor specific query types
     */
    monitorTypes?: QueryType[];
}
/**
 * Extract query type from QueryBuilder's expressionMap (preferred method)
 * This is more reliable than string parsing because it uses TypeORM's internal state
 *
 * For QueryBuilder queries, TypeORM's expressionMap.queryType provides:
 * - SELECT, INSERT, UPDATE, DELETE (always available from expressionMap)
 *
 * For DDL and transaction control, we check the generated SQL since TypeORM's
 * expressionMap doesn't distinguish these types.
 *
 * @param builder - The QueryBuilder instance
 * @returns The query type
 *
 * @example
 * ```typescript
 * const repo = dataSource.getRepository(User);
 *
 * // SELECT query
 * const qb1 = repo.createQueryBuilder('user').where('user.id = :id', { id: 1 });
 * extractQueryTypeFromBuilder(qb1); // "SELECT"
 *
 * // INSERT query
 * const qb2 = repo.createQueryBuilder().insert().into(User).values({ name: 'John' });
 * extractQueryTypeFromBuilder(qb2); // "INSERT"
 *
 * // UPDATE query
 * const qb3 = repo.createQueryBuilder().update(User).set({ name: 'Jane' });
 * extractQueryTypeFromBuilder(qb3); // "UPDATE"
 *
 * // DELETE query
 * const qb4 = repo.createQueryBuilder().delete().from(User);
 * extractQueryTypeFromBuilder(qb4); // "DELETE"
 * ```
 */
export declare function extractQueryTypeFromBuilder(builder: any): QueryType;
/**
 * Extract query type from SQL string (fallback method)
 * Used when QueryBuilder's expressionMap is not available (e.g., raw SQL queries)
 *
 * @param query - The SQL query string
 * @returns The query type
 *
 * @example
 * ```typescript
 * const type = extractQueryTypeFromSQL('SELECT * FROM users'); // "SELECT"
 * const type = extractQueryTypeFromSQL('CREATE INDEX ...'); // "CREATE"
 * ```
 */
export declare function extractQueryTypeFromSQL(query: string): QueryType;
/**
 * Get query type from context (uses expressionMap first, falls back to SQL parsing)
 * This is the preferred method as it tries expressionMap first
 *
 * @param context - Query hook context
 * @returns The query type
 */
export declare function getQueryType(context: QueryHookContext | QueryExecutionContext): QueryType;
/**
 * Check if query type is a DDL operation
 */
export declare function isDDL(queryType: QueryType): boolean;
/**
 * Check if query type is a DML operation
 */
export declare function isDML(queryType: QueryType): boolean;
/**
 * Check if query type is a transaction control operation
 */
export declare function isTransaction(queryType: QueryType): boolean;
/**
 * Creates a Query Type Detector Plugin
 *
 * This plugin detects the type of SQL query being executed using TypeORM's
 * internal expressionMap (preferred) or SQL string parsing (fallback).
 *
 * @param options - Configuration options
 * @returns QueryHookPlugin instance
 *
 * @example
 * ```typescript
 * import { registerPlugin, QueryTypeDetectorPlugin } from 'typeorm-query-hooks';
 *
 * registerPlugin(QueryTypeDetectorPlugin({
 *   enableLogging: true,
 *   onSelect: (context) => {
 *     console.log('SELECT query detected:', context.sql);
 *   },
 *   onInsert: (context) => {
 *     console.log('INSERT query detected');
 *   },
 *   onDDL: (context) => {
 *     console.warn('DDL operation detected:', context.queryType);
 *   }
 * }));
 * ```
 *
 * @example Filter specific query types
 * ```typescript
 * registerPlugin(QueryTypeDetectorPlugin({
 *   monitorTypes: ['INSERT', 'UPDATE', 'DELETE'],
 *   onQueryType: (context) => {
 *     // Only called for INSERT, UPDATE, DELETE
 *     console.log(`Write operation: ${context.queryType}`);
 *   }
 * }));
 * ```
 */
export declare function QueryTypeDetectorPlugin(options?: QueryTypeDetectorOptions): QueryHookPlugin;
/**
 * Default Query Type Detector Plugin instance
 * Logs all query types
 */
export declare const DefaultQueryTypeDetector: QueryHookPlugin;
//# sourceMappingURL=query-type-detector.d.ts.map