fabrikantencore 1.0.0

package/esm2020/src/app/modules/fabrikantencore/swagger/SwaggerClient.mjs

@@ -0,0 +1,341 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v13.16.1.0 (NJsonSchema v10.7.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+/* tslint:disable */
+/* eslint-disable */
+// ReSharper disable InconsistentNaming
+import { mergeMap as _observableMergeMap, catchError as _observableCatch } from 'rxjs/operators';
+import { Observable, throwError as _observableThrow, of as _observableOf } from 'rxjs';
+import { Injectable, Inject, Optional, InjectionToken } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpResponse, HttpResponseBase } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export const API_BASE_URL = new InjectionToken('API_BASE_URL');
+export class FiltersApiClient {
+    constructor(http, baseUrl) {
+        this.jsonParseReviver = undefined;
+        this.http = http;
+        this.baseUrl = baseUrl !== undefined && baseUrl !== null ? baseUrl : "";
+    }
+    getFilterViewModel() {
+        let url_ = this.baseUrl + "/api/filters/viewmodel";
+        url_ = url_.replace(/[?&]$/, "");
+        let options_ = {
+            observe: "response",
+            responseType: "blob",
+            headers: new HttpHeaders({
+                "Accept": "application/json"
+            })
+        };
+        return this.http.request("get", url_, options_).pipe(_observableMergeMap((response_) => {
+            return this.processGetFilterViewModel(response_);
+        })).pipe(_observableCatch((response_) => {
+            if (response_ instanceof HttpResponseBase) {
+                try {
+                    return this.processGetFilterViewModel(response_);
+                }
+                catch (e) {
+                    return _observableThrow(e);
+                }
+            }
+            else
+                return _observableThrow(response_);
+        }));
+    }
+    processGetFilterViewModel(response) {
+        const status = response.status;
+        const responseBlob = response instanceof HttpResponse ? response.body :
+            response.error instanceof Blob ? response.error : undefined;
+        let _headers = {};
+        if (response.headers) {
+            for (let key of response.headers.keys()) {
+                _headers[key] = response.headers.get(key);
+            }
+        }
+        if (status === 200) {
+            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText) => {
+                let result200 = null;
+                let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = FilterViewModel.fromJS(resultData200);
+                return _observableOf(result200);
+            }));
+        }
+        else if (status !== 200 && status !== 204) {
+            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText) => {
+                return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            }));
+        }
+        return _observableOf(null);
+    }
+    getFilterViewModel2() {
+        let url_ = this.baseUrl + "/api/filters/viewmodel2";
+        url_ = url_.replace(/[?&]$/, "");
+        let options_ = {
+            observe: "response",
+            responseType: "blob",
+            headers: new HttpHeaders({
+                "Accept": "application/json"
+            })
+        };
+        return this.http.request("get", url_, options_).pipe(_observableMergeMap((response_) => {
+            return this.processGetFilterViewModel2(response_);
+        })).pipe(_observableCatch((response_) => {
+            if (response_ instanceof HttpResponseBase) {
+                try {
+                    return this.processGetFilterViewModel2(response_);
+                }
+                catch (e) {
+                    return _observableThrow(e);
+                }
+            }
+            else
+                return _observableThrow(response_);
+        }));
+    }
+    processGetFilterViewModel2(response) {
+        const status = response.status;
+        const responseBlob = response instanceof HttpResponse ? response.body :
+            response.error instanceof Blob ? response.error : undefined;
+        let _headers = {};
+        if (response.headers) {
+            for (let key of response.headers.keys()) {
+                _headers[key] = response.headers.get(key);
+            }
+        }
+        if (status === 200) {
+            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText) => {
+                let result200 = null;
+                let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = FilterViewModel.fromJS(resultData200);
+                return _observableOf(result200);
+            }));
+        }
+        else if (status !== 200 && status !== 204) {
+            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText) => {
+                return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            }));
+        }
+        return _observableOf(null);
+    }
+}
+FiltersApiClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.4", ngImport: i0, type: FiltersApiClient, deps: [{ token: HttpClient }, { token: API_BASE_URL, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FiltersApiClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.4", ngImport: i0, type: FiltersApiClient });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.4", ngImport: i0, type: FiltersApiClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient, decorators: [{
+                    type: Inject,
+                    args: [HttpClient]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [API_BASE_URL]
+                }] }]; } });
+export class SecurityApiClient {
+    constructor(http, baseUrl) {
+        this.jsonParseReviver = undefined;
+        this.http = http;
+        this.baseUrl = baseUrl !== undefined && baseUrl !== null ? baseUrl : "";
+    }
+    authenticateUser(pLoginRequestModel) {
+        let url_ = this.baseUrl + "/api/security/authenticateuser";
+        url_ = url_.replace(/[?&]$/, "");
+        const content_ = JSON.stringify(pLoginRequestModel);
+        let options_ = {
+            body: content_,
+            observe: "response",
+            responseType: "blob",
+            headers: new HttpHeaders({
+                "Content-Type": "application/json",
+                "Accept": "application/json"
+            })
+        };
+        return this.http.request("post", url_, options_).pipe(_observableMergeMap((response_) => {
+            return this.processAuthenticateUser(response_);
+        })).pipe(_observableCatch((response_) => {
+            if (response_ instanceof HttpResponseBase) {
+                try {
+                    return this.processAuthenticateUser(response_);
+                }
+                catch (e) {
+                    return _observableThrow(e);
+                }
+            }
+            else
+                return _observableThrow(response_);
+        }));
+    }
+    processAuthenticateUser(response) {
+        const status = response.status;
+        const responseBlob = response instanceof HttpResponse ? response.body :
+            response.error instanceof Blob ? response.error : undefined;
+        let _headers = {};
+        if (response.headers) {
+            for (let key of response.headers.keys()) {
+                _headers[key] = response.headers.get(key);
+            }
+        }
+        if (status === 200) {
+            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText) => {
+                let result200 = null;
+                let resultData200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver);
+                result200 = LoginResponseModel.fromJS(resultData200);
+                return _observableOf(result200);
+            }));
+        }
+        else if (status !== 200 && status !== 204) {
+            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText) => {
+                return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            }));
+        }
+        return _observableOf(null);
+    }
+}
+SecurityApiClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.4", ngImport: i0, type: SecurityApiClient, deps: [{ token: HttpClient }, { token: API_BASE_URL, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+SecurityApiClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.4", ngImport: i0, type: SecurityApiClient });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.4", ngImport: i0, type: SecurityApiClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient, decorators: [{
+                    type: Inject,
+                    args: [HttpClient]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [API_BASE_URL]
+                }] }]; } });
+export class FilterViewModel {
+    constructor(data) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    this[property] = data[property];
+            }
+        }
+    }
+    init(_data) {
+        if (_data) {
+            this.id = _data["id"];
+            this.name = _data["name"];
+        }
+    }
+    static fromJS(data) {
+        data = typeof data === 'object' ? data : {};
+        let result = new FilterViewModel();
+        result.init(data);
+        return result;
+    }
+    toJSON(data) {
+        data = typeof data === 'object' ? data : {};
+        data["id"] = this.id;
+        data["name"] = this.name;
+        return data;
+    }
+}
+export class LoginResponseModel {
+    constructor(data) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    this[property] = data[property];
+            }
+        }
+    }
+    init(_data) {
+        if (_data) {
+            this.name = _data["name"];
+            if (Array.isArray(_data["roles"])) {
+                this.roles = [];
+                for (let item of _data["roles"])
+                    this.roles.push(item);
+            }
+            this.loginSuccess = _data["loginSuccess"];
+            this.authData = _data["authData"];
+        }
+    }
+    static fromJS(data) {
+        data = typeof data === 'object' ? data : {};
+        let result = new LoginResponseModel();
+        result.init(data);
+        return result;
+    }
+    toJSON(data) {
+        data = typeof data === 'object' ? data : {};
+        data["name"] = this.name;
+        if (Array.isArray(this.roles)) {
+            data["roles"] = [];
+            for (let item of this.roles)
+                data["roles"].push(item);
+        }
+        data["loginSuccess"] = this.loginSuccess;
+        data["authData"] = this.authData;
+        return data;
+    }
+}
+export class LoginRequestModel {
+    constructor(data) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    this[property] = data[property];
+            }
+        }
+    }
+    init(_data) {
+        if (_data) {
+            this.name = _data["name"];
+            this.password = _data["password"];
+        }
+    }
+    static fromJS(data) {
+        data = typeof data === 'object' ? data : {};
+        let result = new LoginRequestModel();
+        result.init(data);
+        return result;
+    }
+    toJSON(data) {
+        data = typeof data === 'object' ? data : {};
+        data["name"] = this.name;
+        data["password"] = this.password;
+        return data;
+    }
+}
+export class ApiException extends Error {
+    constructor(message, status, response, headers, result) {
+        super();
+        this.isApiException = true;
+        this.message = message;
+        this.status = status;
+        this.response = response;
+        this.headers = headers;
+        this.result = result;
+    }
+    static isApiException(obj) {
+        return obj.isApiException === true;
+    }
+}
+function throwException(message, status, response, headers, result) {
+    if (result !== null && result !== undefined)
+        return _observableThrow(result);
+    else
+        return _observableThrow(new ApiException(message, status, response, headers, null));
+}
+function blobToText(blob) {
+    return new Observable((observer) => {
+        if (!blob) {
+            observer.next("");
+            observer.complete();
+        }
+        else {
+            let reader = new FileReader();
+            reader.onload = event => {
+                observer.next(event.target.result);
+                observer.complete();
+            };
+            reader.readAsText(blob);
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SwaggerClient.js","sourceRoot":"","sources":["../../../../../../../src/app/modules/fabrikantencore/swagger/SwaggerClient.ts"],"names":[],"mappings":"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","sourcesContent":["//----------------------\r\n// <auto-generated>\r\n//     Generated using the NSwag toolchain v13.16.1.0 (NJsonSchema v10.7.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)\r\n// </auto-generated>\r\n//----------------------\r\n\r\n/* tslint:disable */\r\n/* eslint-disable */\r\n// ReSharper disable InconsistentNaming\r\n\r\nimport { mergeMap as _observableMergeMap, catchError as _observableCatch } from 'rxjs/operators';\r\nimport { Observable, throwError as _observableThrow, of as _observableOf } from 'rxjs';\r\nimport { Injectable, Inject, Optional, InjectionToken } from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpResponse, HttpResponseBase } from '@angular/common/http';\r\n\r\nexport const API_BASE_URL = new InjectionToken<string>('API_BASE_URL');\r\n\r\n@Injectable()\r\nexport class FiltersApiClient {\r\n    private http: HttpClient;\r\n    private baseUrl: string;\r\n    protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;\r\n\r\n    constructor(@Inject(HttpClient) http: HttpClient, @Optional() @Inject(API_BASE_URL) baseUrl?: string) {\r\n        this.http = http;\r\n        this.baseUrl = baseUrl !== undefined && baseUrl !== null ? baseUrl : \"\";\r\n    }\r\n\r\n    getFilterViewModel(): Observable<FilterViewModel> {\r\n        let url_ = this.baseUrl + \"/api/filters/viewmodel\";\r\n        url_ = url_.replace(/[?&]$/, \"\");\r\n\r\n        let options_ : any = {\r\n            observe: \"response\",\r\n            responseType: \"blob\",\r\n            headers: new HttpHeaders({\r\n                \"Accept\": \"application/json\"\r\n            })\r\n        };\r\n\r\n        return this.http.request(\"get\", url_, options_).pipe(_observableMergeMap((response_ : any) => {\r\n            return this.processGetFilterViewModel(response_);\r\n        })).pipe(_observableCatch((response_: any) => {\r\n            if (response_ instanceof HttpResponseBase) {\r\n                try {\r\n                    return this.processGetFilterViewModel(response_ as any);\r\n                } catch (e) {\r\n                    return _observableThrow(e) as any as Observable<FilterViewModel>;\r\n                }\r\n            } else\r\n                return _observableThrow(response_) as any as Observable<FilterViewModel>;\r\n        }));\r\n    }\r\n\r\n    protected processGetFilterViewModel(response: HttpResponseBase): Observable<FilterViewModel> {\r\n        const status = response.status;\r\n        const responseBlob =\r\n            response instanceof HttpResponse ? response.body :\r\n            (response as any).error instanceof Blob ? (response as any).error : undefined;\r\n\r\n        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }}\r\n        if (status === 200) {\r\n            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText: string) => {\r\n            let result200: any = null;\r\n            let resultData200 = _responseText === \"\" ? null : JSON.parse(_responseText, this.jsonParseReviver);\r\n            result200 = FilterViewModel.fromJS(resultData200);\r\n            return _observableOf(result200);\r\n            }));\r\n        } else if (status !== 200 && status !== 204) {\r\n            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText: string) => {\r\n            return throwException(\"An unexpected server error occurred.\", status, _responseText, _headers);\r\n            }));\r\n        }\r\n        return _observableOf(null as any);\r\n    }\r\n\r\n    getFilterViewModel2(): Observable<FilterViewModel> {\r\n        let url_ = this.baseUrl + \"/api/filters/viewmodel2\";\r\n        url_ = url_.replace(/[?&]$/, \"\");\r\n\r\n        let options_ : any = {\r\n            observe: \"response\",\r\n            responseType: \"blob\",\r\n            headers: new HttpHeaders({\r\n                \"Accept\": \"application/json\"\r\n            })\r\n        };\r\n\r\n        return this.http.request(\"get\", url_, options_).pipe(_observableMergeMap((response_ : any) => {\r\n            return this.processGetFilterViewModel2(response_);\r\n        })).pipe(_observableCatch((response_: any) => {\r\n            if (response_ instanceof HttpResponseBase) {\r\n                try {\r\n                    return this.processGetFilterViewModel2(response_ as any);\r\n                } catch (e) {\r\n                    return _observableThrow(e) as any as Observable<FilterViewModel>;\r\n                }\r\n            } else\r\n                return _observableThrow(response_) as any as Observable<FilterViewModel>;\r\n        }));\r\n    }\r\n\r\n    protected processGetFilterViewModel2(response: HttpResponseBase): Observable<FilterViewModel> {\r\n        const status = response.status;\r\n        const responseBlob =\r\n            response instanceof HttpResponse ? response.body :\r\n            (response as any).error instanceof Blob ? (response as any).error : undefined;\r\n\r\n        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }}\r\n        if (status === 200) {\r\n            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText: string) => {\r\n            let result200: any = null;\r\n            let resultData200 = _responseText === \"\" ? null : JSON.parse(_responseText, this.jsonParseReviver);\r\n            result200 = FilterViewModel.fromJS(resultData200);\r\n            return _observableOf(result200);\r\n            }));\r\n        } else if (status !== 200 && status !== 204) {\r\n            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText: string) => {\r\n            return throwException(\"An unexpected server error occurred.\", status, _responseText, _headers);\r\n            }));\r\n        }\r\n        return _observableOf(null as any);\r\n    }\r\n}\r\n\r\n@Injectable()\r\nexport class SecurityApiClient {\r\n    private http: HttpClient;\r\n    private baseUrl: string;\r\n    protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;\r\n\r\n    constructor(@Inject(HttpClient) http: HttpClient, @Optional() @Inject(API_BASE_URL) baseUrl?: string) {\r\n        this.http = http;\r\n        this.baseUrl = baseUrl !== undefined && baseUrl !== null ? baseUrl : \"\";\r\n    }\r\n\r\n    authenticateUser(pLoginRequestModel: LoginRequestModel): Observable<LoginResponseModel> {\r\n        let url_ = this.baseUrl + \"/api/security/authenticateuser\";\r\n        url_ = url_.replace(/[?&]$/, \"\");\r\n\r\n        const content_ = JSON.stringify(pLoginRequestModel);\r\n\r\n        let options_ : any = {\r\n            body: content_,\r\n            observe: \"response\",\r\n            responseType: \"blob\",\r\n            headers: new HttpHeaders({\r\n                \"Content-Type\": \"application/json\",\r\n                \"Accept\": \"application/json\"\r\n            })\r\n        };\r\n\r\n        return this.http.request(\"post\", url_, options_).pipe(_observableMergeMap((response_ : any) => {\r\n            return this.processAuthenticateUser(response_);\r\n        })).pipe(_observableCatch((response_: any) => {\r\n            if (response_ instanceof HttpResponseBase) {\r\n                try {\r\n                    return this.processAuthenticateUser(response_ as any);\r\n                } catch (e) {\r\n                    return _observableThrow(e) as any as Observable<LoginResponseModel>;\r\n                }\r\n            } else\r\n                return _observableThrow(response_) as any as Observable<LoginResponseModel>;\r\n        }));\r\n    }\r\n\r\n    protected processAuthenticateUser(response: HttpResponseBase): Observable<LoginResponseModel> {\r\n        const status = response.status;\r\n        const responseBlob =\r\n            response instanceof HttpResponse ? response.body :\r\n            (response as any).error instanceof Blob ? (response as any).error : undefined;\r\n\r\n        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }}\r\n        if (status === 200) {\r\n            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText: string) => {\r\n            let result200: any = null;\r\n            let resultData200 = _responseText === \"\" ? null : JSON.parse(_responseText, this.jsonParseReviver);\r\n            result200 = LoginResponseModel.fromJS(resultData200);\r\n            return _observableOf(result200);\r\n            }));\r\n        } else if (status !== 200 && status !== 204) {\r\n            return blobToText(responseBlob).pipe(_observableMergeMap((_responseText: string) => {\r\n            return throwException(\"An unexpected server error occurred.\", status, _responseText, _headers);\r\n            }));\r\n        }\r\n        return _observableOf(null as any);\r\n    }\r\n}\r\n\r\nexport class FilterViewModel implements IFilterViewModel {\r\n    id!: number;\r\n    name?: string | undefined;\r\n\r\n    constructor(data?: IFilterViewModel) {\r\n        if (data) {\r\n            for (var property in data) {\r\n                if (data.hasOwnProperty(property))\r\n                    (<any>this)[property] = (<any>data)[property];\r\n            }\r\n        }\r\n    }\r\n\r\n    init(_data?: any) {\r\n        if (_data) {\r\n            this.id = _data[\"id\"];\r\n            this.name = _data[\"name\"];\r\n        }\r\n    }\r\n\r\n    static fromJS(data: any): FilterViewModel {\r\n        data = typeof data === 'object' ? data : {};\r\n        let result = new FilterViewModel();\r\n        result.init(data);\r\n        return result;\r\n    }\r\n\r\n    toJSON(data?: any) {\r\n        data = typeof data === 'object' ? data : {};\r\n        data[\"id\"] = this.id;\r\n        data[\"name\"] = this.name;\r\n        return data;\r\n    }\r\n}\r\n\r\nexport interface IFilterViewModel {\r\n    id: number;\r\n    name?: string | undefined;\r\n}\r\n\r\nexport class LoginResponseModel implements ILoginResponseModel {\r\n    name?: string | undefined;\r\n    roles?: string[] | undefined;\r\n    loginSuccess!: boolean;\r\n    authData?: string | undefined;\r\n\r\n    constructor(data?: ILoginResponseModel) {\r\n        if (data) {\r\n            for (var property in data) {\r\n                if (data.hasOwnProperty(property))\r\n                    (<any>this)[property] = (<any>data)[property];\r\n            }\r\n        }\r\n    }\r\n\r\n    init(_data?: any) {\r\n        if (_data) {\r\n            this.name = _data[\"name\"];\r\n            if (Array.isArray(_data[\"roles\"])) {\r\n                this.roles = [] as any;\r\n                for (let item of _data[\"roles\"])\r\n                    this.roles!.push(item);\r\n            }\r\n            this.loginSuccess = _data[\"loginSuccess\"];\r\n            this.authData = _data[\"authData\"];\r\n        }\r\n    }\r\n\r\n    static fromJS(data: any): LoginResponseModel {\r\n        data = typeof data === 'object' ? data : {};\r\n        let result = new LoginResponseModel();\r\n        result.init(data);\r\n        return result;\r\n    }\r\n\r\n    toJSON(data?: any) {\r\n        data = typeof data === 'object' ? data : {};\r\n        data[\"name\"] = this.name;\r\n        if (Array.isArray(this.roles)) {\r\n            data[\"roles\"] = [];\r\n            for (let item of this.roles)\r\n                data[\"roles\"].push(item);\r\n        }\r\n        data[\"loginSuccess\"] = this.loginSuccess;\r\n        data[\"authData\"] = this.authData;\r\n        return data;\r\n    }\r\n}\r\n\r\nexport interface ILoginResponseModel {\r\n    name?: string | undefined;\r\n    roles?: string[] | undefined;\r\n    loginSuccess: boolean;\r\n    authData?: string | undefined;\r\n}\r\n\r\nexport class LoginRequestModel implements ILoginRequestModel {\r\n    name?: string | undefined;\r\n    password?: string | undefined;\r\n\r\n    constructor(data?: ILoginRequestModel) {\r\n        if (data) {\r\n            for (var property in data) {\r\n                if (data.hasOwnProperty(property))\r\n                    (<any>this)[property] = (<any>data)[property];\r\n            }\r\n        }\r\n    }\r\n\r\n    init(_data?: any) {\r\n        if (_data) {\r\n            this.name = _data[\"name\"];\r\n            this.password = _data[\"password\"];\r\n        }\r\n    }\r\n\r\n    static fromJS(data: any): LoginRequestModel {\r\n        data = typeof data === 'object' ? data : {};\r\n        let result = new LoginRequestModel();\r\n        result.init(data);\r\n        return result;\r\n    }\r\n\r\n    toJSON(data?: any) {\r\n        data = typeof data === 'object' ? data : {};\r\n        data[\"name\"] = this.name;\r\n        data[\"password\"] = this.password;\r\n        return data;\r\n    }\r\n}\r\n\r\nexport interface ILoginRequestModel {\r\n    name?: string | undefined;\r\n    password?: string | undefined;\r\n}\r\n\r\nexport class ApiException extends Error {\r\n    override message: string;\r\n    status: number;\r\n    response: string;\r\n    headers: { [key: string]: any; };\r\n    result: any;\r\n\r\n    constructor(message: string, status: number, response: string, headers: { [key: string]: any; }, result: any) {\r\n        super();\r\n\r\n        this.message = message;\r\n        this.status = status;\r\n        this.response = response;\r\n        this.headers = headers;\r\n        this.result = result;\r\n    }\r\n\r\n    protected isApiException = true;\r\n\r\n    static isApiException(obj: any): obj is ApiException {\r\n        return obj.isApiException === true;\r\n    }\r\n}\r\n\r\nfunction throwException(message: string, status: number, response: string, headers: { [key: string]: any; }, result?: any): Observable<any> {\r\n    if (result !== null && result !== undefined)\r\n        return _observableThrow(result);\r\n    else\r\n        return _observableThrow(new ApiException(message, status, response, headers, null));\r\n}\r\n\r\nfunction blobToText(blob: any): Observable<string> {\r\n    return new Observable<string>((observer: any) => {\r\n        if (!blob) {\r\n            observer.next(\"\");\r\n            observer.complete();\r\n        } else {\r\n            let reader = new FileReader();\r\n            reader.onload = event => {\r\n                observer.next((event.target as any).result);\r\n                observer.complete();\r\n            };\r\n            reader.readAsText(blob);\r\n        }\r\n    });\r\n}"]}