import { CollectionQuery, ModelFilterStatement, OrderStatement, QueryOrder, QuerySelectionFromQuery, QueryWhere, RefCollectionName, RefSubquery, RelationshipRef, RelationSubquery, SchemaQuery, ValueCursor, WithInclusion, WithInclusionRaw, WithSelection } from './types/index.js';
import { CollectionNameFromModels, Models } from '../schema/index.js';
import { Writeable } from '../types.js';
export declare function queryBuilder<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>>(collectionName: CN): QueryBuilder<M, CN, WithInclusion<CollectionQuery<M, CN>, {}>>;
export declare class QueryBuilder<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, Q extends CollectionQuery<M, CN> = WithInclusion<CollectionQuery<M, CN>, {}>> implements CollectionQuery<M, CN> {
    collectionName: CN;
    select: Q['select'];
    where: Q['where'];
    limit: Q['limit'];
    order: Q['order'];
    include: Q['include'];
    after: Q['after'];
    vars: Q['vars'];
    constructor(collectionName: CN, query?: Omit<Q, 'collectionName'>);
    Select<Selection extends QuerySelectionFromQuery<Q>>(value: ReadonlyArray<Selection> | undefined): QueryBuilder<M, CN, WithSelection<Q, Selection>>;
    Where(...args: FilterInput<M, CN>): QueryBuilder<M, CN, Q>;
    Id(value: string): QueryBuilder<M, CN, Q>;
    Limit(value: number): QueryBuilder<M, CN, Q>;
    Order(...args: OrderInput<M, CN>): QueryBuilder<M, CN, Q>;
    After(value: AfterInput<M, CN>, inclusive?: boolean): QueryBuilder<M, CN, Q>;
    Vars(value: Record<string, any>): QueryBuilder<M, CN, Q>;
    Include<Alias extends RelationshipRef<M, CN>, RQ extends RefSubquery<M, CN, Alias>>(alias: Alias, queryExt: RQ): QueryBuilder<M, CN, WithInclusion<Q, Q['include'] & {
        [K in Alias]: RQ;
    }>>;
    Include<Alias extends string, RQ extends RefSubquery<M, CN>>(alias: Alias, builder: (rel: <Ref extends RelationshipRef<M, CN>>(ref: Ref) => RelationBuilder<M, CN, Ref>) => RQ): QueryBuilder<M, CN, WithInclusion<Q, Q['include'] & {
        [K in Alias]: RQ;
    }>>;
    Include<Alias extends RelationshipRef<M, CN>>(alias: Alias): QueryBuilder<M, CN, WithInclusion<Q, Q['include'] & {
        [K in Alias]: null;
    }>>;
    SubqueryOne<Alias extends string, SQ extends SchemaQuery<M>>(alias: Alias, subquery: SQ): QueryBuilder<M, CN, WithInclusion<Q, Q['include'] & {
        [K in Alias]: RelationSubquery<M, SQ, 'one'>;
    }>>;
    SubqueryOne<Alias extends string, SQ extends SchemaQuery<M>>(alias: Alias, subquery: (sub: <CName extends CollectionNameFromModels<M>>(collectionName: CName) => QueryBuilder<M, CName>) => SQ): QueryBuilder<M, CN, WithInclusion<Q, Q['include'] & {
        [K in Alias]: RelationSubquery<M, SQ, 'one'>;
    }>>;
    SubqueryMany<Alias extends string, SQ extends SchemaQuery<M>>(alias: Alias, subquery: SQ): QueryBuilder<M, CN, WithInclusion<Q, Q['include'] & {
        [K in Alias]: RelationSubquery<M, SQ, 'many'>;
    }>>;
    SubqueryMany<Alias extends string, SQ extends SchemaQuery<M>>(alias: Alias, subquery: (sub: <CName extends CollectionNameFromModels<M>>(collectionName: CName) => QueryBuilder<M, CName>) => SQ): QueryBuilder<M, CN, WithInclusion<Q, Q['include'] & {
        [K in Alias]: RelationSubquery<M, SQ, 'many'>;
    }>>;
}
export declare function relationBuilder<M extends Models<M>, CN extends CollectionNameFromModels<M>, Ref extends RelationshipRef<M, CN>>(ref: Ref): RelationBuilder<M, CN, Ref, WithInclusionRaw<RefSubquery<M, CN, Ref>, {}>>;
export declare class RelationBuilder<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, Ref extends RelationshipRef<M, CN> = RelationshipRef<M, CN>, RQ extends RefSubquery<M, CN, Ref> = WithInclusionRaw<RefSubquery<M, CN, Ref>, {}>> implements RefSubquery<M, CN, Ref> {
    _extends: Ref;
    select: RQ['select'];
    where: RQ['where'];
    limit: RQ['limit'];
    order: RQ['order'];
    include: RQ['include'];
    constructor(ref: Ref, query?: RQ);
    Select<Selection extends NonNullable<RQ['select']>[number]>(value: Selection[]): RelationBuilder<M, CN, Ref, WithSelection<RQ, Selection>>;
    Where(...args: FilterInput<M, RefCollectionName<M, CN, Ref>>): RelationBuilder<M, CN, Ref, RQ>;
    Id(id: string): RelationBuilder<M, CN, Ref, RQ>;
    Limit(value: number): RelationBuilder<M, CN, Ref, RQ>;
    Order(...args: OrderInput<M, RefCollectionName<M, CN, Ref>>): RelationBuilder<M, CN, Ref, RQ>;
    Include<Alias extends string, NextRQ extends RefSubquery<M, RefCollectionName<M, CN, Ref>>>(alias: Alias, queryExt: NextRQ): RelationBuilder<M, CN, Ref, WithInclusionRaw<RQ, RQ['include'] & {
        [K in Alias]: RQ;
    }>>;
    Include<Alias extends string, NextRQ extends RefSubquery<M, RefCollectionName<M, CN, Ref>>>(alias: Alias, builder: (rel: <NextRef extends RelationshipRef<M, RefCollectionName<M, CN, Ref>>>(ref: NextRef) => RelationBuilder<M, RefCollectionName<M, CN, Ref>, NextRef>) => NextRQ): RelationBuilder<M, CN, Ref, WithInclusionRaw<RQ, RQ['include'] & {
        [K in Alias]: NextRQ;
    }>>;
    Include<Alias extends RelationshipRef<M, RefCollectionName<M, CN, Ref>>>(alias: Alias): RelationBuilder<M, CN, Ref, WithInclusionRaw<RQ, RQ['include'] & {
        [K in Alias]: null;
    }>>;
    SubqueryOne<Alias extends string, SQ extends SchemaQuery<M>>(alias: Alias, subquery: SQ): RelationBuilder<M, CN, Ref, WithInclusionRaw<RQ, RQ['include'] & {
        [K in Alias]: RelationSubquery<M, SQ, 'one'>;
    }>>;
    SubqueryOne<Alias extends string, SQ extends SchemaQuery<M>>(alias: Alias, subquery: (sub: <CName extends CollectionNameFromModels<M>>(collectionName: CName) => QueryBuilder<M, CName>) => SQ): RelationBuilder<M, CN, Ref, WithInclusionRaw<RQ, RQ['include'] & {
        [K in Alias]: RelationSubquery<M, SQ, 'one'>;
    }>>;
    SubqueryMany<Alias extends string, SQ extends SchemaQuery<M>>(alias: Alias, subquery: SQ): RelationBuilder<M, CN, Ref, WithInclusionRaw<RQ, RQ['include'] & {
        [K in Alias]: RelationSubquery<M, SQ, 'many'>;
    }>>;
    SubqueryMany<Alias extends string, SQ extends SchemaQuery<M>>(alias: Alias, subquery: (sub: <CName extends CollectionNameFromModels<M>>(collectionName: CName) => QueryBuilder<M, CName>) => SQ): RelationBuilder<M, CN, Ref, WithInclusionRaw<RQ, RQ['include'] & {
        [K in Alias]: RelationSubquery<M, SQ, 'many'>;
    }>>;
}
/**
 * Input for builder where() clauses
 */
