import { CollectionNameFromModels, Models } from '../../schema/types/models.js';
import { StringKey, Unalias } from '../../utils/types.js';
import { Decoded, ModelPaths, ModelRelationshipPaths, PathFiltered, ResolveRelationshipPath, SchemaPaths } from '../../schema/index.js';
/**
 * All possible queries for a schema, keyed by collection name.
 */
export type SchemaQueries<M extends Models<M> = Models> = {
    [CN in CollectionNameFromModels<M>]: CollectionQuery<M, CN>;
};
/**
 * A selection of queries for a schema, returning a union if there are multiple matches
 */
export type SchemaQuery<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = SchemaQueries<M>[CN];
/**
 * A prepared query, which is used internally by the query engine
 */
export interface PreparedQuery {
    collectionName: string;
    select?: string[];
    where?: PreparedWhere;
    order?: PreparedOrder;
    limit?: number;
    after?: QueryAfter;
    include?: PreparedInclusions;
}
/**
 * A user defined query on the database, which may reference the schema or other database objects.
 */
export interface CollectionQuery<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> {
    collectionName: CN;
    select?: QuerySelection<M, CN>[];
    where?: QueryWhere<M, CN>;
    order?: QueryOrder<M, CN>;
    limit?: number;
    after?: QueryAfter;
    vars?: Record<string, any>;
    include?: QueryInclusions<M, CN>;
}
/**
 * Cardinality of a query result:
 * - 'one' - a single result
 * - 'many' - multiple results
 */
export type QueryResultCardinality = 'one' | 'many';
export type QuerySelectionFromQuery<Q extends CollectionQuery<any, any>> = Q extends CollectionQuery<infer M, infer CN> ? QuerySelection<M, CN> : never;
export type QuerySelection<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = SchemaPaths<M, CN>;
/**
 * A query filter, which is a collection of many filters.
 */
export type QueryWhere<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = WhereFilter<M, CN>[];
/**
 * A single filter, which may have various structures.
 */
export type WhereFilter<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = FilterStatement<M, CN> | FilterGroup<M, CN> | SubQueryFilter<M> | RelationshipExistsFilter<M, CN> | boolean;
export type ModelFilterStatements<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = {
    [K in ModelPaths<M, CN>]: FilterStatement<M, CN, K>;
};
export type ModelFilterStatement<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, K extends ModelPaths<M, CN> = ModelPaths<M, CN>> = ModelFilterStatements<M, CN>[K];
/**
 * A single filter statement of the shape [path, operator, value].
 */
export type FilterStatement<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, K extends ModelPaths<M, CN> = ModelPaths<M, CN>> = readonly [
    K,
    string,
    any
];
export type PreparedWhere = PreparedWhereFilter[];
export type PreparedWhereFilter = FilterStatement | PreparedFilterGroup | PreparedSubQueryFilter | boolean;
export type PreparedFilterGroup = FilterGroup<Models, CollectionNameFromModels<Models>, PreparedWhere>;
export type PreparedSubQueryFilter = {
    exists: PreparedQuery;
};
/**
 * A set of filters specified to be combined with AND or OR.
 */
export type FilterGroup<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, W extends QueryWhere<M, CN> | PreparedWhere = QueryWhere<M, CN> | PreparedWhere> = AndFilterGroup<M, CN, W> | OrFilterGroup<M, CN, W>;
export type QueryFilterGroup<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = FilterGroup<M, CN, QueryWhere<M, CN>>;
/**
 * A group of filters combined with AND.
 */
export type AndFilterGroup<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, W extends QueryWhere<M, CN> | PreparedWhere = QueryWhere<M, CN> | PreparedWhere> = {
    mod: 'and';
    filters: W;
};
/**
 * A group of filters combined with OR.
 */
export type OrFilterGroup<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, W extends QueryWhere<M, CN> | PreparedWhere = QueryWhere<M, CN> | PreparedWhere> = {
    mod: 'or';
    filters: W;
};
/**
 * An exists filter that will check if a subquery returns any results.
 */
export type SubQueryFilter<M extends Models<M> = Models, SQ extends SchemaQuery<M> = SchemaQuery<M>> = {
    exists: SQ;
};
/**
 * An exists filter that will check if a relationship in the schema returns any results.
 */
export type RelationshipRef<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = StringKey<NonNullable<M[CN]['relationships']>>;
export type IsRelationshipRef<M extends Models<M>, CN extends CollectionNameFromModels<M>, Ref extends string> = Ref extends RelationshipRef<M, CN> ? true : false;
export type RelationshipExistsFilter<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, P extends ModelRelationshipPaths<M, CN> = ModelRelationshipPaths<M, CN>, Ext extends RelationshipExistsExtension<M, CN, P> = RelationshipExistsExtension<M, CN, P>> = {
    exists: Ext & {
        _extends: P;
    };
};
export type RelationshipExistsExtension<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, P extends ModelRelationshipPaths<M, CN> = ModelRelationshipPaths<M, CN>> = Pick<SchemaQuery<M, ResolveRelationshipPath<M, CN, P>['query']['collectionName']>, 'where'>;
export type PreparedOrder = PreparedOrderStatement[];
export type PreparedOrderStatement = OrderStatement | RelationalOrderStatement;
export type RelationalOrderStatement<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = [
    property: ModelPaths<M, CN>,
    direction: 'ASC' | 'DESC',
    subquery: PreparedRelationSubquery<'one'>
];
/**
 * A query order, which is a collection of many orders.
 */
