ng2-rest 13.2.8 → 13.2.9

package/client/lib/content-type.d.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
-import { RestHeaders } from "./rest-headers";
-export declare const CONTENT_TYPE: {
-    APPLICATION_JSON: RestHeaders;
-    APPLICATINO_VND_API_JSON: RestHeaders;
+import { RestHeaders } from "./rest-headers";
+export declare const CONTENT_TYPE: {
+    APPLICATION_JSON: RestHeaders;
+    APPLICATINO_VND_API_JSON: RestHeaders;
 };

package/client/lib/cookie.d.ts

@@ -1,9 +1,9 @@
 // @ts-nocheck
-export declare class Cookie {
-    static get Instance(): Cookie;
-    private static __instance;
-    private constructor();
-    read(name: string): string;
-    write(name: string, value: string, days?: number): void;
-    remove(name: string): void;
+export declare class Cookie {
+    static get Instance(): Cookie;
+    private static __instance;
+    private constructor();
+    read(name: string): string;
+    write(name: string, value: string, days?: number): void;
+    remove(name: string): void;
 }

package/client/lib/helpers.d.ts

@@ -1,12 +1,12 @@
 // @ts-nocheck
-import { CoreHelpers } from 'tnp-core/browser';
-import { Mapping } from './mapping';
-import { JSON10 } from 'json10/browser';
-export declare class Helpers extends CoreHelpers {
-    static JSON: typeof JSON10;
-    static get Mapping(): {
-        encode<T = Function>(json: Object, mapping: Mapping.Mapping): T;
-        decode(json: Object, autodetect?: boolean): Mapping.Mapping;
-    };
-    static checkValidUrl(url: string): boolean;
+import { CoreHelpers } from 'tnp-core/browser';
+import { Mapping } from './mapping';
+import { JSON10 } from 'json10/browser';
+export declare class Helpers extends CoreHelpers {
+    static JSON: typeof JSON10;
+    static get Mapping(): {
+        encode<T = Function>(json: Object, mapping: Mapping.Mapping): T;
+        decode(json: Object, autodetect?: boolean): Mapping.Mapping;
+    };
+    static checkValidUrl(url: string): boolean;
 }

package/client/lib/index.d.ts

@@ -1,11 +1,11 @@
 // @ts-nocheck
-export * from './resource.service';
-export * from './models';
-export * from './mapping';
-export * from './rest.class';
-export * from './rest-headers';
-export * from './helpers';
-export * from './request-cache';
-export * from './content-type';
-export { SimpleResource } from './other/simple-resource';
+export * from './resource.service';
+export * from './models';
+export * from './mapping';
+export * from './rest.class';
+export * from './rest-headers';
+export * from './helpers';
+export * from './request-cache';
+export * from './content-type';
+export { SimpleResource } from './other/simple-resource';
 export { interpolateParamsToUrl } from './params';

package/client/lib/mapping.d.ts

@@ -1,14 +1,14 @@
 // @ts-nocheck
-import { Circ } from 'json10/browser';
-export declare namespace Mapping {
-    function decode(json: Object, autodetect?: boolean): Mapping;
-    function encode<T = Function>(json: Object, mapping: Mapping, circular?: Circ[]): T;
-    function getModelsMapping(entity: Function): {};
-    type Mapping<T = {}> = {
-        [P in keyof T]?: string | string[];
-    };
-    type ModelValue<T> = {
-        [propName in keyof T]?: T[propName];
-    };
-    function DefaultModelWithMapping<T = Object>(defaultModelValues?: ModelValue<T>, mapping?: Mapping<T>): (target: Function) => void;
+import { Circ } from 'json10/browser';
+export declare namespace Mapping {
+    function decode(json: Object, autodetect?: boolean): Mapping;
+    function encode<T = Function>(json: Object, mapping: Mapping, circular?: Circ[]): T;
+    function getModelsMapping(entity: Function): {};
+    type Mapping<T = {}> = {
+        [P in keyof T]?: string | string[];
+    };
+    type ModelValue<T> = {
+        [propName in keyof T]?: T[propName];
+    };
+    function DefaultModelWithMapping<T = Object>(defaultModelValues?: ModelValue<T>, mapping?: Mapping<T>): (target: Function) => void;
 }

package/client/lib/models.d.ts

@@ -1,159 +1,159 @@
 // @ts-nocheck
-import { Observable } from 'rxjs';
-import { Subject } from 'rxjs';
-import { RestHeaders } from './rest-headers';
-import { Rest } from './rest.class';
-import { Cookie } from './cookie';
-import { Mapping } from './mapping';
-import { Models as HelpersModels } from 'typescript-class-helpers/browser';
-import { Circ } from 'json10/browser';
-import { RequestCache } from './request-cache';
-import { ConfigModels } from 'tnp-config/browser';
-export declare namespace Models {
-    export import HttpMethod = ConfigModels.HttpMethod;
-    export import ParamType = ConfigModels.ParamType;
-    export import MethodConfig = HelpersModels.MethodConfig;
-    export import ClassConfig = HelpersModels.ClassConfig;
-    export import ParamConfig = HelpersModels.ParamConfig;
-    interface HandleResultOptions {
-        res: Models.MockResponse;
-        method: Models.HttpMethod;
-        jobid?: number;
-        isArray?: boolean;
-    }
-    interface HandleResultSourceRequestOptions {
-        url: string;
-        method: Models.HttpMethod;
-        body: any;
-        isArray: boolean;
-    }
-    type BackendError = {
-        msg?: string;
-        stack?: string[];
-        data: any;
-    };
-    type MetaRequest = {
-        path: string;
-        endpoint: string;
-        entity: Mapping.Mapping;
-        circular: Circ[];
-    };
-    type HttpCode = 200 | 400 | 401 | 404 | 500;
-    type PromiseObservableMix<T> = Promise<T> & {
-        cache?: RequestCache;
-        observable: Observable<T>;
-    };
-    type MethodWithoutBody<E, T, R = PromiseObservableMix<E>> = (params?: UrlParams[], doNotSerializeParams?: boolean) => R;
-    type MethodWithBody<E, T, R = PromiseObservableMix<E>> = (item?: T, params?: UrlParams[], doNotSerializeParams?: boolean) => R;
-    type ReplayData = {
-        subject: Subject<any>;
-        data: {
-            url: string;
-            body: string;
-            headers: RestHeaders;
-            isArray: boolean;
-        };
-        /**
-         * jobid
-         */
-        id: number;
-    };
-    type ReqParams = {
-        url: string;
-        method: ConfigModels.HttpMethod;
-        headers?: RestHeaders;
-        body?: any;
-        jobid: number;
-        isArray: boolean;
-    };
-    interface ResourceModel<A, TA> {
-        model: (pathModels?: Object, responseObjectType?: Function) => Rest<A, TA>;
-        replay: (method: ConfigModels.HttpMethod) => void;
-        headers: RestHeaders;
-    }
-    interface Ng2RestMethods<E, T> {
-        get: MethodWithoutBody<E, T>;
-        post: MethodWithBody<E, T>;
-        put: MethodWithBody<E, T>;
-        patch: MethodWithBody<E, T>;
-        head: MethodWithoutBody<E, T>;
-        delete: MethodWithoutBody<E, T>;
-        jsonp: MethodWithoutBody<E, T>;
-    }
-    type MockController = (url: string, method: ConfigModels.HttpMethod, headers?: RestHeaders, body?: any) => MockResponse;
-    type MockHttp = (MockResponse | MockController);
-    interface FnMethodsHttp<T, TA> extends Ng2RestMethods<HttpResponse<T>, T> {
-        array: Ng2RestMethods<HttpResponse<TA>, TA>;
-    }
-    interface FnMethodsHttpWithMock<T, TA> extends Ng2RestMethods<HttpResponse<T>, T> {
-        array: Ng2RestMethods<HttpResponse<TA>, TA>;
-        mock(mock: MockHttp, code: HttpCode): FnMethodsHttp<T, TA>;
-    }
-    interface NestedParams {
-        [params: string]: string;
-    }
-    interface UrlParams {
-        [urlModelName: string]: string | number | boolean | RegExp | Object;
-        regex?: RegExp;
-    }
-    abstract class BaseBody {
-        protected toJSON(data: any, isJSONArray?: boolean): any;
-    }
-    class HttpBody<T> extends BaseBody {
-        private responseText;
-        private isArray;
-        private entity;
-        private circular;
-        constructor(responseText: string | Blob, isArray: boolean, entity: Mapping.Mapping, circular: Circ[]);
-        get blob(): Blob;
-        get booleanValue(): boolean;
-        get rawJson(): Partial<T>;
-        get json(): T;
-        get text(): string;
-    }
-    class ErrorBody extends BaseBody {
-        private data;
-        constructor(data: any);
-        get json(): Object;
-        get text(): any;
-    }
-    abstract class BaseResponse<T> {
-        responseText?: string | Blob;
-        readonly headers?: RestHeaders;
-        readonly statusCode?: HttpCode | number;
-        isArray: boolean;
-        protected static readonly cookies: Cookie;
-        get cookies(): Cookie;
-        constructor(responseText?: string | Blob, headers?: RestHeaders, statusCode?: HttpCode | number, isArray?: boolean);
-    }
-    class HttpResponse<T> extends BaseResponse<T> {
-        sourceRequest: Models.HandleResultSourceRequestOptions;
-        responseText?: string | Blob;
-        headers?: RestHeaders;
-        statusCode?: HttpCode | number;
-        entity?: Mapping.Mapping | Function;
-        circular?: Circ[];
-        jobid?: number;
-        isArray: boolean;
-        body?: HttpBody<T>;
-        rq: RequestCache;
-        constructor(sourceRequest: Models.HandleResultSourceRequestOptions, responseText?: string | Blob, headers?: RestHeaders, statusCode?: HttpCode | number, entity?: Mapping.Mapping | Function, circular?: Circ[], jobid?: number, isArray?: boolean);
-        init(): void;
-        get cache(): RequestCache;
-    }
-    class HttpResponseError extends BaseResponse<any> {
-        message: string;
-        jobid?: number;
-        private body;
-        constructor(message: string, responseText?: string, headers?: RestHeaders, statusCode?: HttpCode | number, jobid?: number);
-    }
-    interface MockResponse {
-        data?: any;
-        code?: HttpCode;
-        error?: string;
-        headers?: RestHeaders;
-        jobid?: number;
-        isArray: boolean;
-    }
-    type ResponseTypeAxios = 'blob' | 'text';
+import { Observable } from 'rxjs';
+import { Subject } from 'rxjs';
+import { RestHeaders } from './rest-headers';
+import { Rest } from './rest.class';
+import { Cookie } from './cookie';
+import { Mapping } from './mapping';
+import { Models as HelpersModels } from 'typescript-class-helpers/browser';
+import { Circ } from 'json10/browser';
+import { RequestCache } from './request-cache';
+import { ConfigModels } from 'tnp-config/browser';
+export declare namespace Models {
+    export import HttpMethod = ConfigModels.HttpMethod;
+    export import ParamType = ConfigModels.ParamType;
+    export import MethodConfig = HelpersModels.MethodConfig;
+    export import ClassConfig = HelpersModels.ClassConfig;
+    export import ParamConfig = HelpersModels.ParamConfig;
+    interface HandleResultOptions {
+        res: Models.MockResponse;
+        method: Models.HttpMethod;
+        jobid?: number;
+        isArray?: boolean;
+    }
+    interface HandleResultSourceRequestOptions {
+        url: string;
+        method: Models.HttpMethod;
+        body: any;
+        isArray: boolean;
+    }
+    type BackendError = {
+        msg?: string;
+        stack?: string[];
+        data: any;
+    };
+    type MetaRequest = {
+        path: string;
+        endpoint: string;
+        entity: Mapping.Mapping;
+        circular: Circ[];
+    };
+    type HttpCode = 200 | 400 | 401 | 404 | 500;
+    type PromiseObservableMix<T> = Promise<T> & {
+        cache?: RequestCache;
+        observable: Observable<T>;
+    };
+    type MethodWithoutBody<E, T, R = PromiseObservableMix<E>> = (params?: UrlParams[], doNotSerializeParams?: boolean) => R;
+    type MethodWithBody<E, T, R = PromiseObservableMix<E>> = (item?: T, params?: UrlParams[], doNotSerializeParams?: boolean) => R;
+    type ReplayData = {
+        subject: Subject<any>;
+        data: {
+            url: string;
+            body: string;
+            headers: RestHeaders;
+            isArray: boolean;
+        };
+        /**
+         * jobid
+         */
+        id: number;
+    };
+    type ReqParams = {
+        url: string;
+        method: ConfigModels.HttpMethod;
+        headers?: RestHeaders;
+        body?: any;
+        jobid: number;
+        isArray: boolean;
+    };
+    interface ResourceModel<A, TA> {
+        model: (pathModels?: Object, responseObjectType?: Function) => Rest<A, TA>;
+        replay: (method: ConfigModels.HttpMethod) => void;
+        headers: RestHeaders;
+    }
+    interface Ng2RestMethods<E, T> {
+        get: MethodWithoutBody<E, T>;
+        post: MethodWithBody<E, T>;
+        put: MethodWithBody<E, T>;
+        patch: MethodWithBody<E, T>;
+        head: MethodWithoutBody<E, T>;
+        delete: MethodWithoutBody<E, T>;
+        jsonp: MethodWithoutBody<E, T>;
+    }
+    type MockController = (url: string, method: ConfigModels.HttpMethod, headers?: RestHeaders, body?: any) => MockResponse;
+    type MockHttp = (MockResponse | MockController);
+    interface FnMethodsHttp<T, TA> extends Ng2RestMethods<HttpResponse<T>, T> {
+        array: Ng2RestMethods<HttpResponse<TA>, TA>;
+    }
+    interface FnMethodsHttpWithMock<T, TA> extends Ng2RestMethods<HttpResponse<T>, T> {
+        array: Ng2RestMethods<HttpResponse<TA>, TA>;
+        mock(mock: MockHttp, code: HttpCode): FnMethodsHttp<T, TA>;
+    }
+    interface NestedParams {
+        [params: string]: string;
+    }
+    interface UrlParams {
+        [urlModelName: string]: string | number | boolean | RegExp | Object;
+        regex?: RegExp;
+    }
+    abstract class BaseBody {
+        protected toJSON(data: any, isJSONArray?: boolean): any;
+    }
+    class HttpBody<T> extends BaseBody {
+        private responseText;
+        private isArray;
+        private entity;
+        private circular;
+        constructor(responseText: string | Blob, isArray: boolean, entity: Mapping.Mapping, circular: Circ[]);
+        get blob(): Blob;
+        get booleanValue(): boolean;
+        get rawJson(): Partial<T>;
+        get json(): T;
+        get text(): string;
+    }
+    class ErrorBody extends BaseBody {
+        private data;
+        constructor(data: any);
+        get json(): Object;
+        get text(): any;
+    }
+    abstract class BaseResponse<T> {
+        responseText?: string | Blob;
+        readonly headers?: RestHeaders;
+        readonly statusCode?: HttpCode | number;
+        isArray: boolean;
+        protected static readonly cookies: Cookie;
+        get cookies(): Cookie;
+        constructor(responseText?: string | Blob, headers?: RestHeaders, statusCode?: HttpCode | number, isArray?: boolean);
+    }
+    class HttpResponse<T> extends BaseResponse<T> {
+        sourceRequest: Models.HandleResultSourceRequestOptions;
+        responseText?: string | Blob;
+        headers?: RestHeaders;
+        statusCode?: HttpCode | number;
+        entity?: Mapping.Mapping | Function;
+        circular?: Circ[];
+        jobid?: number;
+        isArray: boolean;
+        body?: HttpBody<T>;
+        rq: RequestCache;
+        constructor(sourceRequest: Models.HandleResultSourceRequestOptions, responseText?: string | Blob, headers?: RestHeaders, statusCode?: HttpCode | number, entity?: Mapping.Mapping | Function, circular?: Circ[], jobid?: number, isArray?: boolean);
+        init(): void;
+        get cache(): RequestCache;
+    }
+    class HttpResponseError extends BaseResponse<any> {
+        message: string;
+        jobid?: number;
+        private body;
+        constructor(message: string, responseText?: string, headers?: RestHeaders, statusCode?: HttpCode | number, jobid?: number);
+    }
+    interface MockResponse {
+        data?: any;
+        code?: HttpCode;
+        error?: string;
+        headers?: RestHeaders;
+        jobid?: number;
+        isArray: boolean;
+    }
+    type ResponseTypeAxios = 'blob' | 'text';
 }

package/client/lib/other/simple-resource.d.ts

@@ -1,31 +1,31 @@
 // @ts-nocheck
-import { Observable } from 'rxjs';
-import { Models } from '../models';
-export interface RestPromises<A, TA, QP extends Models.UrlParams> {
-    get: (queryParams?: QP) => Observable<Models.HttpResponse<A>>;
-    head: (queryParams?: QP) => Observable<Models.HttpResponse<A>>;
-    query: (queryParams?: QP) => Observable<Models.HttpResponse<TA>>;
-    put: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
-    patch: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
-    post: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
-    delete: (queryParams?: QP) => Observable<Models.HttpResponse<A> | any>;
-}
-export interface Model<A, TA, RP extends Object, QP extends Models.UrlParams> {
-    (restParams?: RP): RestPromises<A, TA, QP>;
-}
-/**
- *
- * @export
- * @class SimpleResource
- * @template A single model type
- * @template TA array model type
- * @template RP rest parameters type
- * @template QP query parameters type
- */
-export declare class SimpleResource<A, TA> {
-    model: Model<A, TA, Object, Models.UrlParams>;
-    private static _isSetQueryParamsSerialization;
-    static set doNotSerializeQueryParams(value: any);
-    static __destroy(): void;
-    constructor(endpoint: string, model: string);
+import { Observable } from 'rxjs';
+import { Models } from '../models';
+export interface RestPromises<A, TA, QP extends Models.UrlParams> {
+    get: (queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    head: (queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    query: (queryParams?: QP) => Observable<Models.HttpResponse<TA>>;
+    put: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    patch: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    post: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    delete: (queryParams?: QP) => Observable<Models.HttpResponse<A> | any>;
+}
+export interface Model<A, TA, RP extends Object, QP extends Models.UrlParams> {
+    (restParams?: RP): RestPromises<A, TA, QP>;
+}
+/**
+ *
+ * @export
+ * @class SimpleResource
+ * @template A single model type
+ * @template TA array model type
+ * @template RP rest parameters type
+ * @template QP query parameters type
+ */
+export declare class SimpleResource<A, TA> {
+    model: Model<A, TA, Object, Models.UrlParams>;
+    private static _isSetQueryParamsSerialization;
+    static set doNotSerializeQueryParams(value: any);
+    static __destroy(): void;
+    constructor(endpoint: string, model: string);
 }

package/client/lib/params.d.ts

@@ -1,25 +1,25 @@
 // @ts-nocheck
-import { Models } from './models';
-/** check if string is a valid pattern */
-export declare function isValid(pattern: string): boolean;
-export declare function check(url: string, pattern: string): boolean;
-export declare function getModels(pattern: string): string[];
-export declare function getRestPramsNames(pattern: string): string[];
-export declare function containsModels(url: string, models: string[]): boolean;
-export declare function stars(n: number): string;
-export declare function getRestParams(url: string, pattern: string): Object;
-export declare const regexisPath: RegExp;
-export declare function interpolateParamsToUrl(params: Object, url: string): string;
-/**
- * Get query params from url, like 'ex' in /api/books?ex=value
-*/
-export declare function decodeUrl(url: string): Object;
-/**
- * Create query params string for url
- *
- * @export
- * @param {UrlParams[]} params
- * @returns {string}
- */
-export declare function getParamsUrl(params: Models.UrlParams[], doNotSerialize?: boolean): string;
+import { Models } from './models';
+/** check if string is a valid pattern */
+export declare function isValid(pattern: string): boolean;
+export declare function check(url: string, pattern: string): boolean;
+export declare function getModels(pattern: string): string[];
+export declare function getRestPramsNames(pattern: string): string[];
+export declare function containsModels(url: string, models: string[]): boolean;
+export declare function stars(n: number): string;
+export declare function getRestParams(url: string, pattern: string): Object;
+export declare const regexisPath: RegExp;
+export declare function interpolateParamsToUrl(params: Object, url: string): string;
+/**
+ * Get query params from url, like 'ex' in /api/books?ex=value
+*/
+export declare function decodeUrl(url: string): Object;
+/**
+ * Create query params string for url
+ *
+ * @export
+ * @param {UrlParams[]} params
+ * @returns {string}
+ */
+export declare function getParamsUrl(params: Models.UrlParams[], doNotSerialize?: boolean): string;
 export declare function prepareUrlOldWay(params?: TemplateStringsArray): string;

package/client/lib/request-cache.d.ts

@@ -1,19 +1,19 @@
 // @ts-nocheck
-import { Models } from './models';
-/**
- * @deprecated
- * there is Cache API for that
- */
-export declare class RequestCache {
-    response: Models.HttpResponse<any>;
-    static readonly LOCAL_STORAGE_KEY = "ng2restrequestcache";
-    private static cached;
-    private static isRestoredFromLocalStorage;
-    private static restoreFromLocalStorage;
-    static findBy(sourceRequest: Models.HandleResultSourceRequestOptions): RequestCache;
-    constructor(response: Models.HttpResponse<any>);
-    get containsCache(): boolean;
-    private persistsInLocalStorage;
-    store(): this;
-    remove(): void;
+import { Models } from './models';
+/**
+ * @deprecated
+ * there is Cache API for that
+ */
+export declare class RequestCache {
+    response: Models.HttpResponse<any>;
+    static readonly LOCAL_STORAGE_KEY = "ng2restrequestcache";
+    private static cached;
+    private static isRestoredFromLocalStorage;
+    private static restoreFromLocalStorage;
+    static findBy(sourceRequest: Models.HandleResultSourceRequestOptions): RequestCache;
+    constructor(response: Models.HttpResponse<any>);
+    get containsCache(): boolean;
+    private persistsInLocalStorage;
+    store(): this;
+    remove(): void;
 }

package/client/lib/resource.service.d.ts

@@ -1,45 +1,45 @@
 // @ts-nocheck
-import { Observable } from 'rxjs';
-import { Subject } from 'rxjs';
-import { Rest } from './rest.class';
-import { RestHeaders } from './rest-headers';
-import { Cookie } from './cookie';
-import { Mapping } from './mapping';
-import { Models } from './models';
-import { Circ } from 'json10/browser';
-export declare class Resource<E, T, TA> {
-    protected static _listenErrors: Subject<Models.BackendError>;
-    protected static _listenSuccess: Subject<Models.HttpResponse<any>>;
-    static get listenErrors(): Observable<Models.BackendError>;
-    static get listenSuccessOperations(): Observable<Models.HttpResponse<any>>;
-    static enableWarnings: boolean;
-    private getZone;
-    static initAngularNgZone(zone: any): void;
-    private checkNestedModels;
-    private static instance;
-    private static endpoints;
-    static getModel(endpoint: string, model: string): Rest<any>;
-    private static request;
-    static create<A, TA = A[]>(e: string, model?: string, entityMapping?: Mapping.Mapping, circular?: Circ[], customContentType?: RestHeaders): Models.ResourceModel<A, TA>;
-    static reset(): void;
-    private constructor();
-    static Cookies: Cookie;
-    private static map;
-    private static prepareModel;
-    /**
-     * And enipoint to application
-     *
-     * @param {E} endpoint
-     * @param {string} model
-     * @returns {boolean}
-     */
-    private add;
-    /**
-     * Access api throught endpoint
-     *
-     * @param {E} endpoint
-     * @param {string} model
-     * @returns {Rest<T, TA>}
-     */
-    private api;
+import { Observable } from 'rxjs';
+import { Subject } from 'rxjs';
+import { Rest } from './rest.class';
+import { RestHeaders } from './rest-headers';
+import { Cookie } from './cookie';
+import { Mapping } from './mapping';
+import { Models } from './models';
+import { Circ } from 'json10/browser';
+export declare class Resource<E, T, TA> {
+    protected static _listenErrors: Subject<Models.BackendError>;
+    protected static _listenSuccess: Subject<Models.HttpResponse<any>>;
+    static get listenErrors(): Observable<Models.BackendError>;
+    static get listenSuccessOperations(): Observable<Models.HttpResponse<any>>;
+    static enableWarnings: boolean;
+    private getZone;
+    static initAngularNgZone(zone: any): void;
+    private checkNestedModels;
+    private static instance;
+    private static endpoints;
+    static getModel(endpoint: string, model: string): Rest<any>;
+    private static request;
+    static create<A, TA = A[]>(e: string, model?: string, entityMapping?: Mapping.Mapping, circular?: Circ[], customContentType?: RestHeaders): Models.ResourceModel<A, TA>;
+    static reset(): void;
+    private constructor();
+    static Cookies: Cookie;
+    private static map;
+    private static prepareModel;
+    /**
+     * And enipoint to application
+     *
+     * @param {E} endpoint
+     * @param {string} model
+     * @returns {boolean}
+     */
+    private add;
+    /**
+     * Access api throught endpoint
+     *
+     * @param {E} endpoint
+     * @param {string} model
+     * @returns {Rest<T, TA>}
+     */
+    private api;
 }