fH4iZePA

1/* tslint:disable */
2/* eslint-disable */
3//----------------------
4// <auto-generated>
5//     Generated using the NSwag toolchain v13.0.4.0 (NJsonSchema v10.0.21.0 (Newtonsoft.Json v11.0.0.0)) (http://NSwag.org)
6// </auto-generated>
7//----------------------
8// ReSharper disable InconsistentNaming
9
10import { mergeMap as _observableMergeMap, catchError as _observableCatch } from 'rxjs/operators';
11import { Observable, throwError as _observableThrow, of as _observableOf } from 'rxjs';
12import { Injectable, Inject, Optional, InjectionToken } from '@angular/core';
13import { HttpClient, HttpHeaders, HttpResponse, HttpResponseBase } from '@angular/common/http';
14
15import * as moment from 'moment';
16
17export const API_BASE_URL = new InjectionToken<string>('API_BASE_URL');
18
19export interface IMailingConfigurationClient {
20    /**
21     * @param includeSecret Czy pobrać zapisane hasła
22     */
23    getMailingConfiguration(includeSecret: boolean): Observable<MailingConfigurationDTO | null>;
24    editMailingConfiguration(input: MailingConfigurationParams | null): Observable<void>;
25}
26
27@Injectable()
28export class MailingConfigurationClient implements IMailingConfigurationClient {
29    private http: HttpClient;
30    private baseUrl: string;
31    protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;
32
33    constructor(@Inject(HttpClient) http: HttpClient, @Optional() @Inject(API_BASE_URL) baseUrl?: string) {
34        this.http = http;
35        this.baseUrl = baseUrl ? baseUrl : "http://localhost:8153";
36    }
37
38    /**
39     * @param includeSecret Czy pobrać zapisane hasła
40     */
41    getMailingConfiguration(includeSecret: boolean): Observable<MailingConfigurationDTO | null> {
42        let url_ = this.baseUrl + "/api/v1/os/configuration/mailing?";
43        if (includeSecret === undefined || includeSecret === null)
44            throw new Error("The parameter 'includeSecret' must be defined and cannot be null.");
45        else
46            url_ += "includeSecret=" + encodeURIComponent("" + includeSecret) + "&"; 
47        url_ = url_.replace(/[?&]$/, "");
48
49        let options_ : any = {
50            observe: "response",
51            responseType: "blob",
52            headers: new HttpHeaders({
53                "Accept": "application/json"
54            })
55        };
56
57        return this.http.request("get", url_, options_).pipe(_observableMergeMap((response_ : any) => {
58            return this.processGetMailingConfiguration(response_);
59        })).pipe(_observableCatch((response_: any) => {
60            if (response_ instanceof HttpResponseBase) {
61                try {
62                    return this.processGetMailingConfiguration(<any>response_);
63                } catch (e) {
64                    return <Observable<MailingConfigurationDTO | null>><any>_observableThrow(e);
65                }
66            } else
67                return <Observable<MailingConfigurationDTO | null>><any>_observableThrow(response_);
68        }));
69    }
70
71    protected processGetMailingConfiguration(response: HttpResponseBase): Observable<MailingConfigurationDTO | null> {
72        const status = response.status;
73        const responseBlob = 
74            response instanceof HttpResponse ? response.body : 
75            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
76
77        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
78        if (status === 200) {
79            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
80            let result200: any = null;
81            result200 = _responseText === "" ? null : <MailingConfigurationDTO>JSON.parse(_responseText, this.jsonParseReviver);
82            return _observableOf(result200);
83            }));
84        } else {
85            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
86            let resultdefault: any = null;
87            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
88            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
89            }));
90        }
91    }
92
93    editMailingConfiguration(input: MailingConfigurationParams | null): Observable<void> {
94        let url_ = this.baseUrl + "/api/v1/os/configuration/mailing";
95        url_ = url_.replace(/[?&]$/, "");
96
97        const content_ = JSON.stringify(input);
98
99        let options_ : any = {
100            body: content_,
101            observe: "response",
102            responseType: "blob",
103            headers: new HttpHeaders({
104                "Content-Type": "application/json", 
105            })
106        };
107
108        return this.http.request("put", url_, options_).pipe(_observableMergeMap((response_ : any) => {
109            return this.processEditMailingConfiguration(response_);
110        })).pipe(_observableCatch((response_: any) => {
111            if (response_ instanceof HttpResponseBase) {
112                try {
113                    return this.processEditMailingConfiguration(<any>response_);
114                } catch (e) {
115                    return <Observable<void>><any>_observableThrow(e);
116                }
117            } else
118                return <Observable<void>><any>_observableThrow(response_);
119        }));
120    }
121
122    protected processEditMailingConfiguration(response: HttpResponseBase): Observable<void> {
123        const status = response.status;
124        const responseBlob = 
125            response instanceof HttpResponse ? response.body : 
126            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
127
128        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
129        if (status === 204) {
130            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
131            return _observableOf<void>(<any>null);
132            }));
133        } else {
134            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
135            let resultdefault: any = null;
136            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
137            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
138            }));
139        }
140    }
141}
142
143export interface IUiConfigurationClient {
144    getUIConfiguration(): Observable<UiConfigurationDTO | null>;
145    editUIConfiguration(input: UiConfigurationParams | null): Observable<void>;
146}
147
148@Injectable()
149export class UiConfigurationClient implements IUiConfigurationClient {
150    private http: HttpClient;
151    private baseUrl: string;
152    protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;
153
154    constructor(@Inject(HttpClient) http: HttpClient, @Optional() @Inject(API_BASE_URL) baseUrl?: string) {
155        this.http = http;
156        this.baseUrl = baseUrl ? baseUrl : "http://localhost:8153";
157    }
158
159    getUIConfiguration(): Observable<UiConfigurationDTO | null> {
160        let url_ = this.baseUrl + "/api/v1/os/configuration/ui";
161        url_ = url_.replace(/[?&]$/, "");
162
163        let options_ : any = {
164            observe: "response",
165            responseType: "blob",
166            headers: new HttpHeaders({
167                "Accept": "application/json"
168            })
169        };
170
171        return this.http.request("get", url_, options_).pipe(_observableMergeMap((response_ : any) => {
172            return this.processGetUIConfiguration(response_);
173        })).pipe(_observableCatch((response_: any) => {
174            if (response_ instanceof HttpResponseBase) {
175                try {
176                    return this.processGetUIConfiguration(<any>response_);
177                } catch (e) {
178                    return <Observable<UiConfigurationDTO | null>><any>_observableThrow(e);
179                }
180            } else
181                return <Observable<UiConfigurationDTO | null>><any>_observableThrow(response_);
182        }));
183    }
184
185    protected processGetUIConfiguration(response: HttpResponseBase): Observable<UiConfigurationDTO | null> {
186        const status = response.status;
187        const responseBlob = 
188            response instanceof HttpResponse ? response.body : 
189            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
190
191        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
192        if (status === 200) {
193            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
194            let result200: any = null;
195            result200 = _responseText === "" ? null : <UiConfigurationDTO>JSON.parse(_responseText, this.jsonParseReviver);
196            return _observableOf(result200);
197            }));
198        } else {
199            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
200            let resultdefault: any = null;
201            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
202            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
203            }));
204        }
205    }
206
207    editUIConfiguration(input: UiConfigurationParams | null): Observable<void> {
208        let url_ = this.baseUrl + "/api/v1/os/configuration/ui";
209        url_ = url_.replace(/[?&]$/, "");
210
211        const content_ = JSON.stringify(input);
212
213        let options_ : any = {
214            body: content_,
215            observe: "response",
216            responseType: "blob",
217            headers: new HttpHeaders({
218                "Content-Type": "application/json", 
219            })
220        };
221
222        return this.http.request("put", url_, options_).pipe(_observableMergeMap((response_ : any) => {
223            return this.processEditUIConfiguration(response_);
224        })).pipe(_observableCatch((response_: any) => {
225            if (response_ instanceof HttpResponseBase) {
226                try {
227                    return this.processEditUIConfiguration(<any>response_);
228                } catch (e) {
229                    return <Observable<void>><any>_observableThrow(e);
230                }
231            } else
232                return <Observable<void>><any>_observableThrow(response_);
233        }));
234    }
235
236    protected processEditUIConfiguration(response: HttpResponseBase): Observable<void> {
237        const status = response.status;
238        const responseBlob = 
239            response instanceof HttpResponse ? response.body : 
240            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
241
242        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
243        if (status === 204) {
244            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
245            return _observableOf<void>(<any>null);
246            }));
247        } else {
248            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
249            let resultdefault: any = null;
250            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
251            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
252            }));
253        }
254    }
255}
256
257export interface IDepartmentsClient {
258    addDepartment(input: DepartmentParams | null): Observable<number>;
259    editDepartment(id: number, input: DepartmentParams | null): Observable<void>;
260    getDepartmentDetails(id: number): Observable<DepartmentDetailsDTO | null>;
261    getDepartments(input: GetDepartmentsParams | null): Observable<GetResultOfDepartmentDTO | null>;
262}
263
264@Injectable()
265export class DepartmentsClient implements IDepartmentsClient {
266    private http: HttpClient;
267    private baseUrl: string;
268    protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;
269
270    constructor(@Inject(HttpClient) http: HttpClient, @Optional() @Inject(API_BASE_URL) baseUrl?: string) {
271        this.http = http;
272        this.baseUrl = baseUrl ? baseUrl : "http://localhost:8153";
273    }
274
275    addDepartment(input: DepartmentParams | null): Observable<number> {
276        let url_ = this.baseUrl + "/api/v1/os/administration/departments";
277        url_ = url_.replace(/[?&]$/, "");
278
279        const content_ = JSON.stringify(input);
280
281        let options_ : any = {
282            body: content_,
283            observe: "response",
284            responseType: "blob",
285            headers: new HttpHeaders({
286                "Content-Type": "application/json", 
287                "Accept": "application/json"
288            })
289        };
290
291        return this.http.request("post", url_, options_).pipe(_observableMergeMap((response_ : any) => {
292            return this.processAddDepartment(response_);
293        })).pipe(_observableCatch((response_: any) => {
294            if (response_ instanceof HttpResponseBase) {
295                try {
296                    return this.processAddDepartment(<any>response_);
297                } catch (e) {
298                    return <Observable<number>><any>_observableThrow(e);
299                }
300            } else
301                return <Observable<number>><any>_observableThrow(response_);
302        }));
303    }
304
305    protected processAddDepartment(response: HttpResponseBase): Observable<number> {
306        const status = response.status;
307        const responseBlob = 
308            response instanceof HttpResponse ? response.body : 
309            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
310
311        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
312        if (status === 200) {
313            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
314            let result200: any = null;
315            result200 = _responseText === "" ? null : <number>JSON.parse(_responseText, this.jsonParseReviver);
316            return _observableOf(result200);
317            }));
318        } else {
319            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
320            let resultdefault: any = null;
321            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
322            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
323            }));
324        }
325    }
326
327    editDepartment(id: number, input: DepartmentParams | null): Observable<void> {
328        let url_ = this.baseUrl + "/api/v1/os/administration/departments/{id}";
329        if (id === undefined || id === null)
330            throw new Error("The parameter 'id' must be defined.");
331        url_ = url_.replace("{id}", encodeURIComponent("" + id)); 
332        url_ = url_.replace(/[?&]$/, "");
333
334        const content_ = JSON.stringify(input);
335
336        let options_ : any = {
337            body: content_,
338            observe: "response",
339            responseType: "blob",
340            headers: new HttpHeaders({
341                "Content-Type": "application/json", 
342            })
343        };
344
345        return this.http.request("put", url_, options_).pipe(_observableMergeMap((response_ : any) => {
346            return this.processEditDepartment(response_);
347        })).pipe(_observableCatch((response_: any) => {
348            if (response_ instanceof HttpResponseBase) {
349                try {
350                    return this.processEditDepartment(<any>response_);
351                } catch (e) {
352                    return <Observable<void>><any>_observableThrow(e);
353                }
354            } else
355                return <Observable<void>><any>_observableThrow(response_);
356        }));
357    }
358
359    protected processEditDepartment(response: HttpResponseBase): Observable<void> {
360        const status = response.status;
361        const responseBlob = 
362            response instanceof HttpResponse ? response.body : 
363            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
364
365        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
366        if (status === 204) {
367            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
368            return _observableOf<void>(<any>null);
369            }));
370        } else {
371            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
372            let resultdefault: any = null;
373            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
374            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
375            }));
376        }
377    }
378
379    getDepartmentDetails(id: number): Observable<DepartmentDetailsDTO | null> {
380        let url_ = this.baseUrl + "/api/v1/os/administration/departments/{id}";
381        if (id === undefined || id === null)
382            throw new Error("The parameter 'id' must be defined.");
383        url_ = url_.replace("{id}", encodeURIComponent("" + id)); 
384        url_ = url_.replace(/[?&]$/, "");
385
386        let options_ : any = {
387            observe: "response",
388            responseType: "blob",
389            headers: new HttpHeaders({
390                "Accept": "application/json"
391            })
392        };
393
394        return this.http.request("get", url_, options_).pipe(_observableMergeMap((response_ : any) => {
395            return this.processGetDepartmentDetails(response_);
396        })).pipe(_observableCatch((response_: any) => {
397            if (response_ instanceof HttpResponseBase) {
398                try {
399                    return this.processGetDepartmentDetails(<any>response_);
400                } catch (e) {
401                    return <Observable<DepartmentDetailsDTO | null>><any>_observableThrow(e);
402                }
403            } else
404                return <Observable<DepartmentDetailsDTO | null>><any>_observableThrow(response_);
405        }));
406    }
407
408    protected processGetDepartmentDetails(response: HttpResponseBase): Observable<DepartmentDetailsDTO | null> {
409        const status = response.status;
410        const responseBlob = 
411            response instanceof HttpResponse ? response.body : 
412            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
413
414        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
415        if (status === 200) {
416            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
417            let result200: any = null;
418            result200 = _responseText === "" ? null : <DepartmentDetailsDTO>JSON.parse(_responseText, this.jsonParseReviver);
419            return _observableOf(result200);
420            }));
421        } else {
422            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
423            let resultdefault: any = null;
424            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
425            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
426            }));
427        }
428    }
429
430    getDepartments(input: GetDepartmentsParams | null): Observable<GetResultOfDepartmentDTO | null> {
431        let url_ = this.baseUrl + "/api/v1/os/administration/departments/get";
432        url_ = url_.replace(/[?&]$/, "");
433
434        const content_ = JSON.stringify(input);
435
436        let options_ : any = {
437            body: content_,
438            observe: "response",
439            responseType: "blob",
440            headers: new HttpHeaders({
441                "Content-Type": "application/json", 
442                "Accept": "application/json"
443            })
444        };
445
446        return this.http.request("post", url_, options_).pipe(_observableMergeMap((response_ : any) => {
447            return this.processGetDepartments(response_);
448        })).pipe(_observableCatch((response_: any) => {
449            if (response_ instanceof HttpResponseBase) {
450                try {
451                    return this.processGetDepartments(<any>response_);
452                } catch (e) {
453                    return <Observable<GetResultOfDepartmentDTO | null>><any>_observableThrow(e);
454                }
455            } else
456                return <Observable<GetResultOfDepartmentDTO | null>><any>_observableThrow(response_);
457        }));
458    }
459
460    protected processGetDepartments(response: HttpResponseBase): Observable<GetResultOfDepartmentDTO | null> {
461        const status = response.status;
462        const responseBlob = 
463            response instanceof HttpResponse ? response.body : 
464            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
465
466        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
467        if (status === 200) {
468            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
469            let result200: any = null;
470            result200 = _responseText === "" ? null : <GetResultOfDepartmentDTO>JSON.parse(_responseText, this.jsonParseReviver);
471            return _observableOf(result200);
472            }));
473        } else {
474            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
475            let resultdefault: any = null;
476            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
477            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
478            }));
479        }
480    }
481}
482
483export interface IUserPrivilegesClient {
484    getUserPrivileges(): Observable<UserPrivilegeDTO[] | null>;
485    addUserPrivilegesGroup(input: UserPrivilegesGroupParams | null): Observable<number>;
486    editUserPrivilegesGroup(id: number, input: UserPrivilegesGroupParams | null): Observable<void>;
487    getUserPrivilegesGroupDetails(id: number): Observable<UserPrivilegesGroupDetailsDTO | null>;
488    getUserPrivilegesGroups(input: GetUserPrivilegesGroupsParams | null): Observable<GetResultOfUserPrivilegesGroupDTO | null>;
489}
490
491@Injectable()
492export class UserPrivilegesClient implements IUserPrivilegesClient {
493    private http: HttpClient;
494    private baseUrl: string;
495    protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;
496
497    constructor(@Inject(HttpClient) http: HttpClient, @Optional() @Inject(API_BASE_URL) baseUrl?: string) {
498        this.http = http;
499        this.baseUrl = baseUrl ? baseUrl : "http://localhost:8153";
500    }
501
502    getUserPrivileges(): Observable<UserPrivilegeDTO[] | null> {
503        let url_ = this.baseUrl + "/api/v1/os/administration/privileges";
504        url_ = url_.replace(/[?&]$/, "");
505
506        let options_ : any = {
507            observe: "response",
508            responseType: "blob",
509            headers: new HttpHeaders({
510                "Accept": "application/json"
511            })
512        };
513
514        return this.http.request("get", url_, options_).pipe(_observableMergeMap((response_ : any) => {
515            return this.processGetUserPrivileges(response_);
516        })).pipe(_observableCatch((response_: any) => {
517            if (response_ instanceof HttpResponseBase) {
518                try {
519                    return this.processGetUserPrivileges(<any>response_);
520                } catch (e) {
521                    return <Observable<UserPrivilegeDTO[] | null>><any>_observableThrow(e);
522                }
523            } else
524                return <Observable<UserPrivilegeDTO[] | null>><any>_observableThrow(response_);
525        }));
526    }
527
528    protected processGetUserPrivileges(response: HttpResponseBase): Observable<UserPrivilegeDTO[] | null> {
529        const status = response.status;
530        const responseBlob = 
531            response instanceof HttpResponse ? response.body : 
532            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
533
534        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
535        if (status === 200) {
536            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
537            let result200: any = null;
538            result200 = _responseText === "" ? null : <UserPrivilegeDTO[]>JSON.parse(_responseText, this.jsonParseReviver);
539            return _observableOf(result200);
540            }));
541        } else {
542            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
543            let resultdefault: any = null;
544            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
545            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
546            }));
547        }
548    }
549
550    addUserPrivilegesGroup(input: UserPrivilegesGroupParams | null): Observable<number> {
551        let url_ = this.baseUrl + "/api/v1/os/administration/privileges/groups";
552        url_ = url_.replace(/[?&]$/, "");
553
554        const content_ = JSON.stringify(input);
555
556        let options_ : any = {
557            body: content_,
558            observe: "response",
559            responseType: "blob",
560            headers: new HttpHeaders({
561                "Content-Type": "application/json", 
562                "Accept": "application/json"
563            })
564        };
565
566        return this.http.request("post", url_, options_).pipe(_observableMergeMap((response_ : any) => {
567            return this.processAddUserPrivilegesGroup(response_);
568        })).pipe(_observableCatch((response_: any) => {
569            if (response_ instanceof HttpResponseBase) {
570                try {
571                    return this.processAddUserPrivilegesGroup(<any>response_);
572                } catch (e) {
573                    return <Observable<number>><any>_observableThrow(e);
574                }
575            } else
576                return <Observable<number>><any>_observableThrow(response_);
577        }));
578    }
579
580    protected processAddUserPrivilegesGroup(response: HttpResponseBase): Observable<number> {
581        const status = response.status;
582        const responseBlob = 
583            response instanceof HttpResponse ? response.body : 
584            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
585
586        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
587        if (status === 200) {
588            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
589            let result200: any = null;
590            result200 = _responseText === "" ? null : <number>JSON.parse(_responseText, this.jsonParseReviver);
591            return _observableOf(result200);
592            }));
593        } else {
594            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
595            let resultdefault: any = null;
596            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
597            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
598            }));
599        }
600    }
601
602    editUserPrivilegesGroup(id: number, input: UserPrivilegesGroupParams | null): Observable<void> {
603        let url_ = this.baseUrl + "/api/v1/os/administration/privileges/groups/{id}";
604        if (id === undefined || id === null)
605            throw new Error("The parameter 'id' must be defined.");
606        url_ = url_.replace("{id}", encodeURIComponent("" + id)); 
607        url_ = url_.replace(/[?&]$/, "");
608
609        const content_ = JSON.stringify(input);
610
611        let options_ : any = {
612            body: content_,
613            observe: "response",
614            responseType: "blob",
615            headers: new HttpHeaders({
616                "Content-Type": "application/json", 
617            })
618        };
619
620        return this.http.request("put", url_, options_).pipe(_observableMergeMap((response_ : any) => {
621            return this.processEditUserPrivilegesGroup(response_);
622        })).pipe(_observableCatch((response_: any) => {
623            if (response_ instanceof HttpResponseBase) {
624                try {
625                    return this.processEditUserPrivilegesGroup(<any>response_);
626                } catch (e) {
627                    return <Observable<void>><any>_observableThrow(e);
628                }
629            } else
630                return <Observable<void>><any>_observableThrow(response_);
631        }));
632    }
633
634    protected processEditUserPrivilegesGroup(response: HttpResponseBase): Observable<void> {
635        const status = response.status;
636        const responseBlob = 
637            response instanceof HttpResponse ? response.body : 
638            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
639
640        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
641        if (status === 204) {
642            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
643            return _observableOf<void>(<any>null);
644            }));
645        } else {
646            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
647            let resultdefault: any = null;
648            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
649            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
650            }));
651        }
652    }
653
654    getUserPrivilegesGroupDetails(id: number): Observable<UserPrivilegesGroupDetailsDTO | null> {
655        let url_ = this.baseUrl + "/api/v1/os/administration/privileges/groups/{id}";
656        if (id === undefined || id === null)
657            throw new Error("The parameter 'id' must be defined.");
658        url_ = url_.replace("{id}", encodeURIComponent("" + id)); 
659        url_ = url_.replace(/[?&]$/, "");
660
661        let options_ : any = {
662            observe: "response",
663            responseType: "blob",
664            headers: new HttpHeaders({
665                "Accept": "application/json"
666            })
667        };
668
669        return this.http.request("get", url_, options_).pipe(_observableMergeMap((response_ : any) => {
670            return this.processGetUserPrivilegesGroupDetails(response_);
671        })).pipe(_observableCatch((response_: any) => {
672            if (response_ instanceof HttpResponseBase) {
673                try {
674                    return this.processGetUserPrivilegesGroupDetails(<any>response_);
675                } catch (e) {
676                    return <Observable<UserPrivilegesGroupDetailsDTO | null>><any>_observableThrow(e);
677                }
678            } else
679                return <Observable<UserPrivilegesGroupDetailsDTO | null>><any>_observableThrow(response_);
680        }));
681    }
682
683    protected processGetUserPrivilegesGroupDetails(response: HttpResponseBase): Observable<UserPrivilegesGroupDetailsDTO | null> {
684        const status = response.status;
685        const responseBlob = 
686            response instanceof HttpResponse ? response.body : 
687            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
688
689        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
690        if (status === 200) {
691            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
692            let result200: any = null;
693            result200 = _responseText === "" ? null : <UserPrivilegesGroupDetailsDTO>JSON.parse(_responseText, this.jsonParseReviver);
694            return _observableOf(result200);
695            }));
696        } else {
697            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
698            let resultdefault: any = null;
699            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
700            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
701            }));
702        }
703    }
704
705    getUserPrivilegesGroups(input: GetUserPrivilegesGroupsParams | null): Observable<GetResultOfUserPrivilegesGroupDTO | null> {
706        let url_ = this.baseUrl + "/api/v1/os/administration/privileges/groups/get";
707        url_ = url_.replace(/[?&]$/, "");
708
709        const content_ = JSON.stringify(input);
710
711        let options_ : any = {
712            body: content_,
713            observe: "response",
714            responseType: "blob",
715            headers: new HttpHeaders({
716                "Content-Type": "application/json", 
717                "Accept": "application/json"
718            })
719        };
720
721        return this.http.request("post", url_, options_).pipe(_observableMergeMap((response_ : any) => {
722            return this.processGetUserPrivilegesGroups(response_);
723        })).pipe(_observableCatch((response_: any) => {
724            if (response_ instanceof HttpResponseBase) {
725                try {
726                    return this.processGetUserPrivilegesGroups(<any>response_);
727                } catch (e) {
728                    return <Observable<GetResultOfUserPrivilegesGroupDTO | null>><any>_observableThrow(e);
729                }
730            } else
731                return <Observable<GetResultOfUserPrivilegesGroupDTO | null>><any>_observableThrow(response_);
732        }));
733    }
734
735    protected processGetUserPrivilegesGroups(response: HttpResponseBase): Observable<GetResultOfUserPrivilegesGroupDTO | null> {
736        const status = response.status;
737        const responseBlob = 
738            response instanceof HttpResponse ? response.body : 
739            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
740
741        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
742        if (status === 200) {
743            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
744            let result200: any = null;
745            result200 = _responseText === "" ? null : <GetResultOfUserPrivilegesGroupDTO>JSON.parse(_responseText, this.jsonParseReviver);
746            return _observableOf(result200);
747            }));
748        } else {
749            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
750            let resultdefault: any = null;
751            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
752            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
753            }));
754        }
755    }
756}
757
758export interface IStreamingClient {
759    /**
760     * Pobiera plik o podanym guidzie i zwraca go w formacie binarnym jako octet-stream
761     * @param id Guid pliku
762     * @param storage (optional) Rodzaj magazynu, w którym przechowywany jest plik
763     * @param fileName (optional) Nazwa, pod jaką ma zostać zapisany plik. 
764                Jeśli nie zostanie podana, to nazwą pliku będzie jego guid
765     * @param sizeY (optional) Wysokość w pikselach, do jakiej ma zostać przeskalowany obrazek (jeśli plik jest obrazkiem)
766     * @return Plik w formacie binarnym
767     */
768    get(id: string | null, storage?: any | undefined, fileName?: string | null | undefined, sizeY?: number | null | undefined): Observable<FileResponse>;
769    /**
770     * Pozwala na wgranie plików na serwer
771     * @return Guid pliku
772     */
773    post(file_bytesFormData: FileParameter): Observable<string[] | null>;
774}
775
776@Injectable()
777export class StreamingClient implements IStreamingClient {
778    private http: HttpClient;
779    private baseUrl: string;
780    protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;
781
782    constructor(@Inject(HttpClient) http: HttpClient, @Optional() @Inject(API_BASE_URL) baseUrl?: string) {
783        this.http = http;
784        this.baseUrl = baseUrl ? baseUrl : "http://localhost:8153";
785    }
786
787    /**
788     * Pobiera plik o podanym guidzie i zwraca go w formacie binarnym jako octet-stream
789     * @param id Guid pliku
790     * @param storage (optional) Rodzaj magazynu, w którym przechowywany jest plik
791     * @param fileName (optional) Nazwa, pod jaką ma zostać zapisany plik. 
792                Jeśli nie zostanie podana, to nazwą pliku będzie jego guid
793     * @param sizeY (optional) Wysokość w pikselach, do jakiej ma zostać przeskalowany obrazek (jeśli plik jest obrazkiem)
794     * @return Plik w formacie binarnym
795     */
796    get(id: string | null, storage?: any | undefined, fileName?: string | null | undefined, sizeY?: number | null | undefined): Observable<FileResponse> {
797        let url_ = this.baseUrl + "/api/v1/common/streaming/{id}?";
798        if (id === undefined || id === null)
799            throw new Error("The parameter 'id' must be defined.");
800        url_ = url_.replace("{id}", encodeURIComponent("" + id)); 
801        if (storage === null)
802            throw new Error("The parameter 'storage' cannot be null.");
803        else if (storage !== undefined)
804            url_ += "storage=" + encodeURIComponent("" + storage) + "&"; 
805        if (fileName !== undefined)
806            url_ += "fileName=" + encodeURIComponent("" + fileName) + "&"; 
807        if (sizeY !== undefined)
808            url_ += "sizeY=" + encodeURIComponent("" + sizeY) + "&"; 
809        url_ = url_.replace(/[?&]$/, "");
810
811        let options_ : any = {
812            observe: "response",
813            responseType: "blob",
814            headers: new HttpHeaders({
815                "Accept": "application/octet-stream"
816            })
817        };
818
819        return this.http.request("get", url_, options_).pipe(_observableMergeMap((response_ : any) => {
820            return this.processGet(response_);
821        })).pipe(_observableCatch((response_: any) => {
822            if (response_ instanceof HttpResponseBase) {
823                try {
824                    return this.processGet(<any>response_);
825                } catch (e) {
826                    return <Observable<FileResponse>><any>_observableThrow(e);
827                }
828            } else
829                return <Observable<FileResponse>><any>_observableThrow(response_);
830        }));
831    }
832
833    protected processGet(response: HttpResponseBase): Observable<FileResponse> {
834        const status = response.status;
835        const responseBlob = 
836            response instanceof HttpResponse ? response.body : 
837            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
838
839        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
840        if (status === 200 || status === 206) {
841            const contentDisposition = response.headers ? response.headers.get("content-disposition") : undefined;
842            const fileNameMatch = contentDisposition ? /filename="?([^"]*?)"?(;|$)/g.exec(contentDisposition) : undefined;
843            const fileName = fileNameMatch && fileNameMatch.length > 1 ? fileNameMatch[1] : undefined;
844            return _observableOf({ fileName: fileName, data: <any>responseBlob, status: status, headers: _headers });
845        } else {
846            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
847            let resultdefault: any = null;
848            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
849            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
850            }));
851        }
852    }
853
854    /**
855     * Pozwala na wgranie plików na serwer
856     * @return Guid pliku
857     */
858    post(file_bytesFormData: FileParameter): Observable<string[] | null> {
859        let url_ = this.baseUrl + "/api/v1/common/streaming";
860        url_ = url_.replace(/[?&]$/, "");
861
862        const content_ = new FormData();
863        if (file_bytesFormData === null || file_bytesFormData === undefined)
864            throw new Error("The parameter 'file_bytesFormData' cannot be null.");
865        else
866            content_.append("File bytes", file_bytesFormData.data, file_bytesFormData.fileName ? file_bytesFormData.fileName : "File bytes");
867
868        let options_ : any = {
869            body: content_,
870            observe: "response",
871            responseType: "blob",
872            headers: new HttpHeaders({
873                "Accept": "application/json"
874            })
875        };
876
877        return this.http.request("post", url_, options_).pipe(_observableMergeMap((response_ : any) => {
878            return this.processPost(response_);
879        })).pipe(_observableCatch((response_: any) => {
880            if (response_ instanceof HttpResponseBase) {
881                try {
882                    return this.processPost(<any>response_);
883                } catch (e) {
884                    return <Observable<string[] | null>><any>_observableThrow(e);
885                }
886            } else
887                return <Observable<string[] | null>><any>_observableThrow(response_);
888        }));
889    }
890
891    protected processPost(response: HttpResponseBase): Observable<string[] | null> {
892        const status = response.status;
893        const responseBlob = 
894            response instanceof HttpResponse ? response.body : 
895            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
896
897        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
898        if (status === 200) {
899            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
900            let result200: any = null;
901            result200 = _responseText === "" ? null : <string[]>JSON.parse(_responseText, this.jsonParseReviver);
902            return _observableOf(result200);
903            }));
904        } else {
905            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
906            let resultdefault: any = null;
907            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
908            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
909            }));
910        }
911    }
912}
913
914export interface IJwtAuthenticationClient {
915    /**
916     * Loguje użytkownika
917     * @param input Dane logowania użytkownika
918     */
919    login(input: LoginParams | null): Observable<CorrectLoginResponse | null>;
920    /**
921     * Pozwala na pobranie access token'u (potrzebnego do wywoływania metod API) na bazie refresh tokenu
922     * @param refreshToken Refresh token, otrzymany przy logowaniu
923     * @return Access Token
924     */
925    getAccessToken(refreshToken: string | null): Observable<string | null>;
926}
927
928@Injectable()
929export class JwtAuthenticationClient implements IJwtAuthenticationClient {
930    private http: HttpClient;
931    private baseUrl: string;
932    protected jsonParseReviver: ((key: string, value: any) => any) | undefined = undefined;
933
934    constructor(@Inject(HttpClient) http: HttpClient, @Optional() @Inject(API_BASE_URL) baseUrl?: string) {
935        this.http = http;
936        this.baseUrl = baseUrl ? baseUrl : "http://localhost:8153";
937    }
938
939    /**
940     * Loguje użytkownika
941     * @param input Dane logowania użytkownika
942     */
943    login(input: LoginParams | null): Observable<CorrectLoginResponse | null> {
944        let url_ = this.baseUrl + "/api/v1/common/authentication/jwt/login";
945        url_ = url_.replace(/[?&]$/, "");
946
947        const content_ = JSON.stringify(input);
948
949        let options_ : any = {
950            body: content_,
951            observe: "response",
952            responseType: "blob",
953            headers: new HttpHeaders({
954                "Content-Type": "application/json", 
955                "Accept": "application/json"
956            })
957        };
958
959        return this.http.request("post", url_, options_).pipe(_observableMergeMap((response_ : any) => {
960            return this.processLogin(response_);
961        })).pipe(_observableCatch((response_: any) => {
962            if (response_ instanceof HttpResponseBase) {
963                try {
964                    return this.processLogin(<any>response_);
965                } catch (e) {
966                    return <Observable<CorrectLoginResponse | null>><any>_observableThrow(e);
967                }
968            } else
969                return <Observable<CorrectLoginResponse | null>><any>_observableThrow(response_);
970        }));
971    }
972
973    protected processLogin(response: HttpResponseBase): Observable<CorrectLoginResponse | null> {
974        const status = response.status;
975        const responseBlob = 
976            response instanceof HttpResponse ? response.body : 
977            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
978
979        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
980        if (status === 200) {
981            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
982            let result200: any = null;
983            result200 = _responseText === "" ? null : <CorrectLoginResponse>JSON.parse(_responseText, this.jsonParseReviver);
984            return _observableOf(result200);
985            }));
986        } else {
987            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
988            let resultdefault: any = null;
989            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
990            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
991            }));
992        }
993    }
994
995    /**
996     * Pozwala na pobranie access token'u (potrzebnego do wywoływania metod API) na bazie refresh tokenu
997     * @param refreshToken Refresh token, otrzymany przy logowaniu
998     * @return Access Token
999     */
1000    getAccessToken(refreshToken: string | null): Observable<string | null> {
1001        let url_ = this.baseUrl + "/api/v1/common/authentication/jwt/accessToken";
1002        url_ = url_.replace(/[?&]$/, "");
1003
1004        const content_ = JSON.stringify(refreshToken);
1005
1006        let options_ : any = {
1007            body: content_,
1008            observe: "response",
1009            responseType: "blob",
1010            headers: new HttpHeaders({
1011                "Content-Type": "application/json", 
1012                "Accept": "application/json"
1013            })
1014        };
1015
1016        return this.http.request("post", url_, options_).pipe(_observableMergeMap((response_ : any) => {
1017            return this.processGetAccessToken(response_);
1018        })).pipe(_observableCatch((response_: any) => {
1019            if (response_ instanceof HttpResponseBase) {
1020                try {
1021                    return this.processGetAccessToken(<any>response_);
1022                } catch (e) {
1023                    return <Observable<string | null>><any>_observableThrow(e);
1024                }
1025            } else
1026                return <Observable<string | null>><any>_observableThrow(response_);
1027        }));
1028    }
1029
1030    protected processGetAccessToken(response: HttpResponseBase): Observable<string | null> {
1031        const status = response.status;
1032        const responseBlob = 
1033            response instanceof HttpResponse ? response.body : 
1034            (<any>response).error instanceof Blob ? (<any>response).error : undefined;
1035
1036        let _headers: any = {}; if (response.headers) { for (let key of response.headers.keys()) { _headers[key] = response.headers.get(key); }};
1037        if (status === 200) {
1038            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
1039            let result200: any = null;
1040            result200 = _responseText === "" ? null : <string>JSON.parse(_responseText, this.jsonParseReviver);
1041            return _observableOf(result200);
1042            }));
1043        } else {
1044            return blobToText(responseBlob).pipe(_observableMergeMap(_responseText => {
1045            let resultdefault: any = null;
1046            resultdefault = _responseText === "" ? null : <ErrorResponse>JSON.parse(_responseText, this.jsonParseReviver);
1047            return throwException("A server error occurred.", status, _responseText, _headers, resultdefault);
1048            }));
1049        }
1050    }
1051}
1052
1053export interface MailingConfigurationParams {
1054    SenderAddress?: string | undefined;
1055    SenderName?: string | undefined;
1056    Host?: string | undefined;
1057    Password?: string | undefined;
1058    SmtpPort?: number;
1059    EnableSsl?: boolean;
1060}
1061
1062export interface MailingConfigurationDTO extends MailingConfigurationParams {
1063    EditionMetadata?: EditionMetadataDTO | undefined;
1064}
1065
1066export interface EditionMetadataDTO {
1067    CreatorId?: number;
1068    CreatorName?: string | undefined;
1069    CreationDate?: moment.Moment;
1070    ModificatorId?: number | undefined;
1071    ModificatorName?: string | undefined;
1072    ModificationDate?: moment.Moment | undefined;
1073}
1074
1075export interface ErrorResponse {
1076    Message?: string | undefined;
1077    Code?: number | undefined;
1078}
1079
1080export interface UiConfigurationParams {
1081    HomePage?: string | undefined;
1082    SecuritySchemaFileGuid?: string | undefined;
1083    MaxImageSizeKB?: number | undefined;
1084    ImageDefaultSize?: number | undefined;
1085}
1086
1087export interface UiConfigurationDTO extends UiConfigurationParams {
1088    EditionMetadata?: EditionMetadataDTO | undefined;
1089}
1090
1091export interface DepartmentParams {
1092    IsActive: boolean;
1093    Name: string;
1094    Type: DepartmentType;
1095    Phone: string;
1096    Email: string;
1097    ManagerId?: number | undefined;
1098    Address: AddressDTO;
1099    GeoCoordinates: GeoCoordinatesDTO;
1100}
1101
1102export enum DepartmentType {
1103    Standalone = 1,
1104    Small = 2,
1105    Airport = 4,
1106}
1107
1108export interface AddressDTO {
1109    Street?: string | undefined;
1110    PostalCode?: string | undefined;
1111    City: string;
1112    Province?: string | undefined;
1113    Country?: string | undefined;
1114}
1115
1116export interface GeoCoordinatesDTO {
1117    Latitude?: number;
1118    Longitude?: number;
1119}
1120
1121export interface GetResultOfDepartmentDTO {
1122    CountAll?: number;
1123    Data?: DepartmentDTO[] | undefined;
1124}
1125
1126export interface DepartmentDTO {
1127    Id?: number;
1128    IsActive?: boolean;
1129    Name?: string | undefined;
1130    Type?: DepartmentType;
1131    Phone?: string | undefined;
1132    Email?: string | undefined;
1133    ManagerId?: number | undefined;
1134    ManagerName?: string | undefined;
1135    Address?: string | undefined;
1136    AddressObject?: AddressDTO | undefined;
1137    Latitude?: number;
1138    Longitude?: number;
1139}
1140
1141export interface GetDepartmentsParams {
1142    Id?: NumberFilterParamsOfNullableInteger | undefined;
1143    IsActive?: BoolFilterParams | undefined;
1144    Name?: StringFilterParams | undefined;
1145    Type?: EnumFilterParamsOfNullableDepartmentType | undefined;
1146    Phone?: StringFilterParams | undefined;
1147    Email?: StringFilterParams | undefined;
1148    ManagerId?: NumberFilterParamsOfNullableInteger | undefined;
1149    ManagerName?: StringFilterParams | undefined;
1150    Address?: StringFilterParams | undefined;
1151    AddressObject?: EmptyFilterParams | undefined;
1152    Latitude?: NumberFilterParamsOfNullableSingle | undefined;
1153    Longitude?: NumberFilterParamsOfNullableSingle | undefined;
1154    Paging?: PagingParams | undefined;
1155}
1156
1157export interface NumberFilterParamsOfNullableInteger {
1158    Equal?: number | undefined;
1159    NotEqual?: number | undefined;
1160    LessThan?: number | undefined;
1161    LessThanOrEqual?: number | undefined;
1162    GreaterThan?: number | undefined;
1163    GreaterThanOrEqual?: number | undefined;
1164    HasValue?: boolean | undefined;
1165    OneOf?: (number | undefined)[] | undefined;
1166    NotOneOf?: (number | undefined)[] | undefined;
1167    Compute?: boolean;
1168    Sort?: SortDir | undefined;
1169}
1170
1171export enum SortDir {
1172    Desc = 0,
1173    Asc = 1,
1174}
1175
1176export interface BoolFilterParams {
1177    Equal?: boolean | undefined;
1178    NotEqual?: boolean | undefined;
1179    HasValue?: boolean | undefined;
1180    Compute?: boolean;
1181    Sort?: SortDir | undefined;
1182}
1183
1184export interface StringFilterParams {
1185    Equal?: string | undefined;
1186    NotEqual?: string | undefined;
1187    HasValue?: boolean | undefined;
1188    OneOf?: string[] | undefined;
1189    NotOneOf?: string[] | undefined;
1190    Contains?: string | undefined;
1191    NotContains?: string | undefined;
1192    StartsWith?: string | undefined;
1193    EndsWith?: string | undefined;
1194    ContainsAllWords?: string | undefined;
1195    Compute?: boolean;
1196    Sort?: SortDir | undefined;
1197}
1198
1199export interface EnumFilterParamsOfNullableDepartmentType {
1200    Equal?: DepartmentType | undefined;
1201    NotEqual?: DepartmentType | undefined;
1202    HasFlag?: DepartmentType | undefined;
1203    HasntFlag?: DepartmentType | undefined;
1204    HasValue?: boolean | undefined;
1205    OneOf?: (DepartmentType | undefined)[] | undefined;
1206    NotOneOf?: (DepartmentType | undefined)[] | undefined;
1207    Compute?: boolean;
1208    Sort?: SortDir | undefined;
1209}
1210
1211export interface EmptyFilterParams {
1212    Equal?: string | undefined;
1213    NotEqual?: string | undefined;
1214    LessThan?: string | undefined;
1215    LessThanOrEqual?: string | undefined;
1216    GreaterThan?: string | undefined;
1217    GreaterThanOrEqual?: string | undefined;
1218    HasFlag?: string | undefined;
1219    HasntFlag?: string | undefined;
1220    HasValue?: boolean | undefined;
1221    OneOf?: string[] | undefined;
1222    NotOneOf?: string[] | undefined;
1223    Contains?: string | undefined;
1224    NotContains?: string | undefined;
1225    StartsWith?: string | undefined;
1226    EndsWith?: string | undefined;
1227    ContainsAllWords?: string | undefined;
1228    Compute?: boolean;
1229    Sort?: SortDir | undefined;
1230}
1231
1232export interface NumberFilterParamsOfNullableSingle {
1233    Equal?: number | undefined;
1234    NotEqual?: number | undefined;
1235    LessThan?: number | undefined;
1236    LessThanOrEqual?: number | undefined;
1237    GreaterThan?: number | undefined;
1238    GreaterThanOrEqual?: number | undefined;
1239    HasValue?: boolean | undefined;
1240    OneOf?: (number | undefined)[] | undefined;
1241    NotOneOf?: (number | undefined)[] | undefined;
1242    Compute?: boolean;
1243    Sort?: SortDir | undefined;
1244}
1245
1246export interface PagingParams {
1247    Skip?: number | undefined;
1248    Take?: number | undefined;
1249}
1250
1251export interface DepartmentDetailsDTO extends DepartmentParams {
1252    Id?: number;
1253    ManagerName?: string | undefined;
1254    EditionMetadata?: EditionMetadataDTO | undefined;
1255}
1256
1257export interface UserPrivilegeDTO {
1258    Id?: number;
1259    Name?: string | undefined;
1260    Module?: UiModule;
1261}
1262
1263export enum UiModule {
1264    Role = 1,
1265    Ghosts = 2,
1266    Cars = 3,
1267    Telemetry = 4,
1268    Reservations = 5,
1269    Commission = 6,
1270    CarsArchive = 7,
1271    Knowledge = 8,
1272    Pricelists = 9,
1273    AdditionalEquipment = 10,
1274    Orders = 11,
1275    Policies = 12,
1276    Services = 13,
1277    Finances = 14,
1278    Administration = 15,
1279    FrameworkAgreements = 16,
1280    Contractors = 17,
1281    Alerts = 18,
1282    Statistics = 19,
1283}
1284
1285export interface UserPrivilegesGroupParams {
1286    Name?: string | undefined;
1287    IsActive?: boolean;
1288    PrivilegesIds?: number[] | undefined;
1289}
1290
1291export interface GetResultOfUserPrivilegesGroupDTO {
1292    CountAll?: number;
1293    Data?: UserPrivilegesGroupDTO[] | undefined;
1294}
1295
1296export interface UserPrivilegesGroupDTO {
1297    Id?: number;
1298    IsActive?: boolean;
1299    Name?: string | undefined;
1300}
1301
1302export interface GetUserPrivilegesGroupsParams {
1303    Id?: NumberFilterParamsOfNullableInteger | undefined;
1304    IsActive?: BoolFilterParams | undefined;
1305    Name?: StringFilterParams | undefined;
1306    Paging?: PagingParams | undefined;
1307}
1308
1309export interface UserPrivilegesGroupDetailsDTO extends UserPrivilegesGroupDTO {
1310    Privileges?: UserPrivilegeDTO[] | undefined;
1311    EditionMetadata?: EditionMetadataDTO | undefined;
1312}
1313
1314export enum ItemType {
1315    User = 1,
1316    UserPrivilegesGroup = 2,
1317    Department = 3,
1318    DepartmentGroup = 4,
1319    Car = 5,
1320    CarDamage = 6,
1321    Configuration = 7,
1322}
1323
1324export interface CorrectLoginResponse {
1325    RefreshToken?: string | undefined;
1326    RefreshTokenValidTo?: moment.Moment;
1327    DepartmentId?: number | undefined;
1328    DepartmentName?: string | undefined;
1329    FirstName?: string | undefined;
1330    LastName?: string | undefined;
1331    Email?: string | undefined;
1332    Phone?: string | undefined;
1333    UserId?: number;
1334    Privileges?: UserPrivilegeDTO[] | undefined;
1335    UIConfig?: string | undefined;
1336    UserType?: UserType;
1337}
1338
1339export enum UserType {
1340    Worker = 1,
1341    IntergratedSystem = 2,
1342}
1343
1344export interface LoginParams {
1345    Login: string;
1346    Password: string;
1347}
1348
1349export interface FileParameter {
1350    data: any;
1351    fileName: string;
1352}
1353
1354export interface FileResponse {
1355    data: Blob;
1356    status: number;
1357    fileName?: string;
1358    headers?: { [name: string]: any };
1359}
1360
1361export class SwaggerException extends Error {
1362    message: string;
1363    status: number; 
1364    response: string; 
1365    headers: { [key: string]: any; };
1366    result: any; 
1367
1368    constructor(message: string, status: number, response: string, headers: { [key: string]: any; }, result: any) {
1369        super();
1370
1371        this.message = message;
1372        this.status = status;
1373        this.response = response;
1374        this.headers = headers;
1375        this.result = result;
1376    }
1377
1378    protected isSwaggerException = true;
1379
1380    static isSwaggerException(obj: any): obj is SwaggerException {
1381        return obj.isSwaggerException === true;
1382    }
1383}
1384
1385function throwException(message: string, status: number, response: string, headers: { [key: string]: any; }, result?: any): Observable<any> {
1386    if(result !== null && result !== undefined)
1387        return _observableThrow(result);
1388    else
1389        return _observableThrow(new SwaggerException(message, status, response, headers, null));
1390}
1391
1392function blobToText(blob: any): Observable<string> {
1393    return new Observable<string>((observer: any) => {
1394        if (!blob) {
1395            observer.next("");
1396            observer.complete();
1397        } else {
1398            let reader = new FileReader(); 
1399            reader.onload = event => { 
1400                observer.next((<any>event.target).result);
1401                observer.complete();
1402            };
1403            reader.readAsText(blob); 
1404        }
1405    });
1406}