import type { EntityConfiguration, EntityQueryContext, IEntityMetricsAdapter } from '@expo/entity';
import type { BasePostgresEntityDatabaseAdapter, FieldEqualityCondition, PostgresOrderByClause, PostgresQuerySelectionModifiers } from '../BasePostgresEntityDatabaseAdapter.ts';
import { PaginationStrategy } from '../PaginationStrategy.ts';
import { SQLFragment } from '../SQLOperator.ts';
import type { NonNullableKeys } from './utilityTypes.ts';
interface DataManagerStandardSpecification<TFields extends Record<string, any>> {
    strategy: PaginationStrategy.STANDARD;
    orderBy: readonly PostgresOrderByClause<TFields>[];
}
type DataManagerFieldNameConstructorFn<TFields extends Record<string, any>> = (fieldName: keyof TFields) => SQLFragment<TFields>;
type DataManagerSearchFieldSQLFragmentFnSpecification<TFields extends Record<string, any>> = {
    fieldConstructor: (getFragmentForFieldName: DataManagerFieldNameConstructorFn<TFields>) => SQLFragment<TFields>;
};
type DataManagerSearchFieldSpecification<TFields extends Record<string, any>> = NonNullableKeys<TFields> | DataManagerSearchFieldSQLFragmentFnSpecification<TFields>;
interface DataManagerSearchSpecificationBase<TFields extends Record<string, any>> {
    term: string;
    fields: readonly DataManagerSearchFieldSpecification<TFields>[];
}
interface DataManagerILikeSearchSpecification<TFields extends Record<string, any>> extends DataManagerSearchSpecificationBase<TFields> {
    strategy: PaginationStrategy.ILIKE_SEARCH;
}
interface DataManagerTrigramSearchSpecification<TFields extends Record<string, any>> extends DataManagerSearchSpecificationBase<TFields> {
    strategy: PaginationStrategy.TRIGRAM_SEARCH;
    threshold: number;
    extraOrderByFields?: readonly DataManagerSearchFieldSpecification<TFields>[];
}
type DataManagerSearchSpecification<TFields extends Record<string, any>> = DataManagerILikeSearchSpecification<TFields> | DataManagerTrigramSearchSpecification<TFields>;
type DataManagerPaginationSpecification<TFields extends Record<string, any>> = DataManagerStandardSpecification<TFields> | DataManagerSearchSpecification<TFields>;
interface BaseUnifiedPaginationArgs<TFields extends Record<string, any>> {
    where?: SQLFragment<TFields>;
    pagination: DataManagerPaginationSpecification<TFields>;
}
interface ForwardUnifiedPaginationArgs<TFields extends Record<string, any>> extends BaseUnifiedPaginationArgs<TFields> {
    first: number;
    last?: never;
    before?: never;
    after?: string;
}
interface BackwardUnifiedPaginationArgs<TFields extends Record<string, any>> extends BaseUnifiedPaginationArgs<TFields> {
    first?: never;
    last: number;
    before?: string;
    after?: never;
}
type LoadPageArgs<TFields extends Record<string, any>> = ForwardUnifiedPaginationArgs<TFields> | BackwardUnifiedPaginationArgs<TFields>;
/**
 * Edge in a connection
 */
export interface Edge<TNode> {
    cursor: string;
    node: TNode;
}
/**
 * Page information for pagination
 */
export interface PageInfo {
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    startCursor: string | null;
    endCursor: string | null;
}
/**
 * Relay-style Connection type
 */
export interface Connection<TNode> {
    edges: readonly Edge<TNode>[];
    pageInfo: PageInfo;
}
/**
 * A knex data manager is responsible for handling non-dataloader-based
 * database operations.
 *
 * @internal
 */
export declare class EntityKnexDataManager<TFields extends Record<string, any>, TIDField extends keyof TFields> {
    private readonly entityConfiguration;
    private readonly databaseAdapter;
    private readonly metricsAdapter;
    private readonly entityClassName;
    constructor(entityConfiguration: EntityConfiguration<TFields, TIDField>, databaseAdapter: BasePostgresEntityDatabaseAdapter<TFields, TIDField>, metricsAdapter: IEntityMetricsAdapter, entityClassName: string);
    /**
     * Loads many objects matching the conjunction of where clauses constructed from
     * specified field equality operands.
     *
     * @param queryContext - query context in which to perform the load
     * @param fieldEqualityOperands - list of field equality where clause operand specifications
     * @param querySelectionModifiers - limit, offset, and orderBy for the query
     * @returns array of objects matching the query
     */
    loadManyByFieldEqualityConjunctionAsync<N extends keyof TFields>(queryContext: EntityQueryContext, fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[], querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
    countByFieldEqualityConjunctionAsync<N extends keyof TFields>(queryContext: EntityQueryContext, fieldEqualityOperands: readonly FieldEqualityCondition<TFields, N>[]): Promise<number>;
    loadManyBySQLFragmentAsync(queryContext: EntityQueryContext, sqlFragment: SQLFragment<TFields>, querySelectionModifiers: PostgresQuerySelectionModifiers<TFields>): Promise<readonly Readonly<TFields>[]>;
    countBySQLFragmentAsync(queryContext: EntityQueryContext, sqlFragment: SQLFragment<TFields>): Promise<number>;
    /**
     * Load a page of objects using cursor-based pagination with unified pagination specification.
     *
     * @remarks
     *
     * This method implements cursor-based pagination using the seek method for efficient pagination even on large datasets
     * given appropriate indexes. Cursors are opaque and encode the necessary information to fetch the next page based on the
     * specified pagination strategy (standard, ILIKE search, or trigram search). For this implementation in particular,
     * the cursor encodes the ID of the last entity in the page to ensure correct pagination for all strategies, even in cases
     * where multiple rows have the same value for all fields other than the ID. If the entity referenced by a cursor has been
     * deleted, the load will return an empty page with `hasNextPage: false`.
     *
     * @param queryContext - query context in which to perform the load
     * @param args - pagination arguments including pagination and first/after or last/before
     * @returns connection with edges containing field objects and page info
     */
    loadPageAsync(queryContext: EntityQueryContext, args: LoadPageArgs<TFields>): Promise<Connection<Readonly<TFields>>>;
    getCursorForEntityID(entityID: TFields[TIDField]): string;
    /**
     * Internal method for loading a page with cursor-based pagination.
     * Shared logic for both regular and search pagination.
     */
    private loadPageInternalAsync;
    private combineWhereConditions;
    private augmentOrderByIfNecessary;
    private static flipNullsOrderingSpread;
    private static validateOrderByClauses;
    /**
     * Cursor-based pagination uses Postgres tuple comparison (e.g., (a, b) \> (x, y)) which
     * applies a single comparison direction to all columns. Mixed ordering directions would
     * produce incorrect pagination results.
     */
    private static validateOrderByClausesHaveConsistentDirection;
    private encodeOpaqueCursor;
    private decodeOpaqueCursor;
    private resolveSearchFieldToSQLFragment;
    private buildCursorCondition;
    private buildILikeConditions;
    private buildTrigramSimilarityExpressions;
    private buildTrigramExactMatchCaseExpression;
    private buildTrigramSimilarityGreatestExpression;
    private buildTrigramCursorCondition;
    private buildSearchConditionAndOrderBy;
    private static escapeILikePattern;
}
export {};