import { ArrayPrimitive, InferredType, KeysOf, KeysOfNonPrimitives, NonArrayPrimitive, Primitive, TypeOf } from 'tsds-tools';
import { FindManyOptions, FindOperator, FindOptionsWhere, ObjectLiteral } from 'typeorm';
import { Repository } from '../repository';
import { NestedKeysOf, NestedKeysOf2, TypeOfNested } from './nested-types';
export declare const DEFAULT_PAGE_SIZE = 20;
export declare const DEFAULT_CACHE_TIME: number;
type QueryBuilder<Entity extends ObjectLiteral> = (q: QueryWithWhere<Entity>) => QueryWithWhere<Entity> | TerminalQuery<Entity>;
/**
 * Context flags to track query building state for runtime validation
 */
interface QueryContext {
    insideWhereJoin: boolean;
    insideWhereOr: boolean;
}
export declare function isQuery<T extends ObjectLiteral>(query: any): query is Query<T>;
export declare function isTerminalQuery<T extends ObjectLiteral>(query: any): query is TerminalQuery<T>;
/**
 * A terminal query that restricts further where clause chaining.
 *
 * This class is returned by `whereIn()` and `whereOr()` methods to enforce
 * query chain ordering at compile time. TypeORM's `In()` operator can cause
 * unexpected behavior when combined with subsequent where clauses, so this
 * pattern ensures such combinations are caught during development.
 *
 * ## Why Terminal Queries Exist
 *
 * When using TypeORM's `In()` operator (via `whereIn()`), adding more where
 * conditions after it can lead to incorrect SQL generation. The Terminal Query
 * Pattern enforces that these operators must be last in your query chain.
 *
 * ## Available Methods
 *
 * After calling `whereIn()` or `whereOr()`, you can still use:
 * - `orderByAscending()` / `orderByDescending()` - Sort results
 * - `select()` - Choose specific columns
 * - `fetchRelation()` - Eagerly load related entities
 * - `loadRelationIds()` - Load only relation IDs
 * - `cache()` - Enable query caching
 *
 * ## Restricted Methods
 *
 * The following methods are NOT available after terminal operations:
 * - All `where*()` methods (e.g., `whereEqualTo()`, `whereMoreThan()`)
 * - `whereJoin()`
 *
 * ## Migration Guide
 *
 * If you have existing code that chains where clauses after `whereIn()`,
 * reorder your query to place `whereIn()` last:
 *
 * ```typescript
 * // Before (will cause TypeScript error)
 * q.whereIn('status', statuses).whereEqualTo('active', true)
 *
 * // After (correct)
 * q.whereEqualTo('active', true).whereIn('status', statuses)
 * ```
 *
 * @see {@link TerminalPaginatedQuery} for the paginated variant
 * @see README.md#terminal-query-pattern for full documentation
 */
export declare class TerminalQuery<Entity extends ObjectLiteral> {
    readonly repository: Repository<Entity>;
    protected query: FindManyOptions<Entity>;
    constructor(repository: Repository<Entity>);
    static from<Entity extends ObjectLiteral>(source: QueryWithWhere<Entity> | Query<Entity> | PaginatedQuery<Entity> | TerminalQuery<Entity>): TerminalQuery<Entity>;
    orderByAscending<Key extends KeysOf<Entity, NonArrayPrimitive>>(key: Key): this;
    orderByDescending<Key extends KeysOf<Entity, NonArrayPrimitive>>(key: Key): this;
    select<Key extends KeysOf<Entity, Primitive>>(key: Key): this;
    fetchRelation<Key1 extends KeysOfNonPrimitives<Entity>, Key2 extends KeysOfNonPrimitives<InferredType<Entity, Key1>>, Key3 extends KeysOfNonPrimitives<InferredType<InferredType<Entity, Key1>, Key2>>, Key4 extends KeysOfNonPrimitives<InferredType<InferredType<InferredType<Entity, Key1>, Key2>, Key3>>>(key1: Key1, key2?: Key2, key3?: Key3, key4?: Key4): this;
    loadRelationIds(loadRelationIds?: boolean): this;
    cache(cache?: boolean | number): this;
    toQuery(): FindManyOptions<Entity>;
}
/**
 * A terminal paginated query that restricts further where clause chaining.
 *
 * This class extends {@link TerminalQuery} with pagination capabilities. It is
 * returned by `whereIn()` and `whereOr()` methods when called on a
 * {@link PaginatedQuery}.
 *
 * ## Additional Methods (beyond TerminalQuery)
 *
 * - `pagination()` - Set both limit and cursor token
 * - `next()` - Set the cursor token for pagination
 * - `limit()` - Set the page size
 *
 * ## Example
 *
 * ```typescript
 * const { items, next } = await userRepo.find(q =>
 *   q.whereEqualTo('active', true)
 *    .whereIn('role', ['admin', 'moderator'])
 *    .orderByDescending('createdAt')
 *    .limit(25)
 * )
 * ```
 *
 * @see {@link TerminalQuery} for base terminal query documentation
 * @see README.md#terminal-query-pattern for full documentation
 */
