import { type ChxConfig, type ColumnDefinition, type ProjectionDefinition, type SkipIndexDefinition } from '@chkit/core';
import { type ClickHouseSettings, createClient } from '@clickhouse/client';
export interface QueryStatus {
    status: 'running' | 'finished' | 'failed' | 'unknown';
    readRows?: number;
    readBytes?: number;
    writtenRows?: number;
    writtenBytes?: number;
    elapsedMs?: number;
    durationMs?: number;
    error?: string;
}
export type { ClickHouseSettings };
export interface ClickHouseInsertParams<T extends Record<string, unknown>> {
    table: string;
    values: T[];
    compressed?: boolean;
}
export interface ClickHouseJsonQueryResult<T extends Record<string, unknown> = Record<string, unknown>> {
    data: T[];
    meta: Array<{
        name: string;
        type: string;
    }>;
    rows: number;
    statistics?: {
        elapsed?: number;
        rows_read?: number;
        bytes_read?: number;
    };
    query_id?: string;
}
export interface ClickHouseExecutor {
    command(sql: string): Promise<void>;
    query<T>(sql: string, settings?: ClickHouseSettings): Promise<T[]>;
    queryJson?<T extends Record<string, unknown>>(sql: string, settings?: ClickHouseSettings): Promise<ClickHouseJsonQueryResult<T>>;
    insert<T extends Record<string, unknown>>(params: ClickHouseInsertParams<T>): Promise<void>;
    listSchemaObjects(): Promise<SchemaObjectRef[]>;
    listTableDetails(databases: string[]): Promise<IntrospectedTable[]>;
    /** Submit a query asynchronously. ClickHouse accepts the query and processes it server-side.
     *  Returns immediately without waiting for completion.
     *  @param sql - The SQL to execute
     *  @param queryId - Optional deterministic query_id (useful for resumability). Auto-generated if omitted.
     *  @returns The query_id assigned to this query. */
    submit(sql: string, queryId?: string): Promise<string>;
    /** Check the status of a previously submitted query.
     *  Checks system.processes first (running?), then system.query_log (finished/failed?).
     *  @param queryId - The query_id returned by submit()
     *  @param options.afterTime - Only consider query_log entries for queries started at or after this ISO timestamp.
     *    Useful when resubmitting with the same query_id to ignore stale entries from previous attempts. */
    queryStatus(queryId: string, options?: {
        afterTime?: string;
    }): Promise<QueryStatus>;
    close(): Promise<void>;
}
export interface SchemaObjectRef {
    kind: 'table' | 'view' | 'materialized_view' | 'dictionary';
    database: string;
    name: string;
}
export interface SystemTableRow {
    database: string;
    name: string;
    engine: string;
    create_table_query?: string;
}
export interface SystemColumnRow {
    database: string;
    table: string;
    name: string;
    type: string;
    default_kind?: string;
    default_expression?: string;
    comment?: string;
    position: number;
    compression_codec?: string;
}
export interface SystemSkippingIndexRow {
    database: string;
    table: string;
    name: string;
    expr: string;
    type: string;
    granularity: number;
}
export interface IntrospectedTable {
    database: string;
    name: string;
    engine?: string;
    primaryKey?: string;
    orderBy?: string;
    uniqueKey?: string;
    partitionBy?: string;
    columns: ColumnDefinition[];
    settings: Record<string, string>;
    indexes: SkipIndexDefinition[];
    projections: ProjectionDefinition[];
    ttl?: string;
}
type ClickHouseClient = ReturnType<typeof createClient>;
type ClickHouseConfig = NonNullable<ChxConfig['clickhouse']>;
type ClickHouseClientOptions = {
    compression?: {
        request?: boolean;
        response?: boolean;
    };
};
export { parseEngineFromCreateTableQuery, parseOrderByFromCreateTableQuery, parsePartitionByFromCreateTableQuery, parsePrimaryKeyFromCreateTableQuery, parseProjectionsFromCreateTableQuery, parseSettingsFromCreateTableQuery, parseTTLFromCreateTableQuery, parseUniqueKeyFromCreateTableQuery, } from './create-table-parser.js';
export { parseCommentFromCreateDictionaryQuery, parseDictionaryAttributesFromCreateDictionaryQuery, parseDictionaryPrimaryKeyFromCreateDictionaryQuery, parseDictionaryRangeFromCreateDictionaryQuery, parseDictionarySettingsFromCreateDictionaryQuery, parseLayoutFromCreateDictionaryQuery, parseLifetimeFromCreateDictionaryQuery, parseSourceFromCreateDictionaryQuery, type ParsedDictionaryAttribute, } from './create-dictionary-parser.js';
export declare function inferSchemaKindFromEngine(engine: string): SchemaObjectRef['kind'] | null;
export declare function normalizeColumnFromSystemRow(row: SystemColumnRow): ColumnDefinition;
export declare function normalizeIndexFromSystemRow(row: SystemSkippingIndexRow): SkipIndexDefinition;
export declare function buildIntrospectedTables(tables: SystemTableRow[], columns: SystemColumnRow[], indexes: SystemSkippingIndexRow[]): IntrospectedTable[];
/**
 * Builds a clean, user-facing message for a connection-time error, or returns
 * `undefined` when the error is not one we recognize (caller rethrows as-is).
 * Pure so it can be unit-tested without catching thrown errors.
 */
