import DateTime from "@web-atoms/date-time/dist/DateTime";
import IPagedList from "../models/IPagedList";
import type BaseEntityService from "./BaseEntityService";
import type { ICollection, IListParams, IModel, IPagedListParams, IQueryMethod } from "./BaseEntityService";
export type stepTypes = "Day" | "Month" | "Year" | "Week" | "Hour";
export declare const convertToLinq: (x: string) => string;
export declare function append<T>(original: T[], ...item: T[]): T[];
export interface IIncludedQuery<T, TR> extends Required<Query<T>> {
    thenInclude<TP>(path: (x: TR) => TP): IIncludedQuery<T, TP>;
}
export interface IIncludedArrayQuery<T, TR, TRA extends TR[]> extends Required<Query<T>> {
    thenInclude<TP>(q: (x: TR) => TP[]): IIncludedArrayQuery<T, TP, TP[]>;
    thenInclude<TP>(q: (x: TR) => TP): IIncludedQuery<T, TP>;
}
export type Func<T, TR> = (x: T) => TR;
export type SelectWithFunc<T, TI, TR> = (x: T, y: ICollection<TI>) => TR;
export interface IDateRange {
    startDate: DateTime;
    endDate: DateTime;
}
export interface IEntityWithDateRange<T> {
    entity: T;
    range: IDateRange;
}
export declare class QueryComposer<Q> {
    private separator;
    private query;
    private parameters;
    private index;
    constructor(separator?: string);
    add<P>(p: P, q: (p: P) => (item: Q) => any): void;
    asQuery(): any[];
}
interface IQueryContext {
    service: BaseEntityService;
    name: string;
    traceQuery?: boolean;
    queryFunction?: string;
    args?: any[];
    queryProcessor?: "DotNet" | "JavaScript";
}
export default class Query<T> {
    private context;
    private methods;
    constructor(context: IQueryContext, methods?: IQueryMethod[]);
    where<TR>(q: (x: T) => any): Query<T>;
    where<TP>(p: TP, q: (p: TP) => (x: T) => any): Query<T>;
    joinDateRange(start: DateTime, end: DateTime, step: stepTypes): Query<IEntityWithDateRange<T>>;
    selectWith<TI, TR>(model: IModel<TI>, q: SelectWithFunc<T, TI, TR>): Query<TR>;
    selectWith<TI, TR, TP = any>(model: IModel<TI>, tp: TP, q: (p: TP) => SelectWithFunc<T, TI, TR>): Query<TR>;
    select<TR>(q: (x: T) => TR): Query<TR>;
    select<TR, TP = any>(tp: TP, q: (p: TP) => (x: T) => TR): Query<TR>;
    /**
     * @param args any[]
     * @returns Query<T>
     */
    whereLinq(query: TemplateStringsArray, ...args: any[]): Query<T>;
    selectLinq<TR>(query: TemplateStringsArray, ...args: any[]): Query<TR>;
    join<TInner, TKey>(model: IModel<TInner>, left: (x: T) => TKey, right: (x: TInner) => TKey): Query<{
        entity: T;
        inner: TInner;
    }>;
    leftJoin<TInner, TKey>(model: IModel<TInner>, left: (x: T) => TKey, right: (x: TInner) => TKey): Query<{
        entity: T;
        inner: TInner;
    }>;
    include<TR>(q: (x: T) => TR[]): IIncludedArrayQuery<T, TR, TR[]>;
    include<TR>(q: (x: T) => TR): IIncludedQuery<T, TR>;
    include<TR>(...q: string[]): Query<T>;
    firstOrDefault(p?: IListParams): Promise<T>;
    orderBy<TR>(q: (x: T) => TR): Query<T>;
    orderBy<TP, TR>(p: TP, q: (p: TP) => (x: T) => TR): Query<T>;
    orderByDescending<TR>(q: (x: T) => TR): Query<T>;
    orderByDescending<TP, TR>(p: TP, q: (p: TP) => (x: T) => TR): Query<T>;
    thenBy<TR>(q: (x: T) => TR): Query<T>;
    thenBy<TP, TR>(p: TP, q: (p: TP) => (x: T) => TR): Query<T>;
    thenByDescending<TR>(q: (x: T) => TR): Query<T>;
    thenByDescending<TP, TR>(p: TP, q: (p: TP) => (x: T) => TR): Query<T>;
    trace(): Query<T>;
    /**
     * Warning, will return all the items from the query, please use `toPagedList`
     * for better performance
     * @param cancelToken Cancel Token to cancel the query
     * @returns Promise<T[]>
     */
    toArray({ cancelToken, doNotResolve, hideActivityIndicator, cacheSeconds, cacheVersion }?: IListParams): Promise<T[]>;
    toPagedList({ start, size, cancelToken, cacheVersion, hideActivityIndicator, splitInclude, cacheSeconds, cacheImmutable, count }?: IPagedListParams): Promise<IPagedList<T>>;
    protected thenInclude(a: any): any;
    private append;
    private process;
    private convertToLinq;
}
export {};
//# sourceMappingURL=Query.d.ts.map