import { IBackendUtils, IJoinField, LoadFn, TransformGetFn, TransformPostFn, TransformPutFn } from '../interfaces/backend.interface';
import { BackendConfigArgs } from '../interfaces/configuration.interface';
import { IHttpErrorResponse, IHttpResponse, IPassThruBackend, IPostToOtherMethod, IRequestCore, IRequestInterceptor } from '../interfaces/interceptor.interface';
import { CompareFn, FilterFn, FilterOp, IQueryCursor, IQueryFilter, IQueryOrder, IQueryParams, IQueryResult, IQuickFilter } from '../interfaces/query.interface';
import { IParsedRequestUrl } from '../interfaces/url.interface';
import { Logger } from '../utils/logger';
import 'json.date-extensions';
export type ExtendEntity = {
    [key: string]: unknown;
} & {
    id?: string | number;
};
interface IInterceptorInfo {
    interceptor?: IRequestInterceptor;
    interceptorIds?: string[];
}
export declare function removeRightSlash(path: string): string;
export declare function removeLeftSlash(path: string): string;
export declare function paramParser(rawParams: string): Map<string, string[]>;
export declare const LOG: Logger;
export declare const cssBIB = "font-style: italic; font-weight: bold; color: brown";
export declare const cssBIG = "font-style: italic; font-weight: bold; color: darkgreen";
export declare abstract class BackendService {
    protected loadsFn: Array<LoadFn>;
    protected replaceMap: Map<string, string[][]>;
    protected postToOtherMethodMap: Map<string, IPostToOtherMethod[]>;
    protected transformGetAllMap: Map<string, TransformGetFn>;
    protected transformGetByIdMap: Map<string, TransformGetFn>;
    protected joinnersGetAllMap: Map<string, IJoinField[]>;
    protected joinnersGetByIdMap: Map<string, IJoinField[]>;
    protected transformPostMap: Map<string, TransformPostFn>;
    protected transformPutMap: Map<string, TransformPutFn>;
    protected fieldsFilterMap: Map<string, Map<string, FilterFn | FilterOp>>;
    protected fieldsCompareMap: Map<string, Map<string, CompareFn>>;
    protected quickFilterMap: Map<string, IQuickFilter>;
    private requestInterceptors;
    protected dbReadyFn: (value: boolean) => void;
    protected dbReadyPromise: Promise<boolean>;
    private passThruBackend;
    protected config: BackendConfigArgs;
    protected utils: IBackendUtils;
    constructor(config?: BackendConfigArgs);
    private onDbReadyAjustJoinFields;
    backendUtils(value: IBackendUtils): void;
    addTransformGetAllMap(collectionName: string, transformfn: TransformGetFn): void;
    addTransformGetByIdMap(collectionName: string, transformfn: TransformGetFn): void;
    clearTransformGetBothMap(collectionName: string): void;
    addJoinGetAllMap(collectionName: string, joinField: IJoinField): void;
    addJoinGetByIdMap(collectionName: string, joinField: IJoinField): void;
    addJoinGetBothMap(collectionName: string, joinField: IJoinField): void;
    clearJoinGetBothMap(collectionName: string): void;
    addTransformPostMap(collectionName: string, transformfn: TransformPostFn): void;
    clearTransformPostMap(collectionName: string): void;
    addTransformPutMap(collectionName: string, transformfn: TransformPutFn): void;
    clearTransformPutMap(collectionName: string): void;
    addQuickFilterMap(collectionName: string, quickFilter: IQuickFilter): void;
    clearQuickFilterMap(collectionName: string): void;
    addFieldFilterMap(collectionName: string, field: string, filterfn: FilterFn | FilterOp): void;
    clearFieldFilterMap(collectionName: string): void;
    addFieldCompareMap(collectionName: string, field: string, compareFn: CompareFn): void;
    clearFieldCompareMap(collectionName: string): void;
    addReplaceUrl(collectionName: string, replace: string | string[]): void;
    clearReplaceUrl(collectionName: string): void;
    addPostToOtherMethodMap(collectionName: string, postToOtherMethod: IPostToOtherMethod): void;
    addRequestInterceptor(requestInterceptor: IRequestInterceptor): IRequestInterceptor | null;
    removeRequestInterceptor(requestInterceptor: IRequestInterceptor): IRequestInterceptor | null;
    private adjustInterceptor;
    private isEqualsInterceptor;
    addRequestInterceptorByValue(value: IRequestInterceptor | string): void;
    private adjustJoinFieldsGetAll;
    private adjustJoinFieldsGetById;
    adjustJoinFields(): void;
    protected logRequest(request: IRequestCore<ExtendEntity>): void;
    protected logResponse(response: IHttpResponse<unknown> | IHttpErrorResponse): void;
    protected convertResponse(response: IHttpResponse<unknown>): IHttpResponse<unknown>;
    handleRequest<T>(req: IRequestCore<unknown>): Promise<IHttpResponse<T>>;
    private handleRequest_;
    abstract hasCollection(collectionName: string): boolean;
    private collectionHandler;
    abstract getInstance$(collectionName: string, id: string | number): Promise<ExtendEntity>;
    abstract getAllByFilter$(collectionName: string, conditions?: Array<IQueryFilter>): Promise<ExtendEntity[]>;
    abstract get$<T = ExtendEntity>(collectionName: string, id: string | undefined, query: Map<string, string[]> | undefined, url: string, getJoinFields?: IJoinField[], caseSensitiveSearch?: boolean): Promise<IHttpResponse<(T | T[]) | {
        data: (T | T[]);
    } | IQueryResult<T>>>;
    private get;
    private createJoinTransformGetFn;
    protected applyTransformersGetById(collectionName: string, item: ExtendEntity, getJoinFields?: IJoinField[]): Promise<ExtendEntity>;
    protected applyTransformersGetAll(collectionName: string, items: ExtendEntity[], getJoinFields?: IJoinField[]): Promise<void>;
    protected applyJoinFields(item: ExtendEntity, joinFields: IJoinField[]): Promise<ExtendEntity>;
    protected applyTransformGetFn(item: ExtendEntity, transformfn: TransformGetFn): Promise<ExtendEntity>;
    abstract post$(collectionName: string, id: string, item: ExtendEntity, url: string): Promise<IHttpResponse<unknown>>;
    private post;
    protected applyTransformPost(body: unknown, transformfn: TransformPostFn): Promise<ExtendEntity>;
    abstract put$(collectionName: string, id: string, item: ExtendEntity, url: string): Promise<IHttpResponse<unknown>>;
    private put;
    protected applyTransformPut(item: ExtendEntity, body: ExtendEntity, transformfn: TransformPutFn): Promise<ExtendEntity>;
    abstract delete$(collectionName: string, id: string, url: string): Promise<IHttpResponse<null>>;
    private delete;
    protected pagefy(queryResults: IQueryResult<ExtendEntity>, queryParams: IQueryParams): IQueryResult<ExtendEntity> | {
        data: ExtendEntity[];
    } | ExtendEntity[];
    protected bodify<T>(data: T): {
        data: T;
    } | T;
    private addDelay;
    private getFieldFilterMap;
    private filterItem;
    private getFieldValue;
    private filterItemAnd;
    private filterItemOr;
    private createFilterFn;
    private createFilterOpFn;
    private createFilterArrayFn;
    protected getQueryParams(collectionName: string, query: Map<string, string[]>, caseSensitiveSearch: boolean): IQueryParams;
    protected getQueryParamsRootAndChild(queryParams: IQueryParams): {
        root: IQueryParams;
        children: IQueryParams;
    };
    protected getAllItems(cursor: IQueryCursor<ExtendEntity>, queryResults: IQueryResult<ExtendEntity>, queryParams: IQueryParams): boolean;
    protected getAllItemsFilterByChildren(items: ExtendEntity[], queryParams: IQueryParams): IQueryResult<ExtendEntity>;
    private hasRequestInterceptor;
    private compareRequestInterceptor;
    private hasDefaultRequestInterceptor;
    private compareDefaultRequestInterceptor;
    private processInterceptResponse;
    private interceptResponse;
    /**
     * Get location info from a url, even on server where `document` is not defined
     */
    private getLocation;
    private applyReplaceMap;
    /**
     * Parses the request URL into a `ParsedRequestUrl` object.
     * Parsing depends upon certain values of `config`: `apiBase`, `host`, and `urlRoot`.
     *
     * Configuring the `apiBase` yields the most interesting changes to `parseRequestUrl` behavior:
     *   When apiBase=undefined and url='http://localhost/api/collection/42'
     *     {base: 'api/', collectionName: 'collection', id: '42', ...}
     *   When apiBase='some/api/root/' and url='http://localhost/some/api/root/collection'
     *     {base: 'some/api/root/', collectionName: 'collection', id: undefined, ...}
     *   When apiBase='/' and url='http://localhost/collection'
     *     {base: '/', collectionName: 'collection', id: undefined, ...}
     *
     * The actual api base segment values are ignored. Only the number of segments matters.
     * The following api base strings are considered identical: 'a/b' ~ 'some/api/' ~ `two/segments'
     *
     * To replace this default method, assign your alternative to your InMemDbService['parseRequestUrl']
     */
    protected parseRequestUrl(method: string, url: string, intInfo: IInterceptorInfo): IParsedRequestUrl;
    private getPostToOtherMethod;
    /**
     * get or create the function that passes unhandled requests
     * through to the "real" backend.
     */
    protected getPassThruBackend(): IPassThruBackend;
    private createFilterConditions;
    private createInterceptorUtils;
    protected dispatchErrorToResponse(reject: (error: IHttpErrorResponse) => void, url: string, error: unknown): void;
    protected orderItems(collectionName: string, items: ExtendEntity[], orders: IQueryOrder[]): ExtendEntity[];
    protected createFetchBackend(): IPassThruBackend;
}
export {};