import { type EntityMeta, type FieldKey, type FieldOptions, type JsonMergeOp, type Query, type QueryComparisonOptions, type QueryConflictPaths, type QueryContext, type QueryDialect, type QueryOptions, type QueryPager, QueryRaw, type QueryRawFnOptions, type QuerySearch, type QuerySelect, type QuerySelectOptions, type QuerySortMap, type QueryWhere, type QueryWhereArray, type QueryWhereFieldOperatorMap, type QueryWhereMap, type QueryWhereOptions, type RelationOptions, type SqlDialect, type SqlQueryDialect, type Type, type UpdatePayload } from '../type/index.js';
import { type CallbackKey } from '../util/index.js';
import { AbstractDialect } from './abstractDialect.js';
export declare abstract class AbstractSqlDialect extends AbstractDialect implements QueryDialect, SqlQueryDialect {
    readonly dialect: SqlDialect;
    get escapeIdChar(): "\"" | "`";
    get beginTransactionCommand(): string;
    get commitTransactionCommand(): string;
    get rollbackTransactionCommand(): string;
    createContext(): QueryContext;
    addValue(values: unknown[], value: unknown): string;
    placeholder(_index: number): string;
    returningId<E>(entity: Type<E>): string;
    search<E>(ctx: QueryContext, entity: Type<E>, q?: Query<E>, opts?: QueryOptions): void;
    selectFields<E>(ctx: QueryContext, entity: Type<E>, select: QuerySelect<E> | QueryRaw[] | undefined, opts?: QuerySelectOptions): void;
    select<E>(ctx: QueryContext, entity: Type<E>, select: QuerySelect<E> | QueryRaw[] | undefined, opts?: QueryOptions): void;
    protected selectRelationFields<E>(ctx: QueryContext, entity: Type<E>, select: QuerySelect<E> | undefined, opts?: {
        prefix?: string;
    }): void;
    protected selectRelationJoins<E>(ctx: QueryContext, entity: Type<E>, select: QuerySelect<E> | undefined, opts?: {
        prefix?: string;
    }): void;
    /**
     * Iterates over joinable (11/m1) relations for a given select, resolving shared metadata.
     * Used by both `selectRelationFields` and `selectRelationJoins` to avoid duplicated iteration logic.
     */
    private forEachJoinableRelation;
    where<E>(ctx: QueryContext, entity: Type<E>, where?: QueryWhere<E>, opts?: QueryWhereOptions): void;
    compare<E>(ctx: QueryContext, entity: Type<E>, key: string, val: unknown, opts?: QueryComparisonOptions): void;
    protected compareLogicalOperator<E>(ctx: QueryContext, entity: Type<E>, key: '$and' | '$or' | '$not' | '$nor', val: QueryWhereArray<E>, opts: QueryComparisonOptions): void;
    compareFieldOperator<E, K extends keyof QueryWhereFieldOperatorMap<E>>(ctx: QueryContext, entity: Type<E>, key: FieldKey<E>, op: K, val: QueryWhereFieldOperatorMap<E>[K], opts?: QueryOptions): void;
    protected addValues(ctx: QueryContext, vals: unknown[]): void;
    /**
     * Build a comparison condition for a JSON field.
     * Used by both `$elemMatch` and dot-notation paths. Each dialect provides a `JsonFieldConfig`.
     */
    protected buildJsonFieldCondition(ctx: QueryContext, config: JsonFieldConfig, jsonPath: string, op: string, value: unknown): string;
    getComparisonKey<E>(ctx: QueryContext, entity: Type<E>, key: FieldKey<E>, { prefix }?: QueryOptions): void;
    sort<E>(ctx: QueryContext, entity: Type<E>, sort: QuerySortMap<E> | undefined, { prefix }: QueryOptions): void;
    pager(ctx: QueryContext, opts: QueryPager): void;
    count<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void;
    find<E>(ctx: QueryContext, entity: Type<E>, q?: Query<E>, opts?: QueryOptions): void;
    insert<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void;
    update<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, payload: UpdatePayload<E>, opts?: QueryOptions): void;
    upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E | E[]): void;
    protected getUpsertUpdateAssignments<E>(ctx: QueryContext, meta: EntityMeta<E>, conflictPaths: QueryConflictPaths<E>, payload: E | E[], callback?: (columnName: string) => string): string;
    protected getUpsertConflictPathsStr<E>(meta: EntityMeta<E>, conflictPaths: QueryConflictPaths<E>): string;
    delete<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void;
    escapeId(val: string, forbidQualified?: boolean, addDot?: boolean): string;
    protected getPersistables<E>(ctx: QueryContext, meta: EntityMeta<E>, payload: E | E[], callbackKey: CallbackKey): Record<string, unknown>[];
    protected getPersistable<E>(ctx: QueryContext, meta: EntityMeta<E>, payload: E, callbackKey: CallbackKey): Record<string, unknown>;
    protected formatPersistableValue<E>(ctx: QueryContext, field: FieldOptions | undefined, value: unknown): void;
    /**
     * Generate SQL for a JSONB merge and/or unset operation.
     * Called from `update()` when a field value has `$merge` and/or `$unset` operators.
     * Generates the full `"col" = <expression>` assignment.
     *
     * Base implementation uses MySQL-compatible syntax. Override in dialect subclasses.
     */
    protected formatJsonMerge<E>(ctx: QueryContext, escapedCol: string, value: JsonMergeOp<E>): void;
    /**
     * Checks if a value is a `$merge`/`$unset` operator object.
     */
    protected isJsonMergeOp(value: unknown): value is JsonMergeOp;
    /** Escapes a JSON key for safe interpolation into SQL string literals. */
    protected escapeJsonKey(key: string): string;
    getRawValue(ctx: QueryContext, opts: QueryRawFnOptions & {
        value: QueryRaw;
        autoPrefixAlias?: boolean;
    }): void;
    /**
     * Resolves a dot-notation key to its JSON field metadata.
     * Shared by `where()` and `sort()` to detect 'column.path' keys where 'column' is a JSON/JSONB field.
     *
     * @returns resolved metadata or `undefined` if the key is not a JSON dot-notation path
     */
    protected resolveJsonDotPath<E>(meta: EntityMeta<E>, key: string, prefix?: string): {
        root: string;
        jsonPath: string;
        config: JsonFieldConfig;
    } | undefined;
    /**
     * Compare a JSONB dot-notation path, e.g. `'settings.isArchived': { $ne: true }`.
     * Receives a pre-resolved `resolveJsonDotPath` result to avoid redundant computation.
     */
    protected compareJsonPath(ctx: QueryContext, resolved: {
        jsonPath: string;
        config: JsonFieldConfig;
    }, val: unknown): void;
    /**
     * Returns a dialect-specific `JsonFieldConfig` for accessing a nested JSON path.
     * Dialects should override this to provide their specific JSON accessor syntax.
     *
     * @param escapedColumn - The escaped column name (possibly prefixed with table name)
     * @param jsonPath - The dot-separated path within the JSON field (e.g. 'isArchived' or 'theme.color')
     */
    protected getJsonFieldConfig(escapedColumn: string, jsonPath: string): JsonFieldConfig;
    /**
     * Returns the dialect-invariant portion of `JsonFieldConfig`.
     * Dialects override this to provide casts, operators, and value binding.
     * Both `getJsonFieldConfig` (dot-notation) and `buildJsonFieldOperator` ($elemMatch) compose with this.
     */
    protected getBaseJsonConfig(): Omit<JsonFieldConfig, 'fieldAccessor'>;
    /**
     * Normalizes a raw WHERE value into an operator map.
     * Arrays become `$in`, scalars/null become `$eq`, objects pass through.
     */
    private normalizeWhereValue;
    /**
     * Filter by ManyToMany or OneToMany relation using an EXISTS subquery.
     * Generates: `EXISTS (SELECT 1 FROM ... WHERE local_fk = parent.id AND ...)`
     */
    protected compareRelation<E>(ctx: QueryContext, entity: Type<E>, key: string, val: QueryWhereMap<unknown>, rel: RelationOptions, opts: QueryComparisonOptions): void;
    abstract escape(value: unknown): string;
}
/**
 * Configuration for JSON field operations.
 * Each SQL dialect provides its own config to the shared buildJsonFieldCondition method.
 */
