import { CancelToken } from "@web-atoms/core/dist/core/types";
import DateTime from "@web-atoms/date-time/dist/DateTime";
import { Cloner } from "../models/Cloner";
import IClrEntity, { IClrEntityLike } from "../models/IClrEntity";
import { EntityContext } from "../models/IEntityModel";
import HttpSession, { IHttpRequest } from "./HttpSession";
import Query, { IDateRange, stepTypes } from "./Query";
import resolve from "./resolve";
import { QueryProcessor } from "./QueryProcessor";
export interface IGeometry {
    latitude: number;
    longitude: number;
    wktString?: string;
    difference?(g: IGeometry): IGeometry;
    intersection?(g: IGeometry): IGeometry;
    union?(g: IGeometry): IGeometry;
    symmetricDifference?(g: IGeometry): IGeometry;
    distance?(g: IGeometry): number;
    isWithinDistance?(g: IGeometry, distance: number): boolean;
    touches?(g: IGeometry): boolean;
    intersects?(g: IGeometry): boolean;
    crosses?(g: IGeometry): boolean;
    within?(g: IGeometry): boolean;
    contains?(g: IGeometry): boolean;
    overlaps?(g: IGeometry): boolean;
    covers?(g: IGeometry): boolean;
    coveredBy?(g: IGeometry): boolean;
}
export interface IKeyCollection<TKey, T> extends ICollection<T> {
    key?: TKey;
}
export interface ICollection<T> extends Array<T> {
    sum?(filter?: (item: T) => number): number;
    min?(filter?: (item: T) => number): number;
    max?(filter?: (item: T) => number): number;
    average?(filter?: (item: T) => number): number;
    groupBy?<TK>(this: ICollection<T>, selector: (item: T) => TK): ICollection<IKeyCollection<TK, T>>;
    where?(filter: (item: T) => boolean): ICollection<T>;
    any?(filter?: (item: T) => boolean): boolean;
    select?<TR>(select: (item: T) => TR): ICollection<TR>;
    selectMany?<TR>(select: (item: T) => TR[]): ICollection<TR>;
    firstOrDefault?(filter?: (item: T) => boolean): T;
    count?(filter?: (item: T) => boolean): number;
    toArray?(): ICollection<T>;
    toList?(): ICollection<T>;
    take?(n: number): ICollection<T>;
    orderBy?(item: (item: T) => any): ICollection<T>;
    thenBy?(item: (item: T) => any): ICollection<T>;
    orderByDescending?(item: (item: T) => any): ICollection<T>;
    thenByDescending?(item: (item: T) => any): ICollection<T>;
}
export interface IMethod {
    select?: [string, ...any[]];
    where?: [string, ...any[]];
    orderBy?: [string, ...any[]];
    orderByDescending?: [string, ...any[]];
    thenBy?: [string, ...any[]];
    thenByDescending?: [string, ...any[]];
}
export interface IMethodsFilter {
    methods: IMethod[];
    start: number;
    size: number;
}
export interface IModifications {
    [key: string]: any;
}
export interface IBulkUpdateModel {
    keys: IClrEntity[];
    update: IModifications;
    throwWhenNotFound?: boolean;
}
export interface IBulkDeleteModel {
    keys: IClrEntity[];
    throwWhenNotFound?: boolean;
}
export type IQueryMethod = [
    "select",
    string,
    ...any[]
] | ["where", string, ...any[]] | ["joinDateRange", string, ...any[]] | ["orderBy", string, ...any[]] | ["orderByDescending", string, ...any[]] | ["thenBy", string, ...any[]] | ["thenByDescending", string, ...any[]] | ["include", string] | ["thenInclude", string] | ["dateRange", string, ...any[]];
export interface IListParams {
    cancelToken?: CancelToken;
    /**
     * Query will resolve references by replacing $id attributed objects
     */
    doNotResolve?: boolean;
    /**
     * Do not display activity indicator
     */
    hideActivityIndicator?: boolean;
    /**
     * Response will include cache-control with given seconds as max age
     */
    cacheSeconds?: number;
    /**
     * Arbitrary cache version to invalidate previous version
     */
    cacheVersion?: string;
    /**
     * True if cacheSeconds is greater than zero, set false to turn it off
     */
    cacheImmutable?: boolean;
    /**
     * Split server side includes
     */
    splitInclude?: boolean;
}
export interface IPagedListParams extends IListParams {
    start?: number;
    size?: number;
    count?: boolean;
}
export interface IModel<T> {
    name: string;
    create?(properties?: IClrEntityLike<T>): T;
    patch?(original: IClrEntityLike<T>, updates: IClrEntityLike<T>): T;
}
export declare class DefaultFactory {
    readonly factory: () => any;
    constructor(factory: () => any);
}
export declare class Model<T> implements IModel<T> {
    name: string;
    readonly keys: string[];
    private defaults;
    constructor(name: string, keys?: string[], defaults?: any);
    create(properties?: IClrEntityLike<T>): T;
    patch(original: IClrEntityLike<T>, updates: IClrEntityLike<T>): T;
}
export default abstract class BaseEntityService extends HttpSession {
    url: string;
    abstract queryProcessor: QueryProcessor;
    protected resultConverter: typeof resolve;
    private entityModel;
    cloner<T>(item: T): Cloner<T>;
    model(): Promise<EntityContext>;
    dateRange(start: DateTime, end: DateTime, step: stepTypes): Query<IDateRange>;
    query<T extends IClrEntity>(m: IModel<T>, queryFunction?: string, ...args: any[]): Query<T>;
    delete<T extends IClrEntity>(body: T): Promise<void>;
    insert(body: IClrEntity): Promise<IClrEntity>;
    save<T extends IClrEntity>(body: T): Promise<T>;
    save<T extends IClrEntity>(body: T[]): Promise<T[]>;
    update<T extends IClrEntity>(e: T, update: IModifications): Promise<any>;
    bulkUpdate<T extends IClrEntity>(entities: T[], update: IModifications, throwWhenNotFound?: boolean): Promise<void>;
    bulkDelete<T extends IClrEntity>(entities: T[], throwWhenNotFound?: boolean): Promise<void>;
    protected fetchJson<T>(options: IHttpRequest): Promise<T>;
    protected createBusyIndicator(options: IHttpRequest): {
        dispose(): void;
    };
}
//# sourceMappingURL=BaseEntityService.d.ts.map