ng2-rest 21.0.15 → 21.0.17

package/browser-prod/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "ng2-rest/browser-prod",
+  "version": "21.0.17",
+  "peerDependencies": {
+    "@angular/common": "^21.0.0",
+    "@angular/core": "^21.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/ng2-rest-browser.mjs",
+  "typings": "types/ng2-rest-browser.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/ng2-rest-browser.d.ts",
+      "default": "./fesm2022/ng2-rest-browser.mjs"
+    }
+  }
+}

package/browser-prod/types/ng2-rest-browser.d.ts

@@ -2,8 +2,7 @@
 import { Circ, JSON10 } from 'json10/browser-prod';
 import { Observable, Subject } from 'rxjs';
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { CoreModels, CoreHelpers } from 'tnp-core/browser-prod';
-import { Models as Models$1 } from 'typescript-class-helpers/browser-prod';
+import { CoreModels_HttpMethod, CoreHelpers } from 'tnp-core/browser-prod';
 import express from 'express';
 
 declare class Cookie {
@@ -15,18 +14,16 @@ declare class Cookie {
     remove(name: string): void;
 }
 
-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;
-}
+declare function Mapping_decode(json: Object, autodetect?: boolean): Mapping_Mapping;
+declare function Mapping_encode<T = Function>(json: Object, mapping: Mapping_Mapping, circular?: Circ[]): T;
+declare function Mapping_getModelsMapping(entity: Function): {};
+type Mapping_Mapping<T = {}> = {
+    [P in keyof T]?: string | string[];
+};
+type Mapping_ModelValue<T> = {
+    [propName in keyof T]?: T[propName];
+};
+declare function Mapping_DefaultModelWithMapping<T = Object>(defaultModelValues?: Mapping_ModelValue<T>, mapping?: Mapping_Mapping<T>): (target: Function) => void;
 
 /**
  * Based on Headers from https://github.com/angular/angular/blob/master/packages/http/src/headers.ts
@@ -124,22 +121,22 @@ declare class RestRequest {
     private req;
     private getReplay;
     private generalReq;
-    get(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
-    head(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
-    delete(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
-    post(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
-    put(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
-    patch(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
-    jsonp(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
+    get(url: string, body: string, headers: RestHeaders, meta: Models_MetaRequest, isArray: boolean, mockHttp: Models_MockHttp, axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<any>;
+    head(url: string, body: string, headers: RestHeaders, meta: Models_MetaRequest, isArray: boolean, mockHttp: Models_MockHttp, axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<any>;
+    delete(url: string, body: string, headers: RestHeaders, meta: Models_MetaRequest, isArray: boolean, mockHttp: Models_MockHttp, axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<any>;
+    post(url: string, body: string, headers: RestHeaders, meta: Models_MetaRequest, isArray: boolean, mockHttp: Models_MockHttp, axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<any>;
+    put(url: string, body: string, headers: RestHeaders, meta: Models_MetaRequest, isArray: boolean, mockHttp: Models_MockHttp, axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<any>;
+    patch(url: string, body: string, headers: RestHeaders, meta: Models_MetaRequest, isArray: boolean, mockHttp: Models_MockHttp, axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<any>;
+    jsonp(url: string, body: string, headers: RestHeaders, meta: Models_MetaRequest, isArray: boolean, mockHttp: Models_MockHttp, axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<any>;
     private replaySubjects;
 }
 
-declare class Rest<T, TA = T[]> implements Models.FnMethodsHttpWithMock<T, TA> {
+declare class Rest<T, TA = T[]> implements Models_FnMethodsHttpWithMock<T, TA> {
     private request;
     private meta;
     private customContentType;
     private mockHttp;
-    mock(mock: Models.MockHttp): Models.FnMethodsHttp<T, TA>;
+    mock(mock: Models_MockHttp): Models_FnMethodsHttp<T, TA>;
     private __meta_endpoint;
     private _endpointRest;
     private get endpoint();
@@ -148,24 +145,24 @@ declare class Rest<T, TA = T[]> implements Models.FnMethodsHttpWithMock<T, TA> {
     private creatUrl;
     private _headers;
     get headers(): RestHeaders;
-    constructor(endpoint: string, request: RestRequest, meta: Models.MetaRequest, customContentType: RestHeaders);
+    constructor(endpoint: string, request: RestRequest, meta: Models_MetaRequest, customContentType: RestHeaders);
     private req;
     array: {
-        get: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
-        head: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
-        post: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
-        put: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
-        patch: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
-        delete: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
-        jsonp: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
+        get: (item: TA, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig) => Models_PromiseObservableMix<Models_HttpResponse<TA>>;
+        head: (item: TA, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig) => Models_PromiseObservableMix<Models_HttpResponse<TA>>;
+        post: (item: TA, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig) => Models_PromiseObservableMix<Models_HttpResponse<TA>>;
+        put: (item: TA, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig) => Models_PromiseObservableMix<Models_HttpResponse<TA>>;
+        patch: (item: TA, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig) => Models_PromiseObservableMix<Models_HttpResponse<TA>>;
+        delete: (item: TA, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig) => Models_PromiseObservableMix<Models_HttpResponse<TA>>;
+        jsonp: (item: TA, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig) => Models_PromiseObservableMix<Models_HttpResponse<TA>>;
     };
-    get(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
-    head(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
-    post(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
-    put(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
-    patch(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
-    delete(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
-    jsonp(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
+    get(item: T, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<Models_HttpResponse<T>>;
+    head(item: T, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<Models_HttpResponse<T>>;
+    post(item: T, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<Models_HttpResponse<T>>;
+    put(item: T, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<Models_HttpResponse<T>>;
+    patch(item: T, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<Models_HttpResponse<T>>;
+    delete(item: T, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<Models_HttpResponse<T>>;
+    jsonp(item: T, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig): Models_PromiseObservableMix<Models_HttpResponse<T>>;
 }
 
 declare class RestCommonHttpResponseWrapper {
@@ -189,172 +186,165 @@ declare class RestErrorResponseWrapper extends RestCommonHttpResponseWrapper {
      */
     code?: string;
 }