export declare function formatConnectionError(error: unknown, url: string, username?: string): string | undefined;
export declare function wrapConnectionError(error: unknown, url: string, username?: string): never;
export declare function isUnknownDatabaseError(error: unknown): boolean;
/**
 * Thrown when a ClickHouse query failed mid-flight after the server already
 * committed an HTTP 200 response by emitting progress headers. In that
 * scenario the error is reported via the `x-clickhouse-exception-code`
 * response header rather than as an HTTP error — @clickhouse/client does not
 * surface it as a thrown error, so we must detect it ourselves and throw.
 */
export declare class ClickHouseStreamedException extends Error {
    readonly code: string;
    readonly exceptionTag: string | undefined;
    readonly query_id: string | undefined;
    constructor(input: {
        code: string;
        exceptionTag: string | undefined;
        query_id: string | undefined;
        sql: string | undefined;
    });
}
/**
 * Throws if the response carries a non-zero `x-clickhouse-exception-code`
 * header. This happens when ClickHouse sends progress headers (committing
 * HTTP 200) and then the query errors out — the error is reported in
 * headers, not by HTTP status, and @clickhouse/client does not raise it.
 */
export declare function assertStreamedQuerySucceeded(input: {
    response_headers: Record<string, string | string[] | undefined> | undefined;
    query_id: string;
    sql: string | undefined;
}): void;
export { waitForColumn, waitForDDLPropagation, waitForDictionary, waitForTable, waitForTableAbsent, waitForView, } from './ddl-propagation.js';
export declare function createStatelessClickHouseClient(config: ClickHouseConfig, clickhouseSettings?: ClickHouseSettings, options?: ClickHouseClientOptions): ClickHouseClient;
/**
 * Creates a ClickHouse client that sends one session_id with every request.
 * Use only for workflows that need session state, such as temporary tables or
 * session-level settings. ClickHouse allows only one in-flight query per HTTP
 * session, so callers must serialize all requests made through this client.
 */
export declare function createSessionClickHouseClient(config: ClickHouseConfig, clickhouseSettings?: ClickHouseSettings, sessionId?: `${string}-${string}-${string}-${string}-${string}`, options?: ClickHouseClientOptions): ClickHouseClient;
export declare function createExecutorWithClient(config: ClickHouseConfig, client: ClickHouseClient, options?: {
    createCompressedClient?: () => ClickHouseClient;
}): ClickHouseExecutor;
export declare function createClickHouseExecutor(config: ClickHouseConfig): ClickHouseExecutor;
export declare function createStatelessClickHouseExecutor(config: ClickHouseConfig): ClickHouseExecutor;
//# sourceMappingURL=index.d.ts.map