export type QueryOrder<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = OrderStatement<M, CN>[];
/**
 * A single order statement of the shape [path, direction].
 */
export type OrderStatement<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = [property: ModelPaths<M, CN>, direction: 'ASC' | 'DESC'];
export type QueryAfter = [cursor: ValueCursor, inclusive: boolean];
export type ValueCursor = [
    value: QueryValuePrimitive,
    ...values: QueryValuePrimitive[]
];
/**
 * A map of prepared inclusions, keyed by alias.
 */
export type PreparedInclusions = {
    [K in string]: PreparedInclusion;
};
/**
 * A possible inclusion value in a query.
 */
export type PreparedInclusion = PreparedRelationSubquery;
/**
 * A subquery definition for a prepared query.
 */
export type PreparedRelationSubquery<Cardinality extends QueryResultCardinality = QueryResultCardinality> = {
    subquery: PreparedQuery;
    cardinality: Cardinality;
};
/**
 * A map of inclusions, keyed by alias.
 */
export type QueryInclusions<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = {
    [K in string]: QueryInclusion<M, CN>;
};
/**
 * A possible inclusion value in a query.
 */
export type QueryInclusion<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>> = RefShorthand | RelationSubquery<M> | RefSubquery<M, CN>;
/**
 * A shorthand for including a reference.
 */
export type RefShorthand = true | null;
export type RefSubquery<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, Ref extends RelationshipRef<M, CN> = RelationshipRef<M, CN>> = {
    _extends: Ref;
} & RefQueryExtension<M, CN, Ref>;
/**
 * An extension of a referential subquery, specifying additional query parameters.
 */
export type RefQueryExtension<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, Ref extends RelationshipRef<M, CN> = RelationshipRef<M, CN>> = Pick<SchemaQuery<M, RefCollectionName<M, CN, Ref>>, 'select' | 'include' | 'limit' | 'where' | 'order'>;
export type RefDefinition<M extends Models<M>, CN extends CollectionNameFromModels<M>, Ref extends RelationshipRef<M, CN>> = NonNullable<M[CN]['relationships']>[Ref];
export type RefQuery<M extends Models<M>, CN extends CollectionNameFromModels<M>, Ref extends RelationshipRef<M, CN>> = RefDefinition<M, CN, Ref>['query'];
export type RefCollectionName<M extends Models<M>, CN extends CollectionNameFromModels<M>, Ref extends RelationshipRef<M, CN>> = RefQuery<M, CN, Ref>['collectionName'];
/**
 * A subquery defining a relationship, specifying the subquery and cardinality of the result.
 */
export type RelationSubquery<M extends Models<M> = Models, Q extends SchemaQuery<M> = SchemaQuery<M>, Cardinality extends QueryResultCardinality = QueryResultCardinality> = {
    subquery: Q;
    cardinality: Cardinality;
};
type QueryValuePrimitive = number | string | boolean | Date | null;
/**
 * Possible values that can be passed into a the query engine by a user
 */
export type QueryValue = QueryValuePrimitive | NonNullable<QueryValuePrimitive>[];
export type FetchResult<M extends Models<M>, Q extends SchemaQuery<M>, C extends QueryResultCardinality> = Unalias<AliasedFetchResult<M, Q, C>>;
export type AliasedFetchResult<M extends Models<M>, Q extends SchemaQuery<M>, C extends QueryResultCardinality> = C extends 'one' ? AliasedQueryResult<M, Q> | null : AliasedQueryResult<M, Q>[];
type AliasedQueryResult<M extends Models<M>, Q extends SchemaQuery<M>> = Q extends CollectionQuery<M, infer CN> ? (Q['select'] extends ReadonlyArray<infer S> ? PathFiltered<Decoded<M[CN]['schema']>, S extends string ? S : never> : Decoded<M[CN]['schema']>) & {
    [K in StringKey<Q['include']>]: InclusionResult<M, CN, K, Q['include'][K]>;
} : never;
type InclusionResult<M extends Models<M>, CN extends CollectionNameFromModels<M>, Alias extends string, Inclusion extends QueryInclusion<M, CN>> = Inclusion extends RelationSubquery<M, infer Subquery, infer Cardinality> ? AliasedFetchResult<M, Subquery, Cardinality> : Inclusion extends RefSubquery<M, CN, infer Ref> ? AliasedFetchResult<M, RefQuery<M, CN, Ref> & Omit<Inclusion, '_extends'>, RefDefinition<M, CN, Ref>['cardinality']> : Inclusion extends RefShorthand ? Alias extends RelationshipRef<M, CN> ? AliasedFetchResult<M, RefDefinition<M, CN, Alias>['query'], RefDefinition<M, CN, Alias>['cardinality']> : never : never;
export type WithSelection<Q extends CollectionQuery<any, any>, Selection extends QuerySelectionFromQuery<Q>> = Omit<Q, 'select'> & {
    select: Selection[];
};
export type WithInclusion<Q extends CollectionQuery<any, any>, Inclusion extends Q extends CollectionQuery<infer M, infer CN> ? QueryInclusions<M, CN> : never> = Omit<Q, 'include'> & {
    include: Inclusion;
};
export type WithInclusionRaw<Q, Inclusion> = Omit<Q, 'include'> & {
    include: Inclusion;
};
export {};