-declare namespace Models {
-    export import HttpMethod = CoreModels.HttpMethod;
-    export import ParamType = CoreModels.ParamType;
-    export import MethodConfig = Models$1.MethodConfig;
-    export import ClassConfig = Models$1.ClassConfig;
-    export import ParamConfig = Models$1.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> & {
-        observable: Observable<T>;
-    };
-    type Ng2RestAxiosRequestConfig = {
-        doNotSerializeParams?: boolean;
-    } & AxiosRequestConfig<any>;
-    type MethodWithBody<E, T, R = PromiseObservableMix<E>> = (item?: T, params?: UrlParams[], axiosOptions?: Ng2RestAxiosRequestConfig) => R;
-    type ReplayData = {
-        subject: Subject<any>;
-        data: {
-            url: string;
-            body: string;
-            headers: RestHeaders;
-            isArray: boolean;
-        };
-        /**
-         * jobid
-         */
-        id: number;
-    };
-    type ReqParams = {
+interface Models_HandleResultOptions {
+    res: Models_MockResponse;
+    method: CoreModels_HttpMethod;
+    jobid?: number;
+    isArray?: boolean;
+}
+interface Models_HandleResultSourceRequestOptions {
+    url: string;
+    method: CoreModels_HttpMethod;
+    body: any;
+    isArray: boolean;
+}
+type Models_BackendError = {
+    msg?: string;
+    stack?: string[];
+    data: any;
+};
+type Models_MetaRequest = {
+    path: string;
+    endpoint: string;
+    entity: Mapping_Mapping;
+    circular: Circ[];
+};
+type Models_HttpCode = 200 | 400 | 401 | 404 | 500;
+type Models_PromiseObservableMix<T> = Promise<T> & {
+    observable: Observable<T>;
+};
+type Models_Ng2RestAxiosRequestConfig = {
+    doNotSerializeParams?: boolean;
+} & AxiosRequestConfig<any>;
+type Models_MethodWithBody<E, T, R = Models_PromiseObservableMix<E>> = (item?: T, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig) => R;
+type Models_ReplayData = {
+    subject: Subject<any>;
+    data: {
         url: string;
-        method: CoreModels.HttpMethod;
-        headers?: RestHeaders;
-        body?: any;
-        jobid: number;
-        isArray: boolean;
-    };
-    interface ResourceModel<A, TA> {
-        model: (pathModels?: Object, responseObjectType?: Function) => Rest<A, TA>;
+        body: string;
         headers: RestHeaders;
-    }
-    interface Ng2RestMethods<E, T> {
-        get: MethodWithBody<E, T>;
-        post: MethodWithBody<E, T>;
-        put: MethodWithBody<E, T>;
-        patch: MethodWithBody<E, T>;
-        head: MethodWithBody<E, T>;
-        delete: MethodWithBody<E, T>;
-        jsonp: MethodWithBody<E, T>;
-    }
-    type MockController = (url: string, method: CoreModels.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>;
-    }
-    interface NestedParams {
-        [params: string]: string;
-    }
-    interface UrlParams {
-        [urlModelName: string]: string | number | boolean | RegExp | Object;
-        regex?: RegExp;
-    }
-    abstract class BaseBody {
-        protected toJSON(data: any, opt: {
-            isJSONArray?: boolean;
-            parsingError?: boolean;
-        }): object | undefined;
-    }
-    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 | undefined;
-        get numericValue(): number | undefined;
-        get rawJson(): Partial<T>;
-        get json(): T;
-        /**
-         * undefined when blob
-         */
-        get text(): string | undefined;
-    }
-    class ErrorBody<T = RestErrorResponseWrapper> extends BaseBody {
-        private data;
-        constructor(data: any);
-        get json(): T;
-        get text(): string;
-    }
-    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>;
-        constructor(sourceRequest: Models.HandleResultSourceRequestOptions, responseText?: string | Blob, headers?: RestHeaders, statusCode?: HttpCode | number, entity?: Mapping.Mapping | Function, circular?: Circ[], jobid?: number, isArray?: boolean);
-        init(): void;
-    }
-    interface MockResponse {
-        data?: any;
-        code?: HttpCode;
-        error?: string;
-        headers?: RestHeaders;
-        jobid?: number;
-        isArray: boolean;
-    }
-    type ResponseTypeAxios = 'blob' | 'text';
+    };
+    /**
+     * jobid
+     */
+    id: number;
+};
+type Models_ReqParams = {
+    url: string;
+    method: CoreModels_HttpMethod;
+    headers?: RestHeaders;
+    body?: any;
+    jobid: number;
+    isArray: boolean;
+};
+interface Models_ResourceModel<A, TA> {
+    model: (pathModels?: Object, responseObjectType?: Function) => Rest<A, TA>;
+    headers: RestHeaders;
+}
+interface Models_Ng2RestMethods<E, T> {
+    get: Models_MethodWithBody<E, T>;
+    post: Models_MethodWithBody<E, T>;
+    put: Models_MethodWithBody<E, T>;
+    patch: Models_MethodWithBody<E, T>;
+    head: Models_MethodWithBody<E, T>;
+    delete: Models_MethodWithBody<E, T>;
+    jsonp: Models_MethodWithBody<E, T>;
+}
+type Models_MockController = (url: string, method: CoreModels_HttpMethod, headers?: RestHeaders, body?: any) => Models_MockResponse;
+type Models_MockHttp = Models_MockResponse | Models_MockController;
+interface Models_FnMethodsHttp<T, TA> extends Models_Ng2RestMethods<Models_HttpResponse<T>, T> {
+    array: Models_Ng2RestMethods<Models_HttpResponse<TA>, TA>;
 }
