ng2-rest 21.0.15 → 21.0.17

package/lib-prod/models.d.ts

@@ -3,10 +3,9 @@ import { AxiosRequestConfig } from 'axios';
 import { Circ } from 'json10/lib-prod';
 import { Observable } from 'rxjs';
 import { Subject } from 'rxjs';
-import { CoreModels } from 'tnp-core/lib-prod';
-import { Models as HelpersModels } from 'typescript-class-helpers/lib-prod';
+import { CoreModels_HttpMethod } from 'tnp-core/lib-prod';
 import { Cookie } from './cookie';
-import { Mapping } from './mapping';
+import { Mapping_Mapping } from './mapping';
 import { RestHeaders } from './rest-headers';
 import { Rest } from './rest.class';
 declare class RestCommonHttpResponseWrapper {
@@ -30,157 +29,150 @@ 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;
-        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 = {
+export interface Models_HandleResultOptions {
+    res: Models_MockResponse;
+    method: CoreModels_HttpMethod;
+    jobid?: number;
+    isArray?: boolean;
+}
+export interface Models_HandleResultSourceRequestOptions {
+    url: string;
+    method: CoreModels_HttpMethod;
+    body: any;
+    isArray: boolean;
+}
+export type Models_BackendError = {
+    msg?: string;
+    stack?: string[];
+    data: any;
+};
+export type Models_MetaRequest = {
+    path: string;
+    endpoint: string;
+    entity: Mapping_Mapping;
+    circular: Circ[];
+};
+export type Models_HttpCode = 200 | 400 | 401 | 404 | 500;
+export type Models_PromiseObservableMix<T> = Promise<T> & {
+    observable: Observable<T>;
+};
+export type Models_Ng2RestAxiosRequestConfig = {
+    doNotSerializeParams?: boolean;
+} & AxiosRequestConfig<any>;
+export type Models_MethodWithBody<E, T, R = Models_PromiseObservableMix<E>> = (item?: T, params?: Models_UrlParams[], axiosOptions?: Models_Ng2RestAxiosRequestConfig) => R;
+export 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' | 'arraybuffer' | 'document' | 'stream';
+    };
+    /**
+     * jobid
+     */
+    id: number;
+};
+export type Models_ReqParams = {
+    url: string;
+    method: CoreModels_HttpMethod;
+    headers?: RestHeaders;
+    body?: any;
+    jobid: number;
+    isArray: boolean;
+};
+export interface Models_ResourceModel<A, TA> {
+    model: (pathModels?: Object, responseObjectType?: Function) => Rest<A, TA>;
+    headers: RestHeaders;
+}
+export 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>;
+}
+export type Models_MockController = (url: string, method: CoreModels_HttpMethod, headers?: RestHeaders, body?: any) => Models_MockResponse;
+export type Models_MockHttp = Models_MockResponse | Models_MockController;
+export interface Models_FnMethodsHttp<T, TA> extends Models_Ng2RestMethods<Models_HttpResponse<T>, T> {
+    array: Models_Ng2RestMethods<Models_HttpResponse<TA>, TA>;
+}
+export interface Models_FnMethodsHttpWithMock<T, TA> extends Models_Ng2RestMethods<Models_HttpResponse<T>, T> {
+    array: Models_Ng2RestMethods<Models_HttpResponse<TA>, TA>;
+}
+export interface Models_NestedParams {
+    [params: string]: string;
+}
+export interface Models_UrlParams {
+    [urlModelName: string]: string | number | boolean | RegExp | Object;
+    regex?: RegExp;
+}
+export declare abstract class Models_BaseBody {
+    protected toJSON(data: any, opt: {
+        isJSONArray?: boolean;
+        parsingError?: boolean;
+    }): object | undefined;
+}
+export 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;
+}
+export declare class Models_ErrorBody<T = RestErrorResponseWrapper> extends Models_BaseBody {
+    private data;
+    constructor(data: any);
+    get json(): T;
+    get text(): string;
+}
+export 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);
+}
+export 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;
+}
+export interface Models_MockResponse {
+    data?: any;
+    code?: Models_HttpCode;
+    error?: string;
+    headers?: RestHeaders;
+    jobid?: number;
+    isArray: boolean;
 }
-export declare class HttpResponseError<ERROR_BODY = object> extends Models.BaseResponse<any> {
+export type Models_ResponseTypeAxios = 'blob' | 'text' | 'arraybuffer' | 'document' | 'stream';
+export 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);
 }
 export {};