export type FilterInput<M extends Models<M>, CN extends CollectionNameFromModels<M>> = [typeof undefined] | Writeable<ModelFilterStatement<M, CN>> | QueryWhere<M, CN> | [QueryWhere<M, CN>[number] | undefined] | [QueryWhere<M, CN>];
/**
 * Input for builder order() clauses
 */
export type OrderInput<M extends Models<M>, CN extends CollectionNameFromModels<M>> = [typeof undefined] | OrderStatement<M, CN> | QueryOrder<M, CN> | [QueryOrder<M, CN>[number] | undefined] | [QueryOrder<M, CN>];
/**
 * Input for builder after() clauses
 */
export type AfterInput<M extends Models<M>, CN extends CollectionNameFromModels<M>> = ValueCursor | undefined;
export declare const QUERY_INPUT_TRANSFORMERS: <M extends Models<M>, CN extends CollectionNameFromModels<M>>() => {
    where: <A extends FilterInput<M, CN>>(q: Pick<CollectionQuery<M, CN>, "where">, ...args: A) => QueryWhere<M, CN>;
    order: (q: Pick<CollectionQuery<M, CN>, "order">, ...args: OrderInput<M, CN>) => QueryOrder<M, CN> | undefined;
    include<Alias extends string>(q: Pick<CollectionQuery<M, CN>, "include">, alias: Alias, query?: any): Record<string, any>;
    after(q: Pick<CollectionQuery<M, CN>, "after" | "order">, after: AfterInput<M, CN>, inclusive?: boolean): [ValueCursor, boolean] | undefined;
};