Cleaned code

src/app/components/password-form/password-form.component.ts

@@ -72,8 +72,6 @@ export class PasswordFormComponent {
             });
             await loading2.dismiss();
             await toast.present();
-
-            console.log(error.message);
         }
     }
 }

src/app/components/sign-on-form/sign-on-form.component.html

@@ -1,26 +1,36 @@
 <form [formGroup]="userForm">
     <ion-item lines="none">
-        <ion-label position="stacked">Prénom <ion-text color="danger">*</ion-text></ion-label>
+        <ion-label position="stacked">Prénom
+            <ion-text color="danger">*</ion-text>
+        </ion-label>
         <ion-input placeholder="Prénom" [clearInput]="true" formControlName="firstName"></ion-input>
     </ion-item>
 
     <ion-item lines="none">
-        <ion-label position="stacked">Nom <ion-text color="danger">*</ion-text></ion-label>
+        <ion-label position="stacked">Nom
+            <ion-text color="danger">*</ion-text>
+        </ion-label>
         <ion-input placeholder="Nom de famille" [clearInput]="true" formControlName="name"></ion-input>
     </ion-item>
 
     <ion-item lines="none">
-        <ion-label position="stacked">Pseudo <ion-text color="danger">*</ion-text></ion-label>
+        <ion-label position="stacked">Pseudo
+            <ion-text color="danger">*</ion-text>
+        </ion-label>
         <ion-input placeholder="Nom d'utilisateur" [clearInput]="true" formControlName="username"></ion-input>
     </ion-item>
 
     <ion-item lines="none">
-        <ion-label position="stacked">Adresse email <ion-text color="danger">*</ion-text></ion-label>
+        <ion-label position="stacked">Adresse email
+            <ion-text color="danger">*</ion-text>
+        </ion-label>
         <ion-input placeholder="Email" [clearInput]="true" formControlName="email"></ion-input>
     </ion-item>
 
     <ion-item lines="none">
-        <ion-label position="stacked">Mot de passe <ion-text color="danger">*</ion-text></ion-label>
+        <ion-label position="stacked">Mot de passe
+            <ion-text color="danger">*</ion-text>
+        </ion-label>
         <ion-input type="password" placeholder="MotDePasse1234" [clearInput]="true" formControlName="password">
             <ion-input-password-toggle slot="end"></ion-input-password-toggle>
         </ion-input>

src/app/services/api/README.md