package/lib-prod/models.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpResponseError = exports.Models = exports.RestErrorResponseWrapper = exports.RestResponseWrapper = void 0;
+exports.HttpResponseError = exports.Models_HttpResponse = exports.Models_BaseResponse = exports.Models_ErrorBody = exports.Models_HttpBody = exports.Models_BaseBody = exports.RestErrorResponseWrapper = exports.RestResponseWrapper = void 0;
 const lib_prod_1 = require("json10/lib-prod");
 const lib_prod_2 = require("tnp-core/lib-prod");
 const lib_prod_3 = require("tnp-core/lib-prod");
 const lib_prod_4 = require("tnp-core/lib-prod");
-const lib_prod_5 = require("typescript-class-helpers/lib-prod");
 const cookie_1 = require("./cookie");
 const mapping_1 = require("./mapping");
 class RestCommonHttpResponseWrapper {
@@ -16,186 +15,180 @@ exports.RestResponseWrapper = RestResponseWrapper;
 class RestErrorResponseWrapper extends RestCommonHttpResponseWrapper {
 }
 exports.RestErrorResponseWrapper = RestErrorResponseWrapper;
-// const log = Log.create('rest namespace', Level.__NOTHING)
-var Models;
-(function (Models) {
-    Models.MethodConfig = lib_prod_5.Models.MethodConfig;
-    Models.ClassConfig = lib_prod_5.Models.ClassConfig;
-    Models.ParamConfig = lib_prod_5.Models.ParamConfig;
-    [];
-    class BaseBody {
-        toJSON(data, opt) {
-            opt = opt || { isJSONArray: false };
-            let r = opt.isJSONArray ? [] : {};
-            if (typeof data === 'string') {
-                try {
-                    let parsed = JSON.parse(data);
-                    if (typeof parsed === 'string' && parsed.trim().startsWith('{')) {
-                        parsed = JSON.parse(parsed);
-                    }
-                    if (opt.parsingError && parsed[lib_prod_3.CoreModels.TaonHttpErrorCustomProp]) {
-                        return lib_prod_2._.merge(new RestErrorResponseWrapper(), parsed);
-                    }
-                    return parsed;
+[];
+class Models_BaseBody {
+    toJSON(data, opt) {
+        opt = opt || { isJSONArray: false };
+        let r = opt.isJSONArray ? [] : {};
+        if (typeof data === 'string') {
+            try {
+                let parsed = JSON.parse(data);
+                if (typeof parsed === 'string' && parsed.trim().startsWith('{')) {
+                    parsed = JSON.parse(parsed);
                 }
-                catch (e) { }
-            }
-            else if (typeof data === 'object') {
-                return data;
+                if (opt.parsingError && parsed[lib_prod_3.CoreModels_TaonHttpErrorCustomProp]) {
+                    return lib_prod_2._.merge(new RestErrorResponseWrapper(), parsed);
+                }
+                return parsed;
             }
-            return r;
-        }
-    }
-    Models.BaseBody = BaseBody;
-    class HttpBody extends BaseBody {
-        responseText;
-        isArray;
-        entity;
-        circular;
-        constructor(responseText, isArray = false, entity, circular) {
-            super();
-            this.responseText = responseText;
-            this.isArray = isArray;
-            this.entity = entity;
-            this.circular = circular;
-        }
-        get blob() {
-            return this.responseText;
+            catch (e) { }
         }
-        get booleanValue() {
-            if (!lib_prod_4.Helpers.isBlob(this.responseText)) {
-                return ['ok', 'true'].includes(this.responseText?.trim());
-            }
+        else if (typeof data === 'object') {
+            return data;
         }
-        get numericValue() {
-            if (!lib_prod_4.Helpers.isBlob(this.responseText)) {
-                return Number(this.responseText?.trim());
-            }
+        return r;
+    }
+}
+exports.Models_BaseBody = Models_BaseBody;
+class Models_HttpBody extends Models_BaseBody {
+    responseText;
+    isArray;
+    entity;
+    circular;
+    constructor(responseText, isArray = false, entity, circular) {
+        super();
+        this.responseText = responseText;
+        this.isArray = isArray;
+        this.entity = entity;
+        this.circular = circular;
+    }
+    get blob() {
+        return this.responseText;
+    }
+    get booleanValue() {
+        if (!lib_prod_4.Helpers.isBlob(this.responseText)) {
+            return ['ok', 'true'].includes(this.responseText?.trim());
         }
-        get rawJson() {
-            if (!lib_prod_4.Helpers.isBlob(this.responseText)) {
-                let res = this.toJSON(this.responseText, { isJSONArray: this.isArray });
-                if (this.circular && Array.isArray(this.circular)) {
-                    res = lib_prod_1.JSON10.parse(JSON.stringify(res), this.circular);
-                }
-                return res;
-            }
+    }
+    get numericValue() {
+        if (!lib_prod_4.Helpers.isBlob(this.responseText)) {
+            return Number(this.responseText?.trim());
         }
-        get json() {
-            const isBlob = lib_prod_4.Helpers.isBlob(this.responseText);
-            if (isBlob) {
-                return void 0;
-            }
-            if (this.entity && typeof this.entity === 'function') {
-                return this.entity(); // @LAST
-            }
-            if (this.entity && typeof this.entity === 'object') {
-                const json = this.toJSON(this.responseText, {
-                    isJSONArray: this.isArray,
-                });
-                return mapping_1.Mapping.encode(json, this.entity, this.circular);
-            }
+    }
+    get rawJson() {
+        if (!lib_prod_4.Helpers.isBlob(this.responseText)) {
             let res = this.toJSON(this.responseText, { isJSONArray: this.isArray });
             if (this.circular && Array.isArray(this.circular)) {
                 res = lib_prod_1.JSON10.parse(JSON.stringify(res), this.circular);
             }
             return res;
         }
-        /**
-         * undefined when blob
-         */
-        get text() {
-            if (!lib_prod_4.Helpers.isBlob(this.responseText)) {
-                return this.responseText
-                    .replace(/^\"/, '')
-                    .replace(/\"$/, '');
-            }
-        }
     }
-    Models.HttpBody = HttpBody;
-    class ErrorBody extends BaseBody {
-        data;
-        constructor(data) {
-            super();
-            this.data = data;
-        }
-        get json() {
-            return this.toJSON(this.data, { parsingError: true });
+    get json() {
+        const isBlob = lib_prod_4.Helpers.isBlob(this.responseText);
+        if (isBlob) {
+            return void 0;
         }
-        get text() {
-            return this.data;
+        if (this.entity && typeof this.entity === 'function') {
+            return this.entity(); // @LAST
         }
-    }
-    Models.ErrorBody = ErrorBody;
-    class BaseResponse {
-        responseText;
-        headers;
-        statusCode;
-        isArray;
-        static cookies = cookie_1.Cookie.Instance;
-        get cookies() {
-            return BaseResponse.cookies;
+        if (this.entity && typeof this.entity === 'object') {
+            const json = this.toJSON(this.responseText, {
+                isJSONArray: this.isArray,
+            });
+            return (0, mapping_1.Mapping_encode)(json, this.entity, this.circular);
         }
-        constructor(responseText, headers, statusCode, isArray = false) {
-            this.responseText = responseText;
-            this.headers = headers;
-            this.statusCode = statusCode;
-            this.isArray = isArray;
+        let res = this.toJSON(this.responseText, { isJSONArray: this.isArray });
+        if (this.circular && Array.isArray(this.circular)) {
+            res = lib_prod_1.JSON10.parse(JSON.stringify(res), this.circular);
         }
+        return res;
     }
-    Models.BaseResponse = BaseResponse;
-    class HttpResponse extends BaseResponse {
-        sourceRequest;
-        responseText;
-        headers;
-        statusCode;
-        entity;
-        circular;
-        jobid;
-        isArray;
-        body;
-        // public readonly TOTAL_COUNT_HEADER = 'X-Total-Count'.toLowerCase();
-        // public get totalElements(): number {
-        //     return Number(this.headers.get(this.TOTAL_COUNT_HEADER));
-        // }
-        constructor(sourceRequest, responseText, headers, statusCode, entity, circular, jobid, isArray = false) {
-            // console.log({
-            //   sourceRequest, responseText, headers, statusCode, entity, circular, jobid, isArray
-            // })
-            super(responseText, headers, statusCode, isArray);
-            this.sourceRequest = sourceRequest;
-            this.responseText = responseText;
-            this.headers = headers;
-            this.statusCode = statusCode;
-            this.entity = entity;
-            this.circular = circular;
-            this.jobid = jobid;
-            this.isArray = isArray;
-            this.init();
+    /**
+     * undefined when blob
+     */
+    get text() {
+        if (!lib_prod_4.Helpers.isBlob(this.responseText)) {
+            return this.responseText
+                .replace(/^\"/, '')
+                .replace(/\"$/, '');
         }
-        init() {
-            if (typeof this.entity === 'string') {
-                // const headerWithMapping = headers.get(entity);
-                let entityJSON = this.headers?.getAll(this.entity);
-                if (!!entityJSON) {
-                    this.entity = JSON.parse(entityJSON.join());
-                }
+    }
+}
+exports.Models_HttpBody = Models_HttpBody;
+class Models_ErrorBody extends Models_BaseBody {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    get json() {
+        return this.toJSON(this.data, { parsingError: true });
+    }
+    get text() {
+        return this.data;
+    }
+}
+exports.Models_ErrorBody = Models_ErrorBody;
+class Models_BaseResponse {
+    responseText;
+    headers;
+    statusCode;
+    isArray;
+    static cookies = cookie_1.Cookie.Instance;
+    get cookies() {
+        return Models_BaseResponse.cookies;
+    }
+    constructor(responseText, headers, statusCode, isArray = false) {
+        this.responseText = responseText;
+        this.headers = headers;
+        this.statusCode = statusCode;
+        this.isArray = isArray;
+    }
+}
+exports.Models_BaseResponse = Models_BaseResponse;
+class Models_HttpResponse extends Models_BaseResponse {
+    sourceRequest;
+    responseText;
+    headers;
+    statusCode;
+    entity;
+    circular;
+    jobid;
+    isArray;
+    body;
+    // public readonly TOTAL_COUNT_HEADER = 'X-Total-Count'.toLowerCase();
+    // public get totalElements(): number {
+    //     return Number(this.headers.get(this.TOTAL_COUNT_HEADER));
+    // }
+    constructor(sourceRequest, responseText, headers, statusCode, entity, circular, jobid, isArray = false) {
+        // console.log({
+        //   sourceRequest, responseText, headers, statusCode, entity, circular, jobid, isArray
+        // })
+        super(responseText, headers, statusCode, isArray);
+        this.sourceRequest = sourceRequest;
+        this.responseText = responseText;
+        this.headers = headers;
+        this.statusCode = statusCode;
+        this.entity = entity;
+        this.circular = circular;
+        this.jobid = jobid;
+        this.isArray = isArray;
+        this.init();
+    }
+    init() {
+        if (typeof this.entity === 'string') {
+            // const headerWithMapping = headers.get(entity);
+            let entityJSON = this.headers?.getAll(this.entity);
+            if (!!entityJSON) {
+                this.entity = JSON.parse(entityJSON.join());
             }
-            if (typeof this.circular === 'string') {
-                // const headerWithMapping = headers.get(circular);
-                let circuralJSON = this.headers?.getAll(this.circular);
-                if (!!circuralJSON) {
-                    this.circular = JSON.parse(circuralJSON.join());
-                }
+        }
+        if (typeof this.circular === 'string') {
+            // const headerWithMapping = headers.get(circular);
+            let circuralJSON = this.headers?.getAll(this.circular);
+            if (!!circuralJSON) {
+                this.circular = JSON.parse(circuralJSON.join());
             }
-            this.body = new HttpBody(this.responseText, this.isArray, this.entity, this.circular);
         }
+        this.body = new Models_HttpBody(this.responseText, this.isArray, this.entity, this.circular);
     }
-    Models.HttpResponse = HttpResponse;
-    // | 'json' - I am parsing json from text...
-    //#endregion
-})(Models || (exports.Models = Models = {}));
-class HttpResponseError extends Models.BaseResponse {
+}
+exports.Models_HttpResponse = Models_HttpResponse;
+// | 'json' - I am parsing json from text...
+//#endregion
+//end of namespace Models
+class HttpResponseError extends Models_BaseResponse {
     message;
     jobid;
     sourceRequest;
@@ -207,7 +200,7 @@ class HttpResponseError extends Models.BaseResponse {
         this.message = message;
         this.jobid = jobid;
         this.sourceRequest = sourceRequest;
-        this.body = new Models.ErrorBody(responseText);
+        this.body = new Models_ErrorBody(responseText);
     }
 }
 exports.HttpResponseError = HttpResponseError;