export declare class TerminalPaginatedQuery<Entity extends ObjectLiteral> extends TerminalQuery<Entity> {
    static from<Entity extends ObjectLiteral>(source: QueryWithWhere<Entity> | Query<Entity> | PaginatedQuery<Entity> | TerminalQuery<Entity>): TerminalPaginatedQuery<Entity>;
    pagination(pagination: {
        next?: string | null;
        limit?: number | null;
    } | null | undefined): this;
    next(next: string | null | undefined): this;
    limit(limit: number | null | undefined): this;
}
export declare class QueryWithWhere<Entity extends ObjectLiteral> {
    readonly repository: Repository<Entity>;
    protected query: FindManyOptions<Entity>;
    protected context: QueryContext;
    constructor(repository: Repository<Entity>);
    static from<Entity extends ObjectLiteral, QueryType extends QueryWithWhere<Entity> | Query<Entity> | PaginatedQuery<Entity>>(query: QueryType): QueryWithWhere<Entity>;
    /**
     * Filter by equal value - supports both direct and nested field paths
     *
     * @example Direct field
     * q.whereEqualTo('status', 'active')
     *
     * @example Nested relation field (1 level)
     * q.whereEqualTo('author.id', userId)
     *
     * @example Nested relation field (2 levels)
     * q.whereEqualTo('author.profile.age', 25)
     */
    whereEqualTo<Key extends KeysOf<Entity, NonArrayPrimitive>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereEqualTo<Path extends NestedKeysOf<Entity, NonArrayPrimitive>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereEqualTo<Path extends NestedKeysOf2<Entity, NonArrayPrimitive>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by not equal value - supports both direct and nested field paths
     */
    whereNotEqualTo<Key extends KeysOf<Entity, NonArrayPrimitive>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereNotEqualTo<Path extends NestedKeysOf<Entity, NonArrayPrimitive>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereNotEqualTo<Path extends NestedKeysOf2<Entity, NonArrayPrimitive>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by more than value - supports both direct and nested field paths
     */
    whereMoreThan<Key extends KeysOf<Entity, number | Date>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereMoreThan<Path extends NestedKeysOf<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereMoreThan<Path extends NestedKeysOf2<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by not more than value - supports both direct and nested field paths
     */
    whereNotMoreThan<Key extends KeysOf<Entity, number | Date>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereNotMoreThan<Path extends NestedKeysOf<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereNotMoreThan<Path extends NestedKeysOf2<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by more than or equal value - supports both direct and nested field paths
     */
    whereMoreThanOrEqual<Key extends KeysOf<Entity, number | Date>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereMoreThanOrEqual<Path extends NestedKeysOf<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereMoreThanOrEqual<Path extends NestedKeysOf2<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by not more than or equal value - supports both direct and nested field paths
     */
    whereNotMoreThanOrEqual<Key extends KeysOf<Entity, number | Date>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereNotMoreThanOrEqual<Path extends NestedKeysOf<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereNotMoreThanOrEqual<Path extends NestedKeysOf2<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by less than value - supports both direct and nested field paths
     */
    whereLessThan<Key extends KeysOf<Entity, number | Date>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereLessThan<Path extends NestedKeysOf<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereLessThan<Path extends NestedKeysOf2<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by not less than value - supports both direct and nested field paths
     */
    whereNotLessThan<Key extends KeysOf<Entity, number | Date>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereNotLessThan<Path extends NestedKeysOf<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereNotLessThan<Path extends NestedKeysOf2<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by less than or equal value - supports both direct and nested field paths
     */
    whereLessThanOrEqual<Key extends KeysOf<Entity, number | Date>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereLessThanOrEqual<Path extends NestedKeysOf<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereLessThanOrEqual<Path extends NestedKeysOf2<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by not less than or equal value - supports both direct and nested field paths
     */
    whereNotLessThanOrEqual<Key extends KeysOf<Entity, number | Date>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereNotLessThanOrEqual<Path extends NestedKeysOf<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereNotLessThanOrEqual<Path extends NestedKeysOf2<Entity, number | Date>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by between values - supports both direct and nested field paths
     */
    whereBetween<Key extends KeysOf<Entity, number>>(key: Key, from: TypeOf<Entity, Key> | undefined, to: TypeOf<Entity, Key> | undefined): this;
    whereBetween<Path extends NestedKeysOf<Entity, number>>(path: Path, from: TypeOfNested<Entity, Path> | undefined, to: TypeOfNested<Entity, Path> | undefined): this;
    whereBetween<Path extends NestedKeysOf2<Entity, number>>(path: Path, from: TypeOfNested<Entity, Path> | undefined, to: TypeOfNested<Entity, Path> | undefined): this;
    /**
     * Filter by text containing value - supports both direct and nested field paths
     */
    whereTextContains<Key extends KeysOf<Entity, string>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereTextContains<Path extends NestedKeysOf<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereTextContains<Path extends NestedKeysOf2<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by text starting with value - supports both direct and nested field paths
     */
    whereTextStartsWith<Key extends KeysOf<Entity, string>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereTextStartsWith<Path extends NestedKeysOf<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereTextStartsWith<Path extends NestedKeysOf2<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by text ending with value - supports both direct and nested field paths
     */
    whereTextEndsWith<Key extends KeysOf<Entity, string>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereTextEndsWith<Path extends NestedKeysOf<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereTextEndsWith<Path extends NestedKeysOf2<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by text containing value (case insensitive) - supports both direct and nested field paths
     */
    whereTextInAnyCaseContains<Key extends KeysOf<Entity, string>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereTextInAnyCaseContains<Path extends NestedKeysOf<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereTextInAnyCaseContains<Path extends NestedKeysOf2<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by text starting with value (case insensitive) - supports both direct and nested field paths
     */
    whereTextInAnyCaseStartsWith<Key extends KeysOf<Entity, string>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereTextInAnyCaseStartsWith<Path extends NestedKeysOf<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereTextInAnyCaseStartsWith<Path extends NestedKeysOf2<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by text ending with value (case insensitive) - supports both direct and nested field paths
     */
    whereTextInAnyCaseEndsWith<Key extends KeysOf<Entity, string>>(key: Key, value: TypeOf<Entity, Key> | undefined): this;
    whereTextInAnyCaseEndsWith<Path extends NestedKeysOf<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    whereTextInAnyCaseEndsWith<Path extends NestedKeysOf2<Entity, string>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>> | undefined): this;
    /**
     * Filter by value in array - supports both direct and nested field paths
     * Note: This is a terminal operation and returns a TerminalQuery
     */
    whereIn<Key extends KeysOf<Entity, NonArrayPrimitive>>(key: Key, value: TypeOf<Entity, Key>[] | undefined): TerminalQuery<Entity>;
    whereIn<Path extends NestedKeysOf<Entity, NonArrayPrimitive>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>>[] | undefined): TerminalQuery<Entity>;
    whereIn<Path extends NestedKeysOf2<Entity, NonArrayPrimitive>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>>[] | undefined): TerminalQuery<Entity>;
    /**
     * Filter by null value - supports both direct and nested field paths
     */
    whereIsNull<Key extends KeysOf<Entity>>(key: Key): this;
    whereIsNull<Path extends NestedKeysOf<Entity>>(path: Path): this;
    whereIsNull<Path extends NestedKeysOf2<Entity>>(path: Path): this;
    /**
     * Filter by not null value - supports both direct and nested field paths
     */
    whereIsNotNull<Key extends KeysOf<Entity>>(key: Key): this;
    whereIsNotNull<Path extends NestedKeysOf<Entity>>(path: Path): this;
    whereIsNotNull<Path extends NestedKeysOf2<Entity>>(path: Path): this;
    whereArrayContains<Key extends KeysOf<Entity, ArrayPrimitive>>(key: Key, value: InferredType<Entity, Key> | undefined): this;
    whereArrayContainsAny<Key extends KeysOf<Entity, ArrayPrimitive>>(key: Key, value: InferredType<Entity, Key>[] | undefined): this;
    whereJoin<Key extends KeysOfNonPrimitives<Entity>, Type extends InferredType<Entity, Key> & ObjectLiteral>(key: Key, queryBuilder: QueryBuilder<Type>): this;
    protected setWhere<Key extends KeysOf<Entity>>(key: Key, where: FindOperator<any> | FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[] | TypeOf<Entity, Key> | undefined): this;
    /**
     * Helper method to handle nested path where conditions
     * Automatically adds the relation and builds the nested where structure
     */
    protected setNestedWhere(path: string, value: unknown): this;
    whereOr(queryBuilder1: QueryBuilder<Entity>, queryBuilder2: QueryBuilder<Entity>, ...otherQueryBuilder: QueryBuilder<Entity>[]): TerminalQuery<Entity>;
    toQuery(): FindManyOptions<Entity>;
}
export declare class Query<Entity extends ObjectLiteral> extends QueryWithWhere<Entity> {
    static from<Entity extends ObjectLiteral, QueryType extends QueryWithWhere<Entity> | Query<Entity> | PaginatedQuery<Entity>>(query: QueryType): Query<Entity>;
    orderByAscending<Key extends KeysOf<Entity, NonArrayPrimitive>>(key: Key): this;
    orderByDescending<Key extends KeysOf<Entity, NonArrayPrimitive>>(key: Key): this;
    select<Key extends KeysOf<Entity, Primitive>>(key: Key): this;
    fetchRelation<Key1 extends KeysOfNonPrimitives<Entity>, Key2 extends KeysOfNonPrimitives<InferredType<Entity, Key1>>, Key3 extends KeysOfNonPrimitives<InferredType<InferredType<Entity, Key1>, Key2>>, Key4 extends KeysOfNonPrimitives<InferredType<InferredType<InferredType<Entity, Key1>, Key2>, Key3>>>(key1: Key1, key2?: Key2, key3?: Key3, key4?: Key4): this;
    loadRelationIds(loadRelationIds?: boolean): this;
    cache(cache?: boolean | number): this;
}
export declare class PaginatedQuery<Entity extends ObjectLiteral> extends Query<Entity> {
    static from<QueryType extends QueryWithWhere<any> | Query<any> | PaginatedQuery<any> | TerminalQuery<any> | TerminalPaginatedQuery<any>>(query: QueryType): PaginatedQuery<any>;
    pagination(pagination: {
        next?: string | null;
        limit?: number | null;
    } | null | undefined): this;
    next(next: string | null | undefined): this;
    limit(limit: number | null | undefined): this;
    whereIn<Key extends KeysOf<Entity, NonArrayPrimitive>>(key: Key, value: TypeOf<Entity, Key>[] | undefined): TerminalPaginatedQuery<Entity>;
    whereIn<Path extends NestedKeysOf<Entity, NonArrayPrimitive>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>>[] | undefined): TerminalPaginatedQuery<Entity>;
    whereIn<Path extends NestedKeysOf2<Entity, NonArrayPrimitive>>(path: Path, value: NoInfer<TypeOfNested<Entity, Path>>[] | undefined): TerminalPaginatedQuery<Entity>;
    whereOr(queryBuilder1: QueryBuilder<Entity>, queryBuilder2: QueryBuilder<Entity>, ...otherQueryBuilder: QueryBuilder<Entity>[]): TerminalPaginatedQuery<Entity>;
}
export {};