-declare class HttpResponseError<ERROR_BODY = object> extends Models.BaseResponse<any> {
+interface Models_FnMethodsHttpWithMock<T, TA> extends Models_Ng2RestMethods<Models_HttpResponse<T>, T> {
+    array: Models_Ng2RestMethods<Models_HttpResponse<TA>, TA>;
+}
+interface Models_NestedParams {
+    [params: string]: string;
+}
+interface Models_UrlParams {
+    [urlModelName: string]: string | number | boolean | RegExp | Object;
+    regex?: RegExp;
+}
+declare abstract class Models_BaseBody {
+    protected toJSON(data: any, opt: {
+        isJSONArray?: boolean;
+        parsingError?: boolean;
+    }): object | undefined;
+}
+declare class Models_HttpBody<T> extends Models_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 | undefined;
+    get numericValue(): number | undefined;
+    get rawJson(): Partial<T>;
+    get json(): T;
+    /**
+     * undefined when blob
+     */
+    get text(): string | undefined;
+}
+declare class Models_ErrorBody<T = RestErrorResponseWrapper> extends Models_BaseBody {
+    private data;
+    constructor(data: any);
+    get json(): T;
+    get text(): string;
+}
+declare abstract class Models_BaseResponse<T> {
+    responseText?: string | Blob;
+    readonly headers?: RestHeaders;
+    readonly statusCode?: Models_HttpCode | number;
+    isArray: boolean;
+    protected static readonly cookies: Cookie;
+    get cookies(): Cookie;
+    constructor(responseText?: string | Blob, headers?: RestHeaders, statusCode?: Models_HttpCode | number, isArray?: boolean);
+}
+declare class Models_HttpResponse<T> extends Models_BaseResponse<T> {
+    sourceRequest: Models_HandleResultSourceRequestOptions;
+    responseText?: string | Blob;
+    headers?: RestHeaders;
+    statusCode?: Models_HttpCode | number;
+    entity?: Mapping_Mapping | Function;
+    circular?: Circ[];
+    jobid?: number;
+    isArray: boolean;
+    body: Models_HttpBody<T>;
+    constructor(sourceRequest: Models_HandleResultSourceRequestOptions, responseText?: string | Blob, headers?: RestHeaders, statusCode?: Models_HttpCode | number, entity?: Mapping_Mapping | Function, circular?: Circ[], jobid?: number, isArray?: boolean);
+    init(): void;
+}
+interface Models_MockResponse {
+    data?: any;
+    code?: Models_HttpCode;
+    error?: string;
+    headers?: RestHeaders;
+    jobid?: number;
+    isArray: boolean;
+}
+type Models_ResponseTypeAxios = 'blob' | 'text';
+declare class HttpResponseError<ERROR_BODY = object> extends Models_BaseResponse<any> {
     message: string;
     jobid?: number;
-    sourceRequest?: Models.HandleResultSourceRequestOptions;
-    readonly body: Models.ErrorBody<ERROR_BODY>;
-    constructor(message: string, responseText?: string, headers?: RestHeaders, statusCode?: Models.HttpCode | number, jobid?: number, sourceRequest?: Models.HandleResultSourceRequestOptions);
+    sourceRequest?: Models_HandleResultSourceRequestOptions;
+    readonly body: Models_ErrorBody<ERROR_BODY>;
+    constructor(message: string, responseText?: string, headers?: RestHeaders, statusCode?: Models_HttpCode | number, jobid?: number, sourceRequest?: Models_HandleResultSourceRequestOptions);
 }
 
 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>>;