@@ -73,7 +73,9 @@ export const appConfig: ApplicationConfig = {
 ```
 
 **NOTE**
-If you're still using `AppModule` and haven't [migrated](https://angular.dev/reference/migrations/standalone) yet, you can still import an Angular module:
+If you're still using `AppModule` and haven't [migrated](https://angular.dev/reference/migrations/standalone) yet, you
+can still import an Angular module:
+
 ```typescript
 import { ApiModule } from '';
 ```
@@ -181,5 +183,7 @@ new Configuration({
 ```
 
 [parameter-locations-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-locations
+
 [style-values-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values
+
 [@honoluluhenk/http-param-expander]: https://www.npmjs.com/package/@honoluluhenk/http-param-expander

src/app/services/api/api/achievements.service.ts

@@ -10,7 +10,8 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import {Inject, Injectable, Optional} from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams,
+import {
+    HttpClient, HttpHeaders, HttpParams,
     HttpResponse, HttpEvent, HttpContext
 } from '@angular/common/http';
 import {Observable} from 'rxjs';
@@ -27,7 +28,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';
 
 
-
 @Injectable({
     providedIn: 'root'
 })
@@ -43,10 +43,26 @@ export class AchievementsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAchievementDto>>;
+    public getAllAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAchievementDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAchievementDto>>>;
+        context?: HttpContext,
-    public getAllAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetAchievementDto>>;
+    public getAllAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetAchievementDto>>>;
+    public getAllAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetAchievementDto>>>;
+    public getAllAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -97,10 +113,26 @@ export class AchievementsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getLockedAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAchievementDto>>;
+    public getLockedAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getLockedAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAchievementDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getLockedAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAchievementDto>>>;
+        context?: HttpContext,
-    public getLockedAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetAchievementDto>>;
+    public getLockedAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetAchievementDto>>>;
+    public getLockedAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetAchievementDto>>>;
+    public getLockedAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -151,10 +183,26 @@ export class AchievementsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getUserAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAchievementDto>>;
+    public getUserAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getUserAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAchievementDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getUserAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAchievementDto>>>;
+        context?: HttpContext,
-    public getUserAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetAchievementDto>>;
+    public getUserAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetAchievementDto>>>;
+    public getUserAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetAchievementDto>>>;
+    public getUserAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -206,10 +254,26 @@ export class AchievementsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: 'application/problem+json',
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public unlockAchievementEndpoint(achievementId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public unlockAchievementEndpoint(achievementId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (achievementId === null || achievementId === undefined) {
             throw new Error('Required parameter achievementId was null or undefined when calling unlockAchievementEndpoint.');
         }
@@ -242,7 +306,15 @@ export class AchievementsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Achievements/${this.configuration.encodeParam({name: "achievementId", value: achievementId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users`;
+        let localVarPath = `/API/Achievements/${this.configuration.encodeParam({
+            name: "achievementId",
+            value: achievementId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Users`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {

src/app/services/api/api/api.ts

@@ -1,19 +1,28 @@
 export * from './achievements.service';
 import {AchievementsService} from './achievements.service';
+
 export * from './auth.service';
 import {AuthService} from './auth.service';
+
 export * from './designations.service';
 import {DesignationsService} from './designations.service';
+
 export * from './friends.service';
 import {FriendsService} from './friends.service';
+
 export * from './groups.service';
 import {GroupsService} from './groups.service';
+
 export * from './messages.service';
 import {MessagesService} from './messages.service';
+
 export * from './overallranking.service';
 import {OverallrankingService} from './overallranking.service';
+
 export * from './randomchallenges.service';
 import {RandomchallengesService} from './randomchallenges.service';
+
 export * from './users.service';
 import {UsersService} from './users.service';
+
 export const APIS = [AchievementsService, AuthService, DesignationsService, FriendsService, GroupsService, MessagesService, OverallrankingService, RandomchallengesService, UsersService];

src/app/services/api/api/auth.service.ts

@@ -10,7 +10,8 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import {Inject, Injectable, Optional} from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams,
+import {
+    HttpClient, HttpHeaders, HttpParams,
     HttpResponse, HttpEvent, HttpContext
 } from '@angular/common/http';
 import {Observable} from 'rxjs';
@@ -31,7 +32,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';
 
 
-
 @Injectable({
     providedIn: 'root'
 })
@@ -48,10 +48,26 @@ export class AuthService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public loginEndpoint(loginDto: LoginDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<GetTokenDto>;
+    public loginEndpoint(loginDto: LoginDto, observe?: 'body', reportProgress?: boolean, options?: {
-    public loginEndpoint(loginDto: LoginDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetTokenDto>>;
+        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-    public loginEndpoint(loginDto: LoginDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetTokenDto>>;
+        context?: HttpContext,
-    public loginEndpoint(loginDto: LoginDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<GetTokenDto>;
+    public loginEndpoint(loginDto: LoginDto, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json' | 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<GetTokenDto>>;
+    public loginEndpoint(loginDto: LoginDto, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json' | 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<GetTokenDto>>;
+    public loginEndpoint(loginDto: LoginDto, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json' | 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (loginDto === null || loginDto === undefined) {
             throw new Error('Required parameter loginDto was null or undefined when calling loginEndpoint.');
         }
@@ -114,10 +130,26 @@ export class AuthService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<GetTokenDto>;
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'body', reportProgress?: boolean, options?: {
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetTokenDto>>;
+        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetTokenDto>>;
+        context?: HttpContext,
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<GetTokenDto>;
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json' | 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<GetTokenDto>>;
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json' | 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<GetTokenDto>>;
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json' | 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (refreshTokenDto === null || refreshTokenDto === undefined) {
             throw new Error('Required parameter refreshTokenDto was null or undefined when calling refreshTokenEndpoint.');
         }

src/app/services/api/api/designations.service.ts

@@ -10,7 +10,8 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import {Inject, Injectable, Optional} from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams,
+import {
+    HttpClient, HttpHeaders, HttpParams,
     HttpResponse, HttpEvent, HttpContext
 } from '@angular/common/http';
 import {Observable} from 'rxjs';
@@ -25,7 +26,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';
 
 
-
 @Injectable({
     providedIn: 'root'
 })
@@ -41,10 +41,26 @@ export class DesignationsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllDesignationsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetDesignationDto>>;
+    public getAllDesignationsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllDesignationsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetDesignationDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllDesignationsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetDesignationDto>>>;
+        context?: HttpContext,
-    public getAllDesignationsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetDesignationDto>>;
+    public getAllDesignationsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetDesignationDto>>>;
+    public getAllDesignationsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetDesignationDto>>>;
+    public getAllDesignationsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 

src/app/services/api/api/friends.service.ts

@@ -10,7 +10,8 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import {Inject, Injectable, Optional} from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams,
+import {
+    HttpClient, HttpHeaders, HttpParams,
     HttpResponse, HttpEvent, HttpContext
 } from '@angular/common/http';
 import {Observable} from 'rxjs';
@@ -27,7 +28,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';
 
 
-
 @Injectable({
     providedIn: 'root'
 })
@@ -44,10 +44,26 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public acceptFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public acceptFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling acceptFriendRequestEndpoint.');
         }
@@ -57,8 +73,7 @@ export class FriendsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -79,7 +94,15 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Request`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
+            name: "friendId",
+            value: friendId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Request`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('put', `${basePath}${localVarPath}`,
             {
@@ -101,10 +124,26 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteFriendEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteFriendEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public deleteFriendEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public deleteFriendEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public deleteFriendEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public deleteFriendEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public deleteFriendEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public deleteFriendEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling deleteFriendEndpoint.');
         }
@@ -114,8 +153,7 @@ export class FriendsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -136,7 +174,15 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
+            name: "friendId",
+            value: friendId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -157,10 +203,26 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllFriendRequestsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetFriendRequestDto>>;
+    public getAllFriendRequestsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllFriendRequestsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetFriendRequestDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllFriendRequestsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetFriendRequestDto>>>;
+        context?: HttpContext,
-    public getAllFriendRequestsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetFriendRequestDto>>;
+    public getAllFriendRequestsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetFriendRequestDto>>>;
+    public getAllFriendRequestsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetFriendRequestDto>>>;
+    public getAllFriendRequestsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -211,10 +273,26 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllFriendsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetFriendDto>>;
+    public getAllFriendsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllFriendsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetFriendDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllFriendsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetFriendDto>>>;
+        context?: HttpContext,
-    public getAllFriendsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetFriendDto>>;
+    public getAllFriendsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetFriendDto>>>;
+    public getAllFriendsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetFriendDto>>>;
+    public getAllFriendsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -266,10 +344,26 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public rejectFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public rejectFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling rejectFriendRequestEndpoint.');
         }
@@ -279,8 +373,7 @@ export class FriendsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -301,7 +394,15 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Request`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
+            name: "friendId",
+            value: friendId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Request`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -323,10 +424,26 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public sendFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public sendFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public sendFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public sendFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public sendFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling sendFriendRequestEndpoint.');
         }
@@ -336,8 +453,7 @@ export class FriendsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -358,7 +474,15 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
+            name: "friendId",
+            value: friendId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {

src/app/services/api/api/groups.service.ts

@@ -10,7 +10,8 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import {Inject, Injectable, Optional} from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams,
+import {
+    HttpClient, HttpHeaders, HttpParams,
     HttpResponse, HttpEvent, HttpContext
 } from '@angular/common/http';
 import {Observable} from 'rxjs';
@@ -41,7 +42,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';
 
 
-
 @Injectable({
     providedIn: 'root'
 })
@@ -59,10 +59,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public addUserToGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling addUserToGroupEndpoint.');
         }
@@ -75,8 +91,7 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -97,7 +112,23 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users/${this.configuration.encodeParam({name: "userId", value: userId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "groupId",
+            value: groupId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Users/${this.configuration.encodeParam({
+            name: "userId",
+            value: userId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {
@@ -119,10 +150,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'body', reportProgress?: boolean, options?: {
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: 'application/problem+json',
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (createGroupDto === null || createGroupDto === undefined) {
             throw new Error('Required parameter createGroupDto was null or undefined when calling createGroupEndpoint.');
         }
@@ -187,10 +234,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public deleteGroupEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public deleteGroupEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public deleteGroupEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public deleteGroupEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public deleteGroupEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public deleteGroupEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling deleteGroupEndpoint.');
         }
@@ -200,8 +263,7 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -222,7 +284,15 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "id",
+            value: id,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -245,10 +315,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling deleteUserFromGroupEndpoint.');
         }
@@ -261,8 +347,7 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -283,7 +368,23 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users/${this.configuration.encodeParam({name: "userId", value: userId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "groupId",
+            value: groupId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Users/${this.configuration.encodeParam({
+            name: "userId",
+            value: userId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -305,10 +406,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllGroupUsersEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserGroupDto>>;
+    public getAllGroupUsersEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllGroupUsersEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserGroupDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllGroupUsersEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserGroupDto>>>;
+        context?: HttpContext,
-    public getAllGroupUsersEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetUserGroupDto>>;
+    public getAllGroupUsersEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetUserGroupDto>>>;
+    public getAllGroupUsersEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetUserGroupDto>>>;
+    public getAllGroupUsersEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getAllGroupUsersEndpoint.');
         }
@@ -341,7 +458,15 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "id",
+            value: id,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Users`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<Array<GetUserGroupDto>>('get', `${basePath}${localVarPath}`,
             {
@@ -362,10 +487,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllGroupsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetGroupDto>>;
+    public getAllGroupsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllGroupsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetGroupDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllGroupsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetGroupDto>>>;
+        context?: HttpContext,
-    public getAllGroupsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetGroupDto>>;
+    public getAllGroupsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetGroupDto>>>;
+    public getAllGroupsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetGroupDto>>>;
+    public getAllGroupsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -417,10 +558,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllProofsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetProofDto>>;
+    public getAllProofsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllProofsEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetProofDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllProofsEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetProofDto>>>;
+        context?: HttpContext,
-    public getAllProofsEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetProofDto>>;
+    public getAllProofsEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetProofDto>>>;
+    public getAllProofsEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetProofDto>>>;
+    public getAllProofsEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getAllProofsEndpoint.');
         }
@@ -453,7 +610,15 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Proofs`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "id",
+            value: id,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Proofs`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<Array<GetProofDto>>('get', `${basePath}${localVarPath}`,
             {
@@ -475,10 +640,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getGroupDetailsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetGroupDetailsDto>;
+    public getGroupDetailsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public getGroupDetailsEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetGroupDetailsDto>>;
+        httpHeaderAccept?: 'application/json',
-    public getGroupDetailsEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetGroupDetailsDto>>;
+        context?: HttpContext,
-    public getGroupDetailsEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<GetGroupDetailsDto>;
+    public getGroupDetailsEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<GetGroupDetailsDto>>;
+    public getGroupDetailsEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<GetGroupDetailsDto>>;
+    public getGroupDetailsEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getGroupDetailsEndpoint.');
         }
@@ -511,7 +692,15 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "id",
+            value: id,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<GetGroupDetailsDto>('get', `${basePath}${localVarPath}`,
             {
@@ -533,10 +722,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getGroupRankingEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetGroupRankingDto>>;
+    public getGroupRankingEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public getGroupRankingEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetGroupRankingDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getGroupRankingEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetGroupRankingDto>>>;
+        context?: HttpContext,
-    public getGroupRankingEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetGroupRankingDto>>;
+    public getGroupRankingEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetGroupRankingDto>>>;
+    public getGroupRankingEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetGroupRankingDto>>>;
+    public getGroupRankingEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getGroupRankingEndpoint.');
         }
@@ -569,7 +774,15 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/GroupRank`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "id",
+            value: id,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/GroupRank`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<Array<GetGroupRankingDto>>('get', `${basePath}${localVarPath}`,
             {
@@ -591,10 +804,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchGroupStatusEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchGroupStatusEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public patchGroupStatusEndpoint(groupId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public patchGroupStatusEndpoint(groupId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public patchGroupStatusEndpoint(groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public patchGroupStatusEndpoint(groupId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public patchGroupStatusEndpoint(groupId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public patchGroupStatusEndpoint(groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling patchGroupStatusEndpoint.');
         }
@@ -604,8 +833,7 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -626,7 +854,15 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Status`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "groupId",
+            value: groupId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Status`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`,
             {
@@ -649,10 +885,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchGroupUserProofEndpoint(groupId: number, userProofRequest: UserProofRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchGroupUserProofEndpoint(groupId: number, userProofRequest: UserProofRequest, observe?: 'body', reportProgress?: boolean, options?: {
-    public patchGroupUserProofEndpoint(groupId: number, userProofRequest: UserProofRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public patchGroupUserProofEndpoint(groupId: number, userProofRequest: UserProofRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public patchGroupUserProofEndpoint(groupId: number, userProofRequest: UserProofRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public patchGroupUserProofEndpoint(groupId: number, userProofRequest: UserProofRequest, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public patchGroupUserProofEndpoint(groupId: number, userProofRequest: UserProofRequest, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public patchGroupUserProofEndpoint(groupId: number, userProofRequest: UserProofRequest, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling patchGroupUserProofEndpoint.');
         }
@@ -665,8 +917,7 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -696,7 +947,15 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users/Proof`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "groupId",
+            value: groupId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Users/Proof`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`,
             {
@@ -720,10 +979,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling patchGroupUserRoleEndpoint.');
         }
@@ -736,8 +1011,7 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -758,7 +1032,23 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users/${this.configuration.encodeParam({name: "userId", value: userId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Role`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "groupId",
+            value: groupId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Users/${this.configuration.encodeParam({
+            name: "userId",
+            value: userId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Role`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`,
             {
@@ -781,10 +1071,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchVoteEndpoint(groupId: number, userVoteRequest: UserVoteRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchVoteEndpoint(groupId: number, userVoteRequest: UserVoteRequest, observe?: 'body', reportProgress?: boolean, options?: {
-    public patchVoteEndpoint(groupId: number, userVoteRequest: UserVoteRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public patchVoteEndpoint(groupId: number, userVoteRequest: UserVoteRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public patchVoteEndpoint(groupId: number, userVoteRequest: UserVoteRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public patchVoteEndpoint(groupId: number, userVoteRequest: UserVoteRequest, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public patchVoteEndpoint(groupId: number, userVoteRequest: UserVoteRequest, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public patchVoteEndpoint(groupId: number, userVoteRequest: UserVoteRequest, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling patchVoteEndpoint.');
         }
@@ -797,8 +1103,7 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -828,7 +1133,15 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users/Vote`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "groupId",
+            value: groupId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Users/Vote`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`,
             {
@@ -851,10 +1164,26 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public startVoteEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public startVoteEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public startVoteEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public startVoteEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public startVoteEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public startVoteEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public startVoteEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public startVoteEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling startVoteEndpoint.');
         }
@@ -864,8 +1193,7 @@ export class GroupsService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -886,7 +1214,15 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Vote`;
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+            name: "id",
+            value: id,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Vote`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {

src/app/services/api/api/messages.service.ts

@@ -10,7 +10,8 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import {Inject, Injectable, Optional} from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams,
+import {
+    HttpClient, HttpHeaders, HttpParams,
     HttpResponse, HttpEvent, HttpContext
 } from '@angular/common/http';
 import {Observable} from 'rxjs';
@@ -29,7 +30,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';
 
 
-
 @Injectable({
     providedIn: 'root'
 })
@@ -47,10 +47,26 @@ export class MessagesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public deleteMessageEndpoint(id: number, groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public deleteMessageEndpoint(id: number, groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling deleteMessageEndpoint.');
         }
@@ -63,8 +79,7 @@ export class MessagesService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -85,7 +100,23 @@ export class MessagesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Messages/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Messages/${this.configuration.encodeParam({
+            name: "id",
+            value: id,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Groups/${this.configuration.encodeParam({
+            name: "groupId",
+            value: groupId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
@@ -107,10 +138,26 @@ export class MessagesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getMessagesEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetMessageDto>>;
+    public getMessagesEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public getMessagesEndpoint(groupId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetMessageDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getMessagesEndpoint(groupId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetMessageDto>>>;
+        context?: HttpContext,
-    public getMessagesEndpoint(groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetMessageDto>>;
+    public getMessagesEndpoint(groupId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetMessageDto>>>;
+    public getMessagesEndpoint(groupId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetMessageDto>>>;
+    public getMessagesEndpoint(groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling getMessagesEndpoint.');
         }
@@ -143,7 +190,15 @@ export class MessagesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({
+            name: "groupId",
+            value: groupId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<Array<GetMessageDto>>('get', `${basePath}${localVarPath}`,
             {
@@ -166,10 +221,26 @@ export class MessagesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'body', reportProgress?: boolean, options?: {
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: 'application/problem+json',
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (groupId === null || groupId === undefined) {
             throw new Error('Required parameter groupId was null or undefined when calling sendMessageEndpoint.');
         }
@@ -214,7 +285,15 @@ export class MessagesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({
+            name: "groupId",
+            value: groupId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {

src/app/services/api/api/overallranking.service.ts

@@ -10,7 +10,8 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import {Inject, Injectable, Optional} from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams,
+import {
+    HttpClient, HttpHeaders, HttpParams,
     HttpResponse, HttpEvent, HttpContext
 } from '@angular/common/http';
 import {Observable} from 'rxjs';
@@ -25,7 +26,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';
 
 
-
 @Injectable({
     providedIn: 'root'
 })
@@ -41,10 +41,26 @@ export class OverallrankingService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getOverallRankingEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserDto>>;
+    public getOverallRankingEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getOverallRankingEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getOverallRankingEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserDto>>>;
+        context?: HttpContext,
-    public getOverallRankingEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetUserDto>>;
+    public getOverallRankingEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetUserDto>>>;
+    public getOverallRankingEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetUserDto>>>;
+    public getOverallRankingEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 

src/app/services/api/api/randomchallenges.service.ts

@@ -10,7 +10,8 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import {Inject, Injectable, Optional} from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams,
+import {
+    HttpClient, HttpHeaders, HttpParams,
     HttpResponse, HttpEvent, HttpContext
 } from '@angular/common/http';
 import {Observable} from 'rxjs';
@@ -25,7 +26,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';
 
 
-
 @Injectable({
     providedIn: 'root'
 })
@@ -41,10 +41,26 @@ export class RandomchallengesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public generateRandomChallengeEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetRandomChallengeDto>;
+    public generateRandomChallengeEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public generateRandomChallengeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetRandomChallengeDto>>;
+        httpHeaderAccept?: 'application/json',
-    public generateRandomChallengeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetRandomChallengeDto>>;
+        context?: HttpContext,
-    public generateRandomChallengeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<GetRandomChallengeDto>;
+    public generateRandomChallengeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<GetRandomChallengeDto>>;
+    public generateRandomChallengeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<GetRandomChallengeDto>>;
+    public generateRandomChallengeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -96,10 +112,26 @@ export class RandomchallengesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetRandomChallengeDto>;
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetRandomChallengeDto>>;
+        httpHeaderAccept?: 'application/json',
-    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetRandomChallengeDto>>;
+        context?: HttpContext,
-    public getRandomChallengeEndpoint(randomChallengeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<GetRandomChallengeDto>;
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<GetRandomChallengeDto>>;
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<GetRandomChallengeDto>>;
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (randomChallengeId === null || randomChallengeId === undefined) {
             throw new Error('Required parameter randomChallengeId was null or undefined when calling getRandomChallengeEndpoint.');
         }
@@ -132,7 +164,15 @@ export class RandomchallengesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({name: "randomChallengeId", value: randomChallengeId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({
+            name: "randomChallengeId",
+            value: randomChallengeId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<GetRandomChallengeDto>('get', `${basePath}${localVarPath}`,
             {
@@ -155,10 +195,26 @@ export class RandomchallengesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'body', reportProgress?: boolean, options?: {
-    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (randomChallengeId === null || randomChallengeId === undefined) {
             throw new Error('Required parameter randomChallengeId was null or undefined when calling patchProofEndpoint.');
         }
@@ -168,8 +224,7 @@ export class RandomchallengesService extends BaseService {
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -212,7 +267,15 @@ export class RandomchallengesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({name: "randomChallengeId", value: randomChallengeId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Proof`;
+        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({
+            name: "randomChallengeId",
+            value: randomChallengeId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}/Proof`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`,
             {

src/app/services/api/api/users.service.ts

@@ -10,7 +10,8 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import {Inject, Injectable, Optional} from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams,
+import {
+    HttpClient, HttpHeaders, HttpParams,
     HttpResponse, HttpEvent, HttpContext
 } from '@angular/common/http';
 import {Observable} from 'rxjs';
@@ -41,7 +42,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';
 
 
-
 @Injectable({
     providedIn: 'root'
 })
@@ -58,10 +58,26 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: 'application/problem+json',
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public createUserEndpoint(createUserDto: CreateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public createUserEndpoint(createUserDto: CreateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (createUserDto === null || createUserDto === undefined) {
             throw new Error('Required parameter createUserDto was null or undefined when calling createUserEndpoint.');
         }
@@ -122,18 +138,33 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteUserEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteUserEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public deleteUserEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: undefined,
-    public deleteUserEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public deleteUserEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public deleteUserEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public deleteUserEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public deleteUserEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
         // authentication (JWTBearerAuth) required
         localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');
 
-        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([]);
-        ]);
         if (localVarHttpHeaderAcceptSelected !== undefined) {
             localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
         }
@@ -175,10 +206,26 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllUserChallengesEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserChallengeDto>>;
+    public getAllUserChallengesEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllUserChallengesEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserChallengeDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllUserChallengesEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserChallengeDto>>>;
+        context?: HttpContext,
-    public getAllUserChallengesEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetUserChallengeDto>>;
+    public getAllUserChallengesEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetUserChallengeDto>>>;
+    public getAllUserChallengesEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetUserChallengeDto>>>;
+    public getAllUserChallengesEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -229,10 +276,26 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllUserProofsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserProofDto>>;
+    public getAllUserProofsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllUserProofsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserProofDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllUserProofsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserProofDto>>>;
+        context?: HttpContext,
-    public getAllUserProofsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetUserProofDto>>;
+    public getAllUserProofsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetUserProofDto>>>;
+    public getAllUserProofsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetUserProofDto>>>;
+    public getAllUserProofsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -283,10 +346,26 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllUsersEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserDto>>;
+    public getAllUsersEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getAllUsersEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserDto>>>;
+        httpHeaderAccept?: 'application/json',
-    public getAllUsersEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserDto>>>;
+        context?: HttpContext,
-    public getAllUsersEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<Array<GetUserDto>>;
+    public getAllUsersEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<Array<GetUserDto>>>;
+    public getAllUsersEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<Array<GetUserDto>>>;
+    public getAllUsersEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -337,10 +416,26 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getUserDetailsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetUserDetailsDto>;
+    public getUserDetailsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-    public getUserDetailsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetUserDetailsDto>>;
+        httpHeaderAccept?: 'application/json',
-    public getUserDetailsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetUserDetailsDto>>;
+        context?: HttpContext,
-    public getUserDetailsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<GetUserDetailsDto>;
+    public getUserDetailsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<GetUserDetailsDto>>;
+    public getUserDetailsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<GetUserDetailsDto>>;
+    public getUserDetailsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -392,10 +487,26 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getUserEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetUserDto>;
+    public getUserEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
-    public getUserEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetUserDto>>;
+        httpHeaderAccept?: 'application/json',
-    public getUserEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetUserDto>>;
+        context?: HttpContext,
-    public getUserEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<GetUserDto>;
+    public getUserEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<GetUserDto>>;
+    public getUserEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<GetUserDto>>;
+    public getUserEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getUserEndpoint.');
         }
@@ -428,7 +539,15 @@ export class UsersService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Users/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        let localVarPath = `/API/Users/${this.configuration.encodeParam({
+            name: "id",
+            value: id,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "number",
+            dataFormat: "int32"
+        })}`;
         const {basePath, withCredentials} = this.configuration;
         return this.httpClient.request<GetUserDto>('get', `${basePath}${localVarPath}`,
             {
@@ -450,10 +569,26 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'body', reportProgress?: boolean, options?: {
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: 'application/problem+json',
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (patchUserDesignationDto === null || patchUserDesignationDto === undefined) {
             throw new Error('Required parameter patchUserDesignationDto was null or undefined when calling patchUserDesignationEndpoint.');
         }
@@ -518,10 +653,26 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'body', reportProgress?: boolean, options?: {
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: 'application/problem+json',
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (patchUserPasswordDto === null || patchUserPasswordDto === undefined) {
             throw new Error('Required parameter patchUserPasswordDto was null or undefined when calling patchUserPasswordEndpoint.');
         }
@@ -586,10 +737,26 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+        httpHeaderAccept?: 'application/problem+json',
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+        context?: HttpContext,
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+        transferCache?: boolean
+    }): Observable<any>;
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
         if (updateUserDto === null || updateUserDto === undefined) {
             throw new Error('Required parameter updateUserDto was null or undefined when calling updateUserEndpoint.');
         }

src/app/services/api/configuration.ts

@@ -67,7 +67,17 @@ export class Configuration {
      */
     credentials: { [key: string]: string | (() => string | undefined) };
 
-constructor({ accessToken, apiKeys, basePath, credentials, encodeParam, encoder, password, username, withCredentials }: ConfigurationParameters = {}) {
+    constructor({
+                    accessToken,
+                    apiKeys,
+                    basePath,
+                    credentials,
+                    encodeParam,
+                    encoder,
+                    password,
+                    username,
+                    withCredentials
+                }: ConfigurationParameters = {}) {
         if (apiKeys) {
             this.apiKeys = apiKeys;
         }

src/app/services/api/encoder.ts

@@ -8,12 +8,15 @@ export class CustomHttpParameterCodec implements HttpParameterCodec {
     encodeKey(k: string): string {
         return encodeURIComponent(k);
     }
+
     encodeValue(v: string): string {
         return encodeURIComponent(v);
     }
+
     decodeKey(k: string): string {
         return decodeURIComponent(k);
     }
+
     decodeValue(v: string): string {
         return decodeURIComponent(v);
     }
@@ -23,12 +26,15 @@ export class IdentityHttpParameterCodec implements HttpParameterCodec {
     encodeKey(k: string): string {
         return k;
     }
+
     encodeValue(v: string): string {
         return v;
     }
+
     decodeKey(k: string): string {
         return k;
     }
+
     decodeValue(v: string): string {
         return v;
     }