@energycap/energycapid-sdk-angular 1.2112.49-develop-20211222-1650 → 1.2112.53-ECAPID-356-ApplicationInstance-Get-API-20220106-1621

package/esm2015/api/me.service.js

@@ -112,6 +112,22 @@ export class MeService {
             }
         }));
     }
+    /**
+     * Use this method to update the currently authenticated user's notification settings
+     *
+     * @param body The user notification settings to update
+     */
+    updateMyNotificationSetting(body, extraHttpRequestParams, extraHttpRequestHeaders) {
+        return this.updateMyNotificationSettingWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders)
+            .pipe(map((response) => {
+            if (response.status === 204) {
+                return undefined;
+            }
+            else {
+                return response.body;
+            }
+        }));
+    }
     /**
      * Use this method to get information about the currently authenticated user
      *
@@ -249,6 +265,54 @@ export class MeService {
         };
         return this.http.request(RequestMethod.Put, path, requestOptions);
     }
+    /**
+     * Use this method to update the currently authenticated user's notification settings
+     *
+     * @param body The user notification settings to update
+     */
+    updateMyNotificationSettingWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders) {
+        const path = this.basePath + '/api/v202108/Me/notificationsetting';
+        let queryParameters;
+        if (extraHttpRequestParams) {
+            if (typeof extraHttpRequestParams.search === 'string') {
+                queryParameters = new HttpParams({ fromString: extraHttpRequestParams.search });
+            }
+            else {
+                queryParameters = new HttpParams({ fromObject: extraHttpRequestParams.search });
+            }
+        }
+        else {
+            queryParameters = new HttpParams();
+        }
+        let headers = new HttpHeaders();
+        this.defaultHeaders.keys().forEach(key => {
+            headers = headers.set(key, this.defaultHeaders.getAll(key));
+        });
+        if (extraHttpRequestHeaders) {
+            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {
+                headers = headers.set(key, value);
+            });
+        }
+        // to determine the Accept header
+        let produces = [
+            'application/json'
+        ];
+        if (this.configuration.apiKeys["Authorization"]) {
+            headers = headers.set('Authorization', this.configuration.apiKeys["Authorization"]);
+        }
+        const consumes = [
+            'application/json'
+        ];
+        headers = headers.set('Content-Type', consumes[0]);
+        let requestOptions = {
+            headers: headers,
+            body: body == null ? '' : (consumes[0] == 'application/json' ? JSON.stringify(body) : body),
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            observe: 'response'
+        };
+        return this.http.request(RequestMethod.Put, path, requestOptions);
+    }
 }
 MeService.decorators = [
     { type: Injectable }
@@ -258,4 +322,4 @@ MeService.ctorParameters = () => [
     { type: String, decorators: [{ type: Optional }, { type: Inject, args: [BASE_PATH,] }] },
     { type: Configuration, decorators: [{ type: Optional }] }
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"me.service.js","sourceRoot":"","sources":["../../../api/me.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * EnergyCAP ID SDK\r\n * Document used to generate the EnergyCAP ID SDK\r\n *\r\n * OpenAPI spec version: 1.2112\r\n * Contact: support@energycap.com\r\n *\r\n * NOTE: This class is auto generated by the swagger code generator program.\r\n * https://github.com/swagger-api/swagger-codegen.git\r\n * Do not edit the class manually.\r\n */\r\n\r\n/* tslint:disable:no-unused-variable member-ordering */\r\n\r\nimport { Inject, Injectable, Optional }                      from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams }               from '@angular/common/http';\r\nimport { HttpResponse }                                      from '@angular/common/http';\r\n\r\nimport { Observable }                                        from 'rxjs';\r\nimport { map }                                               from 'rxjs/operators';\r\n\r\nimport { LinkDataSourceRequest } from '../model/linkDataSourceRequest';\r\nimport { UpdateMeRequest } from '../model/updateMeRequest';\r\nimport { UserResponse } from '../model/userResponse';\r\n\r\nimport { BASE_PATH }                                         from '../variables';\r\nimport { COLLECTION_FORMATS }                                from '../variables';\r\n\r\nimport { Configuration }                                     from '../configuration';\r\n\r\nconst RequestMethod = {\r\n    Get: 'get',\r\n    Post: 'post',\r\n    Put: 'put',\r\n    Delete: 'delete',\r\n    Options: 'options',\r\n    Head: 'head',\r\n    Patch: 'patch'\r\n};\r\n\r\n\r\n@Injectable()\r\nexport class MeService {\r\n\r\n    protected basePath = 'https://localhost';\r\n    public defaultHeaders: HttpHeaders = new HttpHeaders();\r\n    public configuration: Configuration = new Configuration();\r\n\r\n    constructor(protected http: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\r\n        if (basePath) {\r\n            this.basePath = basePath;\r\n        }\r\n        if (configuration) {\r\n            this.configuration = configuration;\r\n\t\t\tthis.basePath = basePath || configuration.basePath || this.basePath;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * \r\n     * Extends object by coping non-existing properties.\r\n     * @param objA object to be extended\r\n     * @param objB source object\r\n     */\r\n    private extendObj<T1,T2>(objA: T1, objB: T2) {\r\n        for(let key in objB){\r\n            if(objB.hasOwnProperty(key)){\r\n                (objA as any)[key] = (objB as any)[key];\r\n            }\r\n        }\r\n        return <T1&T2>objA;\r\n    }\r\n\r\n    /**\r\n     * @param consumes string[] mime-types\r\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\r\n     */\r\n    private canConsumeForm(consumes: string[]): boolean {\r\n        const form = 'multipart/form-data';\r\n        for (let consume of consumes) {\r\n            if (form === consume) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Use this method to get information about the currently authenticated user\r\n     * \r\n     */\r\n    public getMe(extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<UserResponse> {\r\n        return this.getMeWithHttpInfo(extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<UserResponse>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n    /**\r\n     * Will allow a user to link to a data source that they don&#39;t have access to based upon their login name\r\n     * \r\n     * @param body Information needed to connect to the data source\r\n     */\r\n    public linkMyUserToDataSource(body?: LinkDataSourceRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<any> {\r\n        return this.linkMyUserToDataSourceWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<any>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n    /**\r\n     * Use this method to update the currently authenticated user&#39;s information\r\n     * \r\n     * @param body The user information to update\r\n     */\r\n    public updateMyInformation(body?: UpdateMeRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<UserResponse> {\r\n        return this.updateMyInformationWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<UserResponse>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n\r\n    /**\r\n     * Use this method to get information about the currently authenticated user\r\n     * \r\n     */\r\n    public getMeWithHttpInfo(extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<UserResponse>> {\r\n        const path = this.basePath + '/api/v202108/Me';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<UserResponse>(RequestMethod.Get, path, requestOptions);\r\n    }\r\n\r\n    /**\r\n     * Will allow a user to link to a data source that they don&#39;t have access to based upon their login name\r\n     * \r\n     * @param body Information needed to connect to the data source\r\n     */\r\n    public linkMyUserToDataSourceWithHttpInfo(body?: LinkDataSourceRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<any>> {\r\n        const path = this.basePath + '/api/v202108/Me/dataSource/link';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n            'application/json'\r\n        ];\r\n        headers = headers.set('Content-Type', consumes[0]);\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            body: body == null ? '' : (consumes[0] == 'application/json' ? JSON.stringify(body) : body), // https://github.com/angular/angular/issues/10612\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<any>(RequestMethod.Post, path, requestOptions);\r\n    }\r\n\r\n    /**\r\n     * Use this method to update the currently authenticated user&#39;s information\r\n     * \r\n     * @param body The user information to update\r\n     */\r\n    public updateMyInformationWithHttpInfo(body?: UpdateMeRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<UserResponse>> {\r\n        const path = this.basePath + '/api/v202108/Me';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n            'application/json'\r\n        ];\r\n        headers = headers.set('Content-Type', consumes[0]);\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            body: body == null ? '' : (consumes[0] == 'application/json' ? JSON.stringify(body) : body), // https://github.com/angular/angular/issues/10612\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<UserResponse>(RequestMethod.Put, path, requestOptions);\r\n    }\r\n\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"me.service.js","sourceRoot":"","sources":["../../../api/me.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * EnergyCAP ID SDK\r\n * Document used to generate the EnergyCAP ID SDK\r\n *\r\n * OpenAPI spec version: 1.2112\r\n * Contact: support@energycap.com\r\n *\r\n * NOTE: This class is auto generated by the swagger code generator program.\r\n * https://github.com/swagger-api/swagger-codegen.git\r\n * Do not edit the class manually.\r\n */\r\n\r\n/* tslint:disable:no-unused-variable member-ordering */\r\n\r\nimport { Inject, Injectable, Optional }                      from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams }               from '@angular/common/http';\r\nimport { HttpResponse }                                      from '@angular/common/http';\r\n\r\nimport { Observable }                                        from 'rxjs';\r\nimport { map }                                               from 'rxjs/operators';\r\n\r\nimport { LinkDataSourceRequest } from '../model/linkDataSourceRequest';\r\nimport { NotificationSettingRequest } from '../model/notificationSettingRequest';\r\nimport { UpdateMeRequest } from '../model/updateMeRequest';\r\nimport { UserResponse } from '../model/userResponse';\r\n\r\nimport { BASE_PATH }                                         from '../variables';\r\nimport { COLLECTION_FORMATS }                                from '../variables';\r\n\r\nimport { Configuration }                                     from '../configuration';\r\n\r\nconst RequestMethod = {\r\n    Get: 'get',\r\n    Post: 'post',\r\n    Put: 'put',\r\n    Delete: 'delete',\r\n    Options: 'options',\r\n    Head: 'head',\r\n    Patch: 'patch'\r\n};\r\n\r\n\r\n@Injectable()\r\nexport class MeService {\r\n\r\n    protected basePath = 'https://localhost';\r\n    public defaultHeaders: HttpHeaders = new HttpHeaders();\r\n    public configuration: Configuration = new Configuration();\r\n\r\n    constructor(protected http: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\r\n        if (basePath) {\r\n            this.basePath = basePath;\r\n        }\r\n        if (configuration) {\r\n            this.configuration = configuration;\r\n\t\t\tthis.basePath = basePath || configuration.basePath || this.basePath;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * \r\n     * Extends object by coping non-existing properties.\r\n     * @param objA object to be extended\r\n     * @param objB source object\r\n     */\r\n    private extendObj<T1,T2>(objA: T1, objB: T2) {\r\n        for(let key in objB){\r\n            if(objB.hasOwnProperty(key)){\r\n                (objA as any)[key] = (objB as any)[key];\r\n            }\r\n        }\r\n        return <T1&T2>objA;\r\n    }\r\n\r\n    /**\r\n     * @param consumes string[] mime-types\r\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\r\n     */\r\n    private canConsumeForm(consumes: string[]): boolean {\r\n        const form = 'multipart/form-data';\r\n        for (let consume of consumes) {\r\n            if (form === consume) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Use this method to get information about the currently authenticated user\r\n     * \r\n     */\r\n    public getMe(extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<UserResponse> {\r\n        return this.getMeWithHttpInfo(extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<UserResponse>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n    /**\r\n     * Will allow a user to link to a data source that they don&#39;t have access to based upon their login name\r\n     * \r\n     * @param body Information needed to connect to the data source\r\n     */\r\n    public linkMyUserToDataSource(body?: LinkDataSourceRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<any> {\r\n        return this.linkMyUserToDataSourceWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<any>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n    /**\r\n     * Use this method to update the currently authenticated user&#39;s information\r\n     * \r\n     * @param body The user information to update\r\n     */\r\n    public updateMyInformation(body?: UpdateMeRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<UserResponse> {\r\n        return this.updateMyInformationWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<UserResponse>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n    /**\r\n     * Use this method to update the currently authenticated user&#39;s notification settings\r\n     * \r\n     * @param body The user notification settings to update\r\n     */\r\n    public updateMyNotificationSetting(body?: NotificationSettingRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<UserResponse> {\r\n        return this.updateMyNotificationSettingWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<UserResponse>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n\r\n    /**\r\n     * Use this method to get information about the currently authenticated user\r\n     * \r\n     */\r\n    public getMeWithHttpInfo(extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<UserResponse>> {\r\n        const path = this.basePath + '/api/v202108/Me';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<UserResponse>(RequestMethod.Get, path, requestOptions);\r\n    }\r\n\r\n    /**\r\n     * Will allow a user to link to a data source that they don&#39;t have access to based upon their login name\r\n     * \r\n     * @param body Information needed to connect to the data source\r\n     */\r\n    public linkMyUserToDataSourceWithHttpInfo(body?: LinkDataSourceRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<any>> {\r\n        const path = this.basePath + '/api/v202108/Me/dataSource/link';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n            'application/json'\r\n        ];\r\n        headers = headers.set('Content-Type', consumes[0]);\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            body: body == null ? '' : (consumes[0] == 'application/json' ? JSON.stringify(body) : body), // https://github.com/angular/angular/issues/10612\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<any>(RequestMethod.Post, path, requestOptions);\r\n    }\r\n\r\n    /**\r\n     * Use this method to update the currently authenticated user&#39;s information\r\n     * \r\n     * @param body The user information to update\r\n     */\r\n    public updateMyInformationWithHttpInfo(body?: UpdateMeRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<UserResponse>> {\r\n        const path = this.basePath + '/api/v202108/Me';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n            'application/json'\r\n        ];\r\n        headers = headers.set('Content-Type', consumes[0]);\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            body: body == null ? '' : (consumes[0] == 'application/json' ? JSON.stringify(body) : body), // https://github.com/angular/angular/issues/10612\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<UserResponse>(RequestMethod.Put, path, requestOptions);\r\n    }\r\n\r\n    /**\r\n     * Use this method to update the currently authenticated user&#39;s notification settings\r\n     * \r\n     * @param body The user notification settings to update\r\n     */\r\n    public updateMyNotificationSettingWithHttpInfo(body?: NotificationSettingRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<UserResponse>> {\r\n        const path = this.basePath + '/api/v202108/Me/notificationsetting';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n            'application/json'\r\n        ];\r\n        headers = headers.set('Content-Type', consumes[0]);\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            body: body == null ? '' : (consumes[0] == 'application/json' ? JSON.stringify(body) : body), // https://github.com/angular/angular/issues/10612\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<UserResponse>(RequestMethod.Put, path, requestOptions);\r\n    }\r\n\r\n}\r\n"]}

package/esm2015/api/notification.service.js

@@ -0,0 +1,332 @@
+/**
+ * EnergyCAP ID SDK
+ * Document used to generate the EnergyCAP ID SDK
+ *
+ * OpenAPI spec version: 1.2112
+ * Contact: support@energycap.com
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { BASE_PATH } from '../variables';
+import { Configuration } from '../configuration';
+const RequestMethod = {
+    Get: 'get',
+    Post: 'post',
+    Put: 'put',
+    Delete: 'delete',
+    Options: 'options',
+    Head: 'head',
+    Patch: 'patch'
+};
+export class NotificationService {
+    constructor(http, basePath, configuration) {
+        this.http = http;
+        this.basePath = 'https://localhost';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (basePath) {
+            this.basePath = basePath;
+        }
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = basePath || configuration.basePath || this.basePath;
+        }
+    }
+    /**
+     *
+     * Extends object by coping non-existing properties.
+     * @param objA object to be extended
+     * @param objB source object
+     */
+    extendObj(objA, objB) {
+        for (let key in objB) {
+            if (objB.hasOwnProperty(key)) {
+                objA[key] = objB[key];
+            }
+        }
+        return objA;
+    }
+    /**
+     * @param consumes string[] mime-types
+     * @return true: consumes contains 'multipart/form-data', false: otherwise
+     */
+    canConsumeForm(consumes) {
+        const form = 'multipart/form-data';
+        for (let consume of consumes) {
+            if (form === consume) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get the last 250 notifications for the current user
+     *
+     */
+    getMyNotifications(extraHttpRequestParams, extraHttpRequestHeaders) {
+        return this.getMyNotificationsWithHttpInfo(extraHttpRequestParams, extraHttpRequestHeaders)
+            .pipe(map((response) => {
+            if (response.status === 204) {
+                return undefined;
+            }
+            else {
+                return response.body;
+            }
+        }));
+    }
+    /**
+     * Get a specific notification for the current user
+     *
+     * @param notificationId Id of the notification to get
+     */
+    getNotification(notificationId, extraHttpRequestParams, extraHttpRequestHeaders) {
+        return this.getNotificationWithHttpInfo(notificationId, extraHttpRequestParams, extraHttpRequestHeaders)
+            .pipe(map((response) => {
+            if (response.status === 204) {
+                return undefined;
+            }
+            else {
+                return response.body;
+            }
+        }));
+    }
+    /**
+     * Get total number of notifications that are unread and unarchived for the current user.  Use lastCheckDateTimeUtc to get the number of new notifications since the passed in date and time.  By default, only the latest 250 notifications will be taken into account. Use the 'noLimit' query parameter to override this behavior.
+     *
+     * @param lastCheckDateTimeUtc Used when calculating the number of new notifications. Must be a UTC DateTime in the format yyyy-MM-ddTHH:mm:ssZ. If not passed the TotalNotifications and NewNotifications will be equal.
+     * @param noLimit If true, will return the badge totals for all of the user's notifications, not just the 250 most recent ones
+     */
+    getNotificationBadgeTotals(lastCheckDateTimeUtc, noLimit, extraHttpRequestParams, extraHttpRequestHeaders) {
+        return this.getNotificationBadgeTotalsWithHttpInfo(lastCheckDateTimeUtc, noLimit, extraHttpRequestParams, extraHttpRequestHeaders)
+            .pipe(map((response) => {
+            if (response.status === 204) {
+                return undefined;
+            }
+            else {
+                return response.body;
+            }
+        }));
+    }
+    /**
+     * Update a list of notifications based on the notification ids and action passed in  Only notifications for the current user can be updated
+     *
+     * @param body List of notification ids and action to perform
+     */
+    updateListOfNotifications(body, extraHttpRequestParams, extraHttpRequestHeaders) {
+        return this.updateListOfNotificationsWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders)
+            .pipe(map((response) => {
+            if (response.status === 204) {
+                return undefined;
+            }
+            else {
+                return response.body;
+            }
+        }));
+    }
+    /**
+     * Get the last 250 notifications for the current user
+     *
+     */
+    getMyNotificationsWithHttpInfo(extraHttpRequestParams, extraHttpRequestHeaders) {
+        const path = this.basePath + '/api/v202111/Notification';
+        let queryParameters;
+        if (extraHttpRequestParams) {
+            if (typeof extraHttpRequestParams.search === 'string') {
+                queryParameters = new HttpParams({ fromString: extraHttpRequestParams.search });
+            }
+            else {
+                queryParameters = new HttpParams({ fromObject: extraHttpRequestParams.search });
+            }
+        }
+        else {
+            queryParameters = new HttpParams();
+        }
+        let headers = new HttpHeaders();
+        this.defaultHeaders.keys().forEach(key => {
+            headers = headers.set(key, this.defaultHeaders.getAll(key));
+        });
+        if (extraHttpRequestHeaders) {
+            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {
+                headers = headers.set(key, value);
+            });
+        }
+        // to determine the Accept header
+        let produces = [
+            'application/json'
+        ];
+        if (this.configuration.apiKeys["Authorization"]) {
+            headers = headers.set('Authorization', this.configuration.apiKeys["Authorization"]);
+        }
+        const consumes = [];
+        let requestOptions = {
+            headers: headers,
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            observe: 'response'
+        };
+        return this.http.request(RequestMethod.Get, path, requestOptions);
+    }
+    /**
+     * Get a specific notification for the current user
+     *
+     * @param notificationId Id of the notification to get
+     */
+    getNotificationWithHttpInfo(notificationId, extraHttpRequestParams, extraHttpRequestHeaders) {
+        const path = this.basePath + '/api/v202111/Notification/${notificationId}'
+            .replace('${' + 'notificationId' + '}', String(notificationId));
+        let queryParameters;
+        if (extraHttpRequestParams) {
+            if (typeof extraHttpRequestParams.search === 'string') {
+                queryParameters = new HttpParams({ fromString: extraHttpRequestParams.search });
+            }
+            else {
+                queryParameters = new HttpParams({ fromObject: extraHttpRequestParams.search });
+            }
+        }
+        else {
+            queryParameters = new HttpParams();
+        }
+        let headers = new HttpHeaders();
+        this.defaultHeaders.keys().forEach(key => {
+            headers = headers.set(key, this.defaultHeaders.getAll(key));
+        });
+        if (extraHttpRequestHeaders) {
+            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {
+                headers = headers.set(key, value);
+            });
+        }
+        // verify required parameter 'notificationId' is not null or undefined
+        if (notificationId === null || notificationId === undefined) {
+            throw new Error('Required parameter notificationId was null or undefined when calling getNotification.');
+        }
+        // to determine the Accept header
+        let produces = [
+            'application/json'
+        ];
+        if (this.configuration.apiKeys["Authorization"]) {
+            headers = headers.set('Authorization', this.configuration.apiKeys["Authorization"]);
+        }
+        const consumes = [];
+        let requestOptions = {
+            headers: headers,
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            observe: 'response'
+        };
+        return this.http.request(RequestMethod.Get, path, requestOptions);
+    }
+    /**
+     * Get total number of notifications that are unread and unarchived for the current user.  Use lastCheckDateTimeUtc to get the number of new notifications since the passed in date and time.  By default, only the latest 250 notifications will be taken into account. Use the 'noLimit' query parameter to override this behavior.
+     *
+     * @param lastCheckDateTimeUtc Used when calculating the number of new notifications. Must be a UTC DateTime in the format yyyy-MM-ddTHH:mm:ssZ. If not passed the TotalNotifications and NewNotifications will be equal.
+     * @param noLimit If true, will return the badge totals for all of the user's notifications, not just the 250 most recent ones
+     */
+    getNotificationBadgeTotalsWithHttpInfo(lastCheckDateTimeUtc, noLimit, extraHttpRequestParams, extraHttpRequestHeaders) {
+        const path = this.basePath + '/api/v202111/Notification/badge';
+        let queryParameters;
+        if (extraHttpRequestParams) {
+            if (typeof extraHttpRequestParams.search === 'string') {
+                queryParameters = new HttpParams({ fromString: extraHttpRequestParams.search });
+            }
+            else {
+                queryParameters = new HttpParams({ fromObject: extraHttpRequestParams.search });
+            }
+        }
+        else {
+            queryParameters = new HttpParams();
+        }
+        let headers = new HttpHeaders();
+        this.defaultHeaders.keys().forEach(key => {
+            headers = headers.set(key, this.defaultHeaders.getAll(key));
+        });
+        if (extraHttpRequestHeaders) {
+            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {
+                headers = headers.set(key, value);
+            });
+        }
+        if (lastCheckDateTimeUtc !== undefined) {
+            queryParameters = queryParameters.set('lastCheckDateTimeUtc', lastCheckDateTimeUtc.toISOString());
+        }
+        if (noLimit !== undefined) {
+            queryParameters = queryParameters.set('noLimit', noLimit);
+        }
+        // to determine the Accept header
+        let produces = [
+            'application/json'
+        ];
+        if (this.configuration.apiKeys["Authorization"]) {
+            headers = headers.set('Authorization', this.configuration.apiKeys["Authorization"]);
+        }
+        const consumes = [];
+        let requestOptions = {
+            headers: headers,
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            observe: 'response'
+        };
+        return this.http.request(RequestMethod.Get, path, requestOptions);
+    }
+    /**
+     * Update a list of notifications based on the notification ids and action passed in  Only notifications for the current user can be updated
+     *
+     * @param body List of notification ids and action to perform
+     */
+    updateListOfNotificationsWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders) {
+        const path = this.basePath + '/api/v202111/Notification';
+        let queryParameters;
+        if (extraHttpRequestParams) {
+            if (typeof extraHttpRequestParams.search === 'string') {
+                queryParameters = new HttpParams({ fromString: extraHttpRequestParams.search });
+            }
+            else {
+                queryParameters = new HttpParams({ fromObject: extraHttpRequestParams.search });
+            }
+        }
+        else {
+            queryParameters = new HttpParams();
+        }
+        let headers = new HttpHeaders();
+        this.defaultHeaders.keys().forEach(key => {
+            headers = headers.set(key, this.defaultHeaders.getAll(key));
+        });
+        if (extraHttpRequestHeaders) {
+            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {
+                headers = headers.set(key, value);
+            });
+        }
+        // to determine the Accept header
+        let produces = [
+            'application/json'
+        ];
+        if (this.configuration.apiKeys["Authorization"]) {
+            headers = headers.set('Authorization', this.configuration.apiKeys["Authorization"]);
+        }
+        const consumes = [
+            'application/json'
+        ];
+        headers = headers.set('Content-Type', consumes[0]);
+        let requestOptions = {
+            headers: headers,
+            body: body == null ? '' : (consumes[0] == 'application/json' ? JSON.stringify(body) : body),
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            observe: 'response'
+        };
+        return this.http.request(RequestMethod.Put, path, requestOptions);
+    }
+}
+NotificationService.decorators = [
+    { type: Injectable }
+];
+NotificationService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [BASE_PATH,] }] },
+    { type: Configuration, decorators: [{ type: Optional }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.service.js","sourceRoot":"","sources":["../../../api/notification.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * EnergyCAP ID SDK\r\n * Document used to generate the EnergyCAP ID SDK\r\n *\r\n * OpenAPI spec version: 1.2112\r\n * Contact: support@energycap.com\r\n *\r\n * NOTE: This class is auto generated by the swagger code generator program.\r\n * https://github.com/swagger-api/swagger-codegen.git\r\n * Do not edit the class manually.\r\n */\r\n\r\n/* tslint:disable:no-unused-variable member-ordering */\r\n\r\nimport { Inject, Injectable, Optional }                      from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams }               from '@angular/common/http';\r\nimport { HttpResponse }                                      from '@angular/common/http';\r\n\r\nimport { Observable }                                        from 'rxjs';\r\nimport { map }                                               from 'rxjs/operators';\r\n\r\nimport { NotificationBadgeResponse } from '../model/notificationBadgeResponse';\r\nimport { NotificationResponse } from '../model/notificationResponse';\r\nimport { NotificationUpdateRequest } from '../model/notificationUpdateRequest';\r\nimport { UpdateResult } from '../model/updateResult';\r\n\r\nimport { BASE_PATH }                                         from '../variables';\r\nimport { COLLECTION_FORMATS }                                from '../variables';\r\n\r\nimport { Configuration }                                     from '../configuration';\r\n\r\nconst RequestMethod = {\r\n    Get: 'get',\r\n    Post: 'post',\r\n    Put: 'put',\r\n    Delete: 'delete',\r\n    Options: 'options',\r\n    Head: 'head',\r\n    Patch: 'patch'\r\n};\r\n\r\n\r\n@Injectable()\r\nexport class NotificationService {\r\n\r\n    protected basePath = 'https://localhost';\r\n    public defaultHeaders: HttpHeaders = new HttpHeaders();\r\n    public configuration: Configuration = new Configuration();\r\n\r\n    constructor(protected http: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\r\n        if (basePath) {\r\n            this.basePath = basePath;\r\n        }\r\n        if (configuration) {\r\n            this.configuration = configuration;\r\n\t\t\tthis.basePath = basePath || configuration.basePath || this.basePath;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * \r\n     * Extends object by coping non-existing properties.\r\n     * @param objA object to be extended\r\n     * @param objB source object\r\n     */\r\n    private extendObj<T1,T2>(objA: T1, objB: T2) {\r\n        for(let key in objB){\r\n            if(objB.hasOwnProperty(key)){\r\n                (objA as any)[key] = (objB as any)[key];\r\n            }\r\n        }\r\n        return <T1&T2>objA;\r\n    }\r\n\r\n    /**\r\n     * @param consumes string[] mime-types\r\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\r\n     */\r\n    private canConsumeForm(consumes: string[]): boolean {\r\n        const form = 'multipart/form-data';\r\n        for (let consume of consumes) {\r\n            if (form === consume) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Get the last 250 notifications for the current user\r\n     * \r\n     */\r\n    public getMyNotifications(extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<Array<NotificationResponse>> {\r\n        return this.getMyNotificationsWithHttpInfo(extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<Array<NotificationResponse>>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n    /**\r\n     * Get a specific notification for the current user\r\n     * \r\n     * @param notificationId Id of the notification to get\r\n     */\r\n    public getNotification(notificationId: string, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<NotificationResponse> {\r\n        return this.getNotificationWithHttpInfo(notificationId, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<NotificationResponse>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n    /**\r\n     * Get total number of notifications that are unread and unarchived for the current user.  Use lastCheckDateTimeUtc to get the number of new notifications since the passed in date and time.  By default, only the latest 250 notifications will be taken into account. Use the &#39;noLimit&#39; query parameter to override this behavior.\r\n     * \r\n     * @param lastCheckDateTimeUtc Used when calculating the number of new notifications. Must be a UTC DateTime in the format yyyy-MM-ddTHH:mm:ssZ. If not passed the TotalNotifications and NewNotifications will be equal.\r\n     * @param noLimit If true, will return the badge totals for all of the user&#39;s notifications, not just the 250 most recent ones\r\n     */\r\n    public getNotificationBadgeTotals(lastCheckDateTimeUtc?: Date, noLimit?: boolean, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<NotificationBadgeResponse> {\r\n        return this.getNotificationBadgeTotalsWithHttpInfo(lastCheckDateTimeUtc, noLimit, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<NotificationBadgeResponse>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n    /**\r\n     * Update a list of notifications based on the notification ids and action passed in  Only notifications for the current user can be updated\r\n     * \r\n     * @param body List of notification ids and action to perform\r\n     */\r\n    public updateListOfNotifications(body?: NotificationUpdateRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<UpdateResult> {\r\n        return this.updateListOfNotificationsWithHttpInfo(body, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<UpdateResult>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n\r\n    /**\r\n     * Get the last 250 notifications for the current user\r\n     * \r\n     */\r\n    public getMyNotificationsWithHttpInfo(extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<Array<NotificationResponse>>> {\r\n        const path = this.basePath + '/api/v202111/Notification';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<Array<NotificationResponse>>(RequestMethod.Get, path, requestOptions);\r\n    }\r\n\r\n    /**\r\n     * Get a specific notification for the current user\r\n     * \r\n     * @param notificationId Id of the notification to get\r\n     */\r\n    public getNotificationWithHttpInfo(notificationId: string, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<NotificationResponse>> {\r\n        const path = this.basePath + '/api/v202111/Notification/${notificationId}'\r\n                    .replace('${' + 'notificationId' + '}', String(notificationId));\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n        // verify required parameter 'notificationId' is not null or undefined\r\n        if (notificationId === null || notificationId === undefined) {\r\n            throw new Error('Required parameter notificationId was null or undefined when calling getNotification.');\r\n        }\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<NotificationResponse>(RequestMethod.Get, path, requestOptions);\r\n    }\r\n\r\n    /**\r\n     * Get total number of notifications that are unread and unarchived for the current user.  Use lastCheckDateTimeUtc to get the number of new notifications since the passed in date and time.  By default, only the latest 250 notifications will be taken into account. Use the &#39;noLimit&#39; query parameter to override this behavior.\r\n     * \r\n     * @param lastCheckDateTimeUtc Used when calculating the number of new notifications. Must be a UTC DateTime in the format yyyy-MM-ddTHH:mm:ssZ. If not passed the TotalNotifications and NewNotifications will be equal.\r\n     * @param noLimit If true, will return the badge totals for all of the user&#39;s notifications, not just the 250 most recent ones\r\n     */\r\n    public getNotificationBadgeTotalsWithHttpInfo(lastCheckDateTimeUtc?: Date, noLimit?: boolean, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<NotificationBadgeResponse>> {\r\n        const path = this.basePath + '/api/v202111/Notification/badge';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n        if (lastCheckDateTimeUtc !== undefined) {\r\n            queryParameters = queryParameters.set('lastCheckDateTimeUtc', <any>lastCheckDateTimeUtc.toISOString());\r\n        }\r\n\r\n        if (noLimit !== undefined) {\r\n            queryParameters = queryParameters.set('noLimit', <any>noLimit);\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<NotificationBadgeResponse>(RequestMethod.Get, path, requestOptions);\r\n    }\r\n\r\n    /**\r\n     * Update a list of notifications based on the notification ids and action passed in  Only notifications for the current user can be updated\r\n     * \r\n     * @param body List of notification ids and action to perform\r\n     */\r\n    public updateListOfNotificationsWithHttpInfo(body?: NotificationUpdateRequest, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<UpdateResult>> {\r\n        const path = this.basePath + '/api/v202111/Notification';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n            'application/json'\r\n        ];\r\n        headers = headers.set('Content-Type', consumes[0]);\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            body: body == null ? '' : (consumes[0] == 'application/json' ? JSON.stringify(body) : body), // https://github.com/angular/angular/issues/10612\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<UpdateResult>(RequestMethod.Put, path, requestOptions);\r\n    }\r\n\r\n}\r\n"]}