+    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 checkNestedModels;
     private static instance;
     private static endpoints;
     static getModel(endpoint: string, model: string): Rest<any>;
     static request: RestRequest;
-    static create<A, TA = A[]>(e: string, model?: string, entityMapping?: Mapping.Mapping, circular?: Circ[], customContentType?: RestHeaders): Models.ResourceModel<A, TA>;
+    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;
@@ -381,8 +371,8 @@ declare class Resource<E, T, TA> {
 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;
+        encode<T = Function>(json: Object, mapping: Mapping_Mapping): T;
+        decode(json: Object, autodetect?: boolean): Mapping_Mapping;
     };
     static checkValidUrl(url: string): boolean;
 }
@@ -392,16 +382,16 @@ declare const CONTENT_TYPE: {
     APPLICATINO_VND_API_JSON: RestHeaders;
 };
 
-interface RestPromises<A, TA, QP extends Models.UrlParams> {
-    get: (tem?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
-    head: (tem?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
-    query: (tem?: A, 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: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A> | any>;
-}
-interface Model<A, TA, RP extends Object, QP extends Models.UrlParams> {
+interface RestPromises<A, TA, QP extends Models_UrlParams> {
+    get: (tem?: A, queryParams?: QP) => Observable<Models_HttpResponse<A>>;
+    head: (tem?: A, queryParams?: QP) => Observable<Models_HttpResponse<A>>;
+    query: (tem?: A, 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: (item?: A, queryParams?: QP) => Observable<Models_HttpResponse<A> | any>;
+}
+interface Model<A, TA, RP extends Object, QP extends Models_UrlParams> {
     (restParams?: RP): RestPromises<A, TA, QP>;
 }
 /**
@@ -414,7 +404,7 @@ interface Model<A, TA, RP extends Object, QP extends Models.UrlParams> {
  * @template QP query parameters type
  */
 declare class SimpleResource<A, TA> {
-    model: Model<A, TA, Object, Models.UrlParams>;
+    model: Model<A, TA, Object, Models_UrlParams>;
     private static _isSetQueryParamsSerialization;
     static set doNotSerializeQueryParams(value: any);
     static __destroy(): void;
@@ -423,5 +413,5 @@ declare class SimpleResource<A, TA> {
 
 declare function interpolateParamsToUrl(params: Object, url: string): string;
 
-export { AxiosBackendHandler, CONTENT_TYPE, Helpers, HttpResponseError, Mapping, Models, Resource, Rest, RestErrorResponseWrapper, RestHeaders, RestResponseWrapper, SimpleResource, buildInterceptorChain, interpolateParamsToUrl };
-export type { AxiosTaonHttpHandler, RestHeadersOptions, TaonAxiosClientInterceptor, TaonClientMiddlewareInterceptOptions, TaonServerMiddlewareInterceptOptions };
+export { AxiosBackendHandler, CONTENT_TYPE, Helpers, HttpResponseError, Mapping_DefaultModelWithMapping, Mapping_decode, Mapping_encode, Mapping_getModelsMapping, Models_BaseBody, Models_BaseResponse, Models_ErrorBody, Models_HttpBody, Models_HttpResponse, Resource, Rest, RestErrorResponseWrapper, RestHeaders, RestResponseWrapper, SimpleResource, buildInterceptorChain, interpolateParamsToUrl };
+export type { AxiosTaonHttpHandler, Mapping_Mapping, Mapping_ModelValue, Models_BackendError, Models_FnMethodsHttp, Models_FnMethodsHttpWithMock, Models_HandleResultOptions, Models_HandleResultSourceRequestOptions, Models_HttpCode, Models_MetaRequest, Models_MethodWithBody, Models_MockController, Models_MockHttp, Models_MockResponse, Models_NestedParams, Models_Ng2RestAxiosRequestConfig, Models_Ng2RestMethods, Models_PromiseObservableMix, Models_ReplayData, Models_ReqParams, Models_ResourceModel, Models_ResponseTypeAxios, Models_UrlParams, RestHeadersOptions, TaonAxiosClientInterceptor, TaonClientMiddlewareInterceptOptions, TaonServerMiddlewareInterceptOptions };

package/browser-prod.split-namespaces.json

@@ -0,0 +1,72 @@
+{
+  "namespacesMapObj": {
+    "Mapping.decode": "Mapping_decode",
+    "Mapping.encode": "Mapping_encode",
+    "Mapping.getModelsMapping": "Mapping_getModelsMapping",
+    "Mapping.Mapping": "Mapping_Mapping",
+    "Mapping.ModelValue": "Mapping_ModelValue",
+    "Mapping.DefaultModelWithMapping": "Mapping_DefaultModelWithMapping",
+    "Models.HandleResultOptions": "Models_HandleResultOptions",
+    "Models.HandleResultSourceRequestOptions": "Models_HandleResultSourceRequestOptions",
+    "Models.BackendError": "Models_BackendError",
+    "Models.MetaRequest": "Models_MetaRequest",
+    "Models.HttpCode": "Models_HttpCode",
+    "Models.PromiseObservableMix": "Models_PromiseObservableMix",
+    "Models.Ng2RestAxiosRequestConfig": "Models_Ng2RestAxiosRequestConfig",
+    "Models.MethodWithBody": "Models_MethodWithBody",
+    "Models.ReplayData": "Models_ReplayData",
+    "Models.ReqParams": "Models_ReqParams",
+    "Models.ResourceModel": "Models_ResourceModel",
+    "Models.Ng2RestMethods": "Models_Ng2RestMethods",
+    "Models.MockController": "Models_MockController",
+    "Models.MockHttp": "Models_MockHttp",
+    "Models.FnMethodsHttp": "Models_FnMethodsHttp",
+    "Models.FnMethodsHttpWithMock": "Models_FnMethodsHttpWithMock",
+    "Models.NestedParams": "Models_NestedParams",
+    "Models.UrlParams": "Models_UrlParams",
+    "Models.BaseBody": "Models_BaseBody",
+    "Models.HttpBody": "Models_HttpBody",
+    "Models.ErrorBody": "Models_ErrorBody",
+    "Models.BaseResponse": "Models_BaseResponse",
+    "Models.HttpResponse": "Models_HttpResponse",
+    "Models.MockResponse": "Models_MockResponse",
+    "Models.ResponseTypeAxios": "Models_ResponseTypeAxios"
+  },
+  "namespacesReplace": {
+    "Mapping": [
+      "Mapping_DefaultModelWithMapping",
+      "Mapping_Mapping",
+      "Mapping_ModelValue",
+      "Mapping_decode",
+      "Mapping_encode",
+      "Mapping_getModelsMapping"
+    ],
+    "Models": [
+      "Models_BackendError",
+      "Models_BaseBody",
+      "Models_BaseResponse",
+      "Models_ErrorBody",
+      "Models_FnMethodsHttp",
+      "Models_FnMethodsHttpWithMock",
+      "Models_HandleResultOptions",
+      "Models_HandleResultSourceRequestOptions",
+      "Models_HttpBody",
+      "Models_HttpCode",
+      "Models_HttpResponse",
+      "Models_MetaRequest",
+      "Models_MethodWithBody",
+      "Models_MockController",
+      "Models_MockHttp",
+      "Models_MockResponse",
+      "Models_NestedParams",
+      "Models_Ng2RestAxiosRequestConfig",
+      "Models_Ng2RestMethods",
+      "Models_PromiseObservableMix",
+      "Models_ReplayData",
+      "Models_ReqParams",
+      "Models_ResourceModel",
+      "Models_ResponseTypeAxios",
+      "Models_UrlParams"
+    ]
+  }
+}

package/lib/build-info._auto-generated_.d.ts

@@ -21,4 +21,4 @@ export declare const CURRENT_PACKAGE_TAON_VERSION = "v21";
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-export declare const CURRENT_PACKAGE_VERSION = "21.0.15";
+export declare const CURRENT_PACKAGE_VERSION = "21.0.17";

package/lib/build-info._auto-generated_.js

@@ -25,6 +25,6 @@ exports.CURRENT_PACKAGE_TAON_VERSION = 'v21';
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-exports.CURRENT_PACKAGE_VERSION = '21.0.15';
+exports.CURRENT_PACKAGE_VERSION = '21.0.17';
 // THIS FILE IS GENERATED - DO NOT MODIFY
 //# sourceMappingURL=build-info._auto-generated_.js.map

package/lib/models.d.ts

@@ -4,7 +4,6 @@ import { Circ } from 'json10';
 import { Observable } from 'rxjs';
 import { Subject } from 'rxjs';
 import { CoreModels } from 'tnp-core';
-import { Models as HelpersModels } from 'typescript-class-helpers';
 import { Cookie } from './cookie';
 import { Mapping } from './mapping';
 import { RestHeaders } from './rest-headers';
@@ -31,20 +30,15 @@ export declare class RestErrorResponseWrapper extends RestCommonHttpResponseWrap
     code?: string;
 }
 export declare namespace Models {
-    export import HttpMethod = CoreModels.HttpMethod;
-    export import ParamType = CoreModels.ParamType;
-    export import MethodConfig = HelpersModels.MethodConfig;
-    export import ClassConfig = HelpersModels.ClassConfig;
-    export import ParamConfig = HelpersModels.ParamConfig;
     interface HandleResultOptions {
         res: Models.MockResponse;
-        method: Models.HttpMethod;
+        method: CoreModels.HttpMethod;
         jobid?: number;
         isArray?: boolean;
     }
     interface HandleResultSourceRequestOptions {
         url: string;
-        method: Models.HttpMethod;
+        method: CoreModels.HttpMethod;
         body: any;
         isArray: boolean;
     }

package/lib/models.js

@@ -5,7 +5,6 @@ const lib_1 = require("json10/lib");
 const lib_2 = require("tnp-core/lib");
 const lib_3 = require("tnp-core/lib");
 const lib_4 = require("tnp-core/lib");
-const lib_5 = require("typescript-class-helpers/lib");
 const cookie_1 = require("./cookie");
 const mapping_1 = require("./mapping");
 class RestCommonHttpResponseWrapper {
@@ -19,9 +18,8 @@ exports.RestErrorResponseWrapper = RestErrorResponseWrapper;
 // const log = Log.create('rest namespace', Level.__NOTHING)
 var Models;
 (function (Models) {
-    Models.MethodConfig = lib_5.Models.MethodConfig;
-    Models.ClassConfig = lib_5.Models.ClassConfig;
-    Models.ParamConfig = lib_5.Models.ParamConfig;
+    // export import HttpMethod = CoreModels.HttpMethod;
+    // export import ParamType = CoreModels.ParamType;
     [];
     class BaseBody {
         toJSON(data, opt) {