import { CancelToken } from "@web-atoms/core/dist/core/types.js";
import DateTime from "@web-atoms/date-time/dist/DateTime.js";
import { Cloner } from "../models/Cloner.js";
import IClrEntity, { IClrEntityLike } from "../models/IClrEntity.js";
import { EntityContext } from "../models/IEntityModel.js";
import Query, { IDateRange, stepTypes } from "./Query.js";
import resolve from "./resolve.js";
import { QueryProcessor } from "./QueryProcessor.js";
import TaskManager from "../models/TaskManager.js";
import FetchBuilder from "@web-atoms/core/dist/services/FetchBuilder.js";
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;
    doNotResolve?: boolean;
    hideActivityIndicator?: boolean;
    cacheSeconds?: number;
    cacheVersion?: string;
    cacheImmutable?: boolean;
    splitInclude?: boolean;
}
export interface IPagedListParams extends IListParams {
    start?: number;
    size?: number;
    more?: boolean;
    count?: boolean;
}
export interface IColumn {
    name?: string;
    type?: string;
    length?: number;
    dataType?: string;
    generated?: string;
    default?: any;
}
export interface IRelation {
    name?: string;
    fkMap?: {
        fk: string;
        relatedKey: string;
    }[];
    relatedName?: string;
    isCollection?: boolean;
    isInverse?: boolean;
    relatedModel?: IModel<any>;
}
export interface IModelSchema {
    name: string;
    keys: IColumn[];
    properties: IColumn[];
    relations: IRelation[];
    queries?: {
        [key: string]: any;
    };
    actions?: {
        [key: string]: any;
    };
}
export interface IModel<T, TQ = any, TA = any> {
    name: string;
    create?(properties?: IClrEntityLike<T>): T;
    patch?(original: IClrEntityLike<T>, updates: IClrEntityLike<T>): T;
    schema?: IModelSchema;
}
export declare class DefaultFactory {
    readonly factory: () => any;
    constructor(factory: () => any);
}
export declare class Model<T> implements IModel<T> {
    name: string;
    readonly keys: string[];
    schema: IModelSchema;
    private defaults;
    constructor(name: string, keys?: string[], defaults?: any, schema?: IModelSchema);
    create(properties?: IClrEntityLike<T>): T;
    patch(original: IClrEntityLike<T>, updates: IClrEntityLike<T>): T;
}
export type IPrimitive = string | null | number | boolean;
export type ArrayItem<T> = T extends Array<infer T> ? T : never;
export default abstract class BaseEntityService extends TaskManager {
    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, TR>(m: IModel<T, TR>, queryFunction?: keyof TR, ...args: IPrimitive[]): Query<T>;
    queryNavigation<T extends IClrEntity, PR extends keyof T>(entity: T, navigation: PR): Query<ArrayItem<T[PR]>>;
    queryNavigation<T extends IClrEntity, PR extends keyof T>(entity: T, navigation: PR): Query<T[PR]>;
    queryEntity<T extends IClrEntity, TR>(m: IModel<T, TR>, entity: T, queryFunction?: keyof TR, ...args: IPrimitive[]): Query<T>;
    as<TR>(): Query<TR>;
    delete<T extends IClrEntity>(body: T): Promise<void>;
    insert(body: IClrEntity): Promise<IClrEntity>;
    invoke<T extends IClrEntity, TA, TQ>(m: IModel<T, TQ, TA>, method: keyof TA, argEntity: T, ...args: any[]): Promise<any>;
    buildRunUrl<T extends IClrEntity, TA, TQ>(m: IModel<T, TQ, TA>, method: keyof TA, argEntity: T, { args, cacheSeconds, cacheVersion }?: {
        args?: any[];
        cacheSeconds?: number;
        cacheVersion?: any;
    }): string;
    run<T extends IClrEntity, TA, TQ>(m: IModel<T, TQ, TA>, method: keyof TA, argEntity: T, { args, cacheSeconds, cacheVersion }?: {
        args?: any[];
        cacheSeconds?: number;
        cacheVersion?: any;
    }): FetchBuilder;
    runFiltered<T extends IClrEntity, TA, TQ>(m: IModel<T, TQ, TA>, method: keyof TA, argEntity: T, ...args: any[]): Promise<FetchBuilder>;
    save<T extends IClrEntity>(body: T, cloner?: (c: Cloner<T>) => Cloner<T>, trace?: boolean): Promise<T>;
    save<T extends IClrEntity>(body: T[], cloner?: (c: Cloner<T>) => Cloner<T>, trace?: boolean): 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 createBusyIndicator(hideActivityIndicator?: boolean): {
        [Symbol.dispose](): void;
    };
}
//# sourceMappingURL=BaseEntityService.d.ts.map