export type JsonFieldConfig = {
    /** Produces the field accessor expression, e.g. `elem->>'name'` or `json_extract(value, '$.name')` */
    fieldAccessor: (field: string) => string;
    /** Wraps an expression for numeric comparison, e.g. `(expr)::numeric` or `CAST(expr AS REAL)` */
    numericCast: (expr: string) => string;
    /** The LIKE keyword to use for case-sensitive matching, e.g. `'LIKE'` */
    likeFn: string;
    /** Builds a case-insensitive LIKE expression from a field and placeholder, e.g. `LOWER(field) LIKE ph` or `field ILIKE ph` */
    ilikeExpr: (field: string, placeholder: string) => string;
    /** The regexp operator, e.g. `'REGEXP'` or `'~'` */
    regexpOp: string;
    /** Binds a value and returns its placeholder string */
    addValue: (ctx: QueryContext, value: unknown) => string;
    /** Optional: custom $in expression (e.g. Postgres `= ANY()`). If omitted, uses `IN (v1, v2, ...)` */
    inExpr?: (field: string, placeholder: string) => string;
    /** Optional: custom $nin expression (e.g. Postgres `<> ALL()`). If omitted, uses `NOT IN (v1, v2, ...)` */
    ninExpr?: (field: string, placeholder: string) => string;
    /** Optional: null-safe `$ne` (e.g. Postgres `IS DISTINCT FROM`, SQLite `IS NOT`). If omitted, uses `<>` */
    neExpr?: (field: string, placeholder: string) => string;
};
//# sourceMappingURL=abstractSqlDialect.d.ts.map