import type { EntityQueryContext } from '@expo/entity';
import { EntityDatabaseAdapter } from '@expo/entity';
import type { Knex } from 'knex';
import type { SQLFragment } from './SQLOperator.ts';
/**
 * Equality operand that is used for selecting entities with a field with a single value.
 */
export interface SingleValueFieldEqualityCondition<TFields extends Record<string, any>, N extends keyof TFields = keyof TFields> {
    fieldName: N;
    fieldValue: TFields[N];
}
/**
 * Equality operand that is used for selecting entities with a field matching one of multiple values.
 */
export interface MultiValueFieldEqualityCondition<TFields extends Record<string, any>, N extends keyof TFields = keyof TFields> {
    fieldName: N;
    fieldValues: readonly TFields[N][];
}
/**
 * A single equality operand for use in a selection clause.
 * See EntityLoader.loadManyByFieldEqualityConjunctionAsync documentation for examples.
 */
export type FieldEqualityCondition<TFields extends Record<string, any>, N extends keyof TFields = keyof TFields> = SingleValueFieldEqualityCondition<TFields, N> | MultiValueFieldEqualityCondition<TFields, N>;
export declare function isSingleValueFieldEqualityCondition<TFields extends Record<string, any>, N extends keyof TFields = keyof TFields>(condition: FieldEqualityCondition<TFields, N>): condition is SingleValueFieldEqualityCondition<TFields, N>;
export interface TableFieldSingleValueEqualityCondition {
    tableField: string;
    tableValue: any;
}
export interface TableFieldMultiValueEqualityCondition {
    tableField: string;
    tableValues: readonly any[];
}
export declare enum NullsOrdering {
    FIRST = "first",
    LAST = "last"
}
/**
 * Ordering options for `orderBy` clauses.
 */
export declare enum OrderByOrdering {
    /**
     * Ascending order (lowest to highest).
     * Ascending order puts smaller values first, where "smaller" is defined in terms of the %3C operator.
     */
    ASCENDING = "asc",
    /**
     * Descending order (highest to lowest).
     * Descending order puts larger values first, where "larger" is defined in terms of the %3E operator.
     */
    DESCENDING = "desc"
}
export type PostgresOrderByClause<TFields extends Record<string, any>> = {
    /**
     * The field name to order by.
     */
    fieldName: keyof TFields;
    /**
     * The OrderByOrdering to order by.
     */
    order: OrderByOrdering;
    /**
     * Optional nulls ordering. If not provided, the database default is used
     * (NULLS LAST for ASC, NULLS FIRST for DESC in PostgreSQL).
     */
    nulls?: NullsOrdering | undefined;
} | {
    /**
     * A raw SQL fragment to order by. May not contain ASC or DESC, as ordering direction is determined by the `order` property.
     */
    fieldFragment: SQLFragment<TFields>;
    /**
     * The OrderByOrdering to order by.
     */
    order: OrderByOrdering;
    /**
     * Optional nulls ordering. If not provided, the database default is used
     * (NULLS LAST for ASC, NULLS FIRST for DESC in PostgreSQL).
     */
    nulls?: NullsOrdering | undefined;
};
/**
 * SQL modifiers that only affect the selection but not the projection.
 */
export interface PostgresQuerySelectionModifiers<TFields extends Record<string, any>> {
    /**
     * Order the entities by specified columns and orders.
     */
    orderBy?: readonly PostgresOrderByClause<TFields>[];
    /**
     * Skip the specified number of entities queried before returning.
     */
    offset?: number;
    /**
     * Limit the number of entities returned.
     */
    limit?: number;
}
export type TableOrderByClause<TFields extends Record<string, any>> = {
    columnName: string;
    order: OrderByOrdering;
    nulls: NullsOrdering | undefined;
} | {
    columnFragment: SQLFragment<TFields>;
    order: OrderByOrdering;
    nulls: NullsOrdering | undefined;
};
export interface TableQuerySelectionModifiers<TFields extends Record<string, any>> {
    orderBy: TableOrderByClause<TFields>[] | undefined;
    offset: number | undefined;
    limit: number | undefined;
}
export declare abstract class BasePostgresEntityDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields> extends EntityDatabaseAdapter<TFields, TIDField> {
    /**
     * Get the maximum page size for pagination.
     * @returns maximum page size if configured, undefined otherwise
     */
    get paginationMaxPageSize(): number | undefined;
    /**
     * Fetch many objects matching the conjunction of where clauses constructed from
     * specified field equality operands.
     *
     * @param queryContext - query context with which to perform the fetch
     * @param fieldEqualityOperands - list of field equality where clause operand specifications
     * @param querySelectionModifiers - limit, offset, orderBy, and orderByRaw for the query
     * @returns array of objects matching the query
     */
    fetchManyByFieldEqualityConjunctionAsync<N extends keyof TFields>(queryContext: EntityQueryContext, fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[], querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
    protected abstract fetchManyByFieldEqualityConjunctionInternalAsync(queryInterface: Knex, tableName: string, tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[], tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[], querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
    /**
     * Fetch many objects matching the SQL fragment.
     *
     * @param queryContext - query context with which to perform the fetch
     * @param sqlFragment - SQLFragment for the WHERE clause of the query
     * @param querySelectionModifiers - limit, offset, and orderByFragment for the query
     * @returns array of objects matching the query
     */
    fetchManyBySQLFragmentAsync(queryContext: EntityQueryContext, sqlFragment: SQLFragment<TFields>, querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
    protected abstract fetchManyBySQLFragmentInternalAsync(queryInterface: Knex, tableName: string, sqlFragment: SQLFragment<TFields>, querySelectionModifiers: TableQuerySelectionModifiers<TFields>): Promise<object[]>;
    /**
     * Count objects matching the conjunction of where clauses constructed from
     * specified field equality operands.
     *
     * @param queryContext - query context with which to perform the count
     * @param fieldEqualityOperands - list of field equality where clause operand specifications
     * @returns count of objects matching the query
     */
    countByFieldEqualityConjunctionAsync<N extends keyof TFields>(queryContext: EntityQueryContext, fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[]): Promise<number>;
    protected abstract countByFieldEqualityConjunctionInternalAsync(queryInterface: Knex, tableName: string, tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[], tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[]): Promise<number>;
    /**
     * Count objects matching the SQL fragment.
     *
     * @param queryContext - query context with which to perform the count
     * @param sqlFragment - SQLFragment for the WHERE clause of the query
     * @returns count of objects matching the query
     */
    countBySQLFragmentAsync(queryContext: EntityQueryContext, sqlFragment: SQLFragment<TFields>): Promise<number>;
    protected abstract countBySQLFragmentInternalAsync(queryInterface: Knex, tableName: string, sqlFragment: SQLFragment<TFields>): Promise<number>;
    private convertToTableQueryModifiers;
}