added interceptor and authService to manage log

2026-03-24 19:08:34 +01:00
parent 491c57b061
commit ef2afb0b58
66 changed files with 1815 additions and 777 deletions
@@ -3,11 +3,14 @@ import { provideRouter } from '@angular/router';

 import {routes} from './app.routes';
 import {provideIonicAngular} from '@ionic/angular/standalone';
+import {provideHttpClient, withInterceptors} from "@angular/common/http";
+import {authInterceptor} from "./interceptors/auth-interceptor";

 export const appConfig: ApplicationConfig = {
    providers: [
        provideBrowserGlobalErrorListeners(),
        provideZoneChangeDetection({eventCoalescing: true}),
-    provideRouter(routes), provideIonicAngular({})
+        provideRouter(routes), provideIonicAngular({}),
+        provideHttpClient(withInterceptors([authInterceptor]))
    ]
 };
@@ -1,4 +1,4 @@
-import { Component } from '@angular/core';
+import {Component, output} from '@angular/core';
 import {FormControl, FormGroup, ReactiveFormsModule, Validators} from "@angular/forms";
 import {IonicModule} from "@ionic/angular";

@@ -12,7 +12,6 @@ import {IonicModule} from "@ionic/angular";
    ]
 })
 export class SignInFormComponent {
-
    loginForm: FormGroup = new FormGroup({
        username: new FormControl<string>(null, [Validators.required]),
        password: new FormControl<string>(null, [Validators.required])
@@ -0,0 +1,46 @@
+import {HttpInterceptorFn, HttpErrorResponse, HttpRequest, HttpHandlerFn} from '@angular/common/http';
+import {inject} from '@angular/core';
+import {catchError, switchMap, throwError} from 'rxjs';
+import {AuthManageService} from "../services/auth-manage";
+import {AuthService} from "../services/api";
+
+export const authInterceptor: HttpInterceptorFn = (req: HttpRequest<any>, next: HttpHandlerFn) => {
+    const authManageService = inject(AuthManageService);
+    const authService = inject(AuthService);
+    const token = authManageService.getToken();
+
+    let authReq = req;
+    if (token) {
+        authReq = req.clone({
+            setHeaders: {Authorization: `Bearer ${token}`}
+        });
+    }
+
+    return next(authReq).pipe(
+        catchError((error: HttpErrorResponse) => {
+            if (error.status === 401 && token) {
+                return authService.refreshTokenEndpoint({token})
+                    .pipe(
+                        switchMap((res: any) => {
+                            authManageService.setToken(res.token);
+                            const newReq = req.clone({
+                                setHeaders: {Authorization: `Bearer ${res.token}`}
+                            });
+                            return next(newReq);
+                        }),
+                        catchError((refreshErr) => {
+                            authManageService.logout();
+                            console.log('Session expirée', 'Veuillez vous reconnecter.');
+                            return throwError(() => refreshErr);
+                        })
+                    );
+            }
+
+            if (error.status === 403) {
+                console.log('Accès refusé', 'Vous n’avez pas les droits pour cette action.');
+            }
+
+            return throwError(() => error);
+        })
+    );
+};
@@ -7,9 +7,9 @@
    </p>

    @if (authState()) {
-        <app-sign-in-form class="mb-9"></app-sign-in-form>
+        <app-sign-in-form class="mb-9" #loginForm></app-sign-in-form>

-        <ion-button class="w-10/12 mt-0 border-0" color="primary">
+        <ion-button class="w-10/12 mt-0 border-0" color="primary" (click)="connectUser()">
            <p class="text-white font-bold m-0">Se connecter</p>
        </ion-button>

@@ -1,7 +1,9 @@
-import {Component, signal} from '@angular/core';
+import {Component, inject, signal, viewChild} from '@angular/core';
 import {IonicModule} from "@ionic/angular";
 import {SignInFormComponent} from "../../components/sign-in-form/sign-in-form.component";
 import {SignOnFormComponent} from "../../components/sign-on-form/sign-on-form.component";
+import {firstValueFrom} from "rxjs";
+import {AuthManageService} from "../../services/auth-manage";

@Component({
    selector: 'app-login',
@@ -15,13 +17,21 @@ import {SignOnFormComponent} from "../../components/sign-on-form/sign-on-form.co
 })
 export class LoginComponent {
    authState = signal<boolean>(true)
+    login = viewChild<SignInFormComponent>('loginForm');

-    createAccount(): void {
+    private authManageService = inject(AuthManageService);
+
+    createAccount() {
        if (this.authState()) {
            this.authState.set(false);
-        }else
-            if (this.authState() == false) {
+        } else if (this.authState() == false) {
            this.authState.set(true);
        }
    }
+
+    connectUser() {
+        const user = this.login().loginForm.getRawValue();
+        console.log(user);
+        this.authManageService.connectUser(user.username, user.password);
+    }
 }
@@ -23,6 +23,7 @@ model/create-message-dto.ts
 model/create-user-dto.ts
 model/create-user-group-dto.ts
 model/delete-friend-request.ts
+model/error-response.ts
 model/get-achievement-dto.ts
 model/get-designation-dto.ts
 model/get-friend-dto.ts
@@ -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
@@ -10,12 +10,15 @@
 /* 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';
 import {OpenApiHttpParams, QueryParamStyle} from '../query.params';

+// @ts-ignore
+import {ErrorResponse} from '../model/error-response';
 // @ts-ignore
 import {GetAchievementDto} from '../model/get-achievement-dto';

@@ -25,7 +28,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';


-
@Injectable({
    providedIn: 'root'
 })
@@ -41,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?: '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> {
+    public getAllAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -95,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?: '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> {
+    public getLockedAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -149,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?: '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> {
+    public getUserAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -204,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?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public unlockAchievementEndpoint(achievementId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        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.');
        }
@@ -218,6 +284,7 @@ export class AchievementsService extends BaseService {
        localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');

        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/problem+json'
        ]);
        if (localVarHttpHeaderAcceptSelected !== undefined) {
            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
@@ -239,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}`,
            {
@@ -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];
@@ -10,12 +10,15 @@
 /* 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';
 import {OpenApiHttpParams, QueryParamStyle} from '../query.params';

+// @ts-ignore
+import {ErrorResponse} from '../model/error-response';
 // @ts-ignore
 import {GetTokenDto} from '../model/get-token-dto';
 // @ts-ignore
@@ -29,7 +32,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';


-
@Injectable({
    providedIn: 'root'
 })
@@ -46,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', context?: HttpContext, transferCache?: boolean}): Observable<GetTokenDto>;
-    public loginEndpoint(loginDto: LoginDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetTokenDto>>;
-    public loginEndpoint(loginDto: LoginDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetTokenDto>>;
-    public loginEndpoint(loginDto: LoginDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    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?: '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.');
        }
@@ -57,7 +75,8 @@ export class AuthService extends BaseService {
        let localVarHeaders = this.defaultHeaders;

        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
-            'application/json'
+            'application/json',
+            'application/problem+json'
        ]);
        if (localVarHttpHeaderAcceptSelected !== undefined) {
            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
@@ -111,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', context?: HttpContext, transferCache?: boolean}): Observable<GetTokenDto>;
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetTokenDto>>;
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetTokenDto>>;
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    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?: '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.');
        }
@@ -122,7 +157,8 @@ export class AuthService extends BaseService {
        let localVarHeaders = this.defaultHeaders;

        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
-            'application/json'
+            'application/json',
+            'application/problem+json'
        ]);
        if (localVarHttpHeaderAcceptSelected !== undefined) {
            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
@@ -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?: '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> {
+    public getAllDesignationsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -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';
@@ -33,7 +34,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';


-
@Injectable({
    providedIn: 'root'
 })
@@ -51,10 +51,26 @@ export class FriendsService extends BaseService {
     * @param reportProgress flag to report request and response progress.
     * @param options additional options
     */
-    public acceptFriendRequestEndpoint(friendId: string, acceptFriendRequest: AcceptFriendRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public acceptFriendRequestEndpoint(friendId: string, acceptFriendRequest: AcceptFriendRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public acceptFriendRequestEndpoint(friendId: string, acceptFriendRequest: AcceptFriendRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public acceptFriendRequestEndpoint(friendId: string, acceptFriendRequest: AcceptFriendRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public acceptFriendRequestEndpoint(friendId: string, acceptFriendRequest: AcceptFriendRequest, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any>;
+    public acceptFriendRequestEndpoint(friendId: string, acceptFriendRequest: AcceptFriendRequest, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public acceptFriendRequestEndpoint(friendId: string, acceptFriendRequest: AcceptFriendRequest, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public acceptFriendRequestEndpoint(friendId: string, acceptFriendRequest: AcceptFriendRequest, 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.');
        }
@@ -67,8 +83,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);
        }
@@ -98,7 +113,15 @@ export class FriendsService extends BaseService {
            }
        }

-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: undefined})}/Request`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
+            name: "friendId",
+            value: friendId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "string",
+            dataFormat: undefined
+        })}/Request`;
        const {basePath, withCredentials} = this.configuration;
        return this.httpClient.request<any>('put', `${basePath}${localVarPath}`,
            {
@@ -121,10 +144,26 @@ export class FriendsService extends BaseService {
     * @param reportProgress flag to report request and response progress.
     * @param options additional options
     */
-    public deleteFriendEndpoint(deleteFriendRequest: DeleteFriendRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public deleteFriendEndpoint(deleteFriendRequest: DeleteFriendRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public deleteFriendEndpoint(deleteFriendRequest: DeleteFriendRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public deleteFriendEndpoint(deleteFriendRequest: DeleteFriendRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public deleteFriendEndpoint(deleteFriendRequest: DeleteFriendRequest, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any>;
+    public deleteFriendEndpoint(deleteFriendRequest: DeleteFriendRequest, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public deleteFriendEndpoint(deleteFriendRequest: DeleteFriendRequest, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public deleteFriendEndpoint(deleteFriendRequest: DeleteFriendRequest, observe: any = 'body', reportProgress: boolean = false, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any> {
        if (deleteFriendRequest === null || deleteFriendRequest === undefined) {
            throw new Error('Required parameter deleteFriendRequest was null or undefined when calling deleteFriendEndpoint.');
        }
@@ -134,8 +173,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);
        }
@@ -187,10 +225,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?: '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> {
+    public getAllFriendRequestsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -241,10 +295,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?: '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> {
+    public getAllFriendsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -297,10 +367,26 @@ export class FriendsService extends BaseService {
     * @param reportProgress flag to report request and response progress.
     * @param options additional options
     */
-    public rejectFriendRequestEndpoint(friendId: string, rejectFriendRequest: RejectFriendRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public rejectFriendRequestEndpoint(friendId: string, rejectFriendRequest: RejectFriendRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public rejectFriendRequestEndpoint(friendId: string, rejectFriendRequest: RejectFriendRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public rejectFriendRequestEndpoint(friendId: string, rejectFriendRequest: RejectFriendRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public rejectFriendRequestEndpoint(friendId: string, rejectFriendRequest: RejectFriendRequest, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any>;
+    public rejectFriendRequestEndpoint(friendId: string, rejectFriendRequest: RejectFriendRequest, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public rejectFriendRequestEndpoint(friendId: string, rejectFriendRequest: RejectFriendRequest, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public rejectFriendRequestEndpoint(friendId: string, rejectFriendRequest: RejectFriendRequest, 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.');
        }
@@ -313,8 +399,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);
        }
@@ -344,7 +429,15 @@ export class FriendsService extends BaseService {
            }
        }

-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: undefined})}/Request`;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
+            name: "friendId",
+            value: friendId,
+            in: "path",
+            style: "simple",
+            explode: false,
+            dataType: "string",
+            dataFormat: undefined
+        })}/Request`;
        const {basePath, withCredentials} = this.configuration;
        return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
            {
@@ -367,10 +460,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?: '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> {
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        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.');
        }
@@ -380,8 +489,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);
        }
@@ -402,7 +510,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}`,
            {
@@ -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';
@@ -19,6 +20,8 @@ import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 // @ts-ignore
 import {CreateGroupDto} from '../model/create-group-dto';
 // @ts-ignore
+import {ErrorResponse} from '../model/error-response';
+// @ts-ignore
 import {GetGroupDetailsDto} from '../model/get-group-details-dto';
 // @ts-ignore
 import {GetGroupDto} from '../model/get-group-dto';
@@ -39,7 +42,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';


-
@Injectable({
    providedIn: 'root'
 })
@@ -57,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?: '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> {
+    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?: '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.');
        }
@@ -73,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);
        }
@@ -95,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}`,
            {
@@ -117,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?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        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.');
        }
@@ -131,6 +180,7 @@ export class GroupsService extends BaseService {
        localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');

        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/problem+json'
        ]);
        if (localVarHttpHeaderAcceptSelected !== undefined) {
            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
@@ -184,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?: '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> {
+    public deleteGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        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.');
        }
@@ -197,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);
        }
@@ -219,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}`,
            {
@@ -242,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?: '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> {
+    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?: '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.');
        }
@@ -258,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);
        }
@@ -280,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}`,
            {
@@ -302,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?: '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> {
+    public getAllGroupUsersEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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.');
        }
@@ -338,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}`,
            {
@@ -359,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?: '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> {
+    public getAllGroupsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -414,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?: '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> {
+    public getAllProofsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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.');
        }
@@ -450,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}`,
            {
@@ -472,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?: '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> {
+    public getGroupDetailsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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.');
        }
@@ -508,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}`,
            {
@@ -530,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?: '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> {
+    public getGroupRankingEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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.');
        }
@@ -566,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}`,
            {
@@ -588,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?: '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> {
+    public patchGroupStatusEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        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.');
        }
@@ -601,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);
        }
@@ -623,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}`,
            {
@@ -646,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?: '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> {
+    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?: '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.');
        }
@@ -662,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);
        }
@@ -693,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}`,
            {
@@ -717,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?: '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> {
+    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?: '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.');
        }
@@ -733,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);
        }
@@ -755,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}`,
            {
@@ -778,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?: '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> {
+    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?: '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.');
        }
@@ -794,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);
        }
@@ -825,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}`,
            {
@@ -848,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?: '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> {
+    public startVoteEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        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.');
        }
@@ -861,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);
        }
@@ -883,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}`,
            {
@@ -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';
@@ -19,6 +20,8 @@ import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 // @ts-ignore
 import {CreateMessageDto} from '../model/create-message-dto';
 // @ts-ignore
+import {ErrorResponse} from '../model/error-response';
+// @ts-ignore
 import {GetMessageDto} from '../model/get-message-dto';

 // @ts-ignore
@@ -27,7 +30,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';


-
@Injectable({
    providedIn: 'root'
 })
@@ -45,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?: '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> {
+    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?: '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.');
        }
@@ -61,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);
        }
@@ -83,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}`,
            {
@@ -105,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?: '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> {
+    public getMessagesEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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.');
        }
@@ -141,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}`,
            {
@@ -164,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?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    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?: '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.');
        }
@@ -181,6 +254,7 @@ export class MessagesService extends BaseService {
        localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');

        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/problem+json'
        ]);
        if (localVarHttpHeaderAcceptSelected !== undefined) {
            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
@@ -211,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}`,
            {
@@ -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?: '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> {
+    public getOverallRankingEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -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,18 +43,33 @@ 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?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public generateRandomChallengeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public generateRandomChallengeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public generateRandomChallengeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public generateRandomChallengeEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any>;
+    public generateRandomChallengeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public generateRandomChallengeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public generateRandomChallengeEndpoint(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);
        }
@@ -97,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?: '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> {
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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.');
        }
@@ -133,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}`,
            {
@@ -156,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, randomChallengeProofRequest: RandomChallengeProofRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public patchProofEndpoint(randomChallengeId: number, randomChallengeProofRequest: RandomChallengeProofRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public patchProofEndpoint(randomChallengeId: number, randomChallengeProofRequest: RandomChallengeProofRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public patchProofEndpoint(randomChallengeId: number, randomChallengeProofRequest: RandomChallengeProofRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public patchProofEndpoint(randomChallengeId: number, randomChallengeProofRequest: RandomChallengeProofRequest, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<any>;
+    public patchProofEndpoint(randomChallengeId: number, randomChallengeProofRequest: RandomChallengeProofRequest, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpResponse<any>>;
+    public patchProofEndpoint(randomChallengeId: number, randomChallengeProofRequest: RandomChallengeProofRequest, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        transferCache?: boolean
+    }): Observable<HttpEvent<any>>;
+    public patchProofEndpoint(randomChallengeId: number, randomChallengeProofRequest: RandomChallengeProofRequest, 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.');
        }
@@ -172,8 +227,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);
        }
@@ -203,7 +257,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}`,
            {
@@ -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';
@@ -19,6 +20,8 @@ import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 // @ts-ignore
 import {CreateUserDto} from '../model/create-user-dto';
 // @ts-ignore
+import {ErrorResponse} from '../model/error-response';
+// @ts-ignore
 import {GetUserChallengeDto} from '../model/get-user-challenge-dto';
 // @ts-ignore
 import {GetUserDetailsDto} from '../model/get-user-details-dto';
@@ -39,7 +42,6 @@ import { Configuration }                                     from '../configurat
 import {BaseService} from '../api.base.service';


-
@Injectable({
    providedIn: 'root'
 })
@@ -56,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?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public createUserEndpoint(createUserDto: CreateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        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.');
        }
@@ -67,6 +85,7 @@ export class UsersService extends BaseService {
        let localVarHeaders = this.defaultHeaders;

        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/problem+json'
        ]);
        if (localVarHttpHeaderAcceptSelected !== undefined) {
            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
@@ -119,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?: '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> {
+    public deleteUserEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined,
+        context?: HttpContext,
+        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);
        }
@@ -172,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?: '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> {
+    public getAllUserChallengesEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -226,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?: '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> {
+    public getAllUserProofsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -280,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?: '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> {
+    public getAllUsersEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -334,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?: '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> {
+    public getUserDetailsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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;

@@ -389,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?: '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> {
+    public getUserEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json',
+        context?: HttpContext,
+        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.');
        }
@@ -425,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}`,
            {
@@ -447,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?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        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.');
        }
@@ -461,6 +599,7 @@ export class UsersService extends BaseService {
        localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');

        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/problem+json'
        ]);
        if (localVarHttpHeaderAcceptSelected !== undefined) {
            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
@@ -514,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?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        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.');
        }
@@ -528,6 +683,7 @@ export class UsersService extends BaseService {
        localVarHeaders = this.configuration.addCredentialToHeaders('JWTBearerAuth', 'Authorization', localVarHeaders, 'Bearer ');

        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/problem+json'
        ]);
        if (localVarHttpHeaderAcceptSelected !== undefined) {
            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
@@ -581,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?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/problem+json',
+        context?: HttpContext,
+        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.');
        }
@@ -592,6 +764,7 @@ export class UsersService extends BaseService {
        let localVarHeaders = this.defaultHeaders;

        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/problem+json'
        ]);
        if (localVarHttpHeaderAcceptSelected !== undefined) {
            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
@@ -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;
        }
@@ -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;
    }
@@ -11,10 +11,11 @@ import { CreateUserGroupDto } from './create-user-group-dto';


 export interface CreateGroupDto {
-    label?: string | null;
-    title?: string | null;
-    description?: string | null;
-    duration?: number;
+    label: string;
+    title: string;
+    description: string;
+    duration: number;
+    voteDuration?: number | null;
    userGroups?: Array<CreateUserGroupDto> | null;
 }

@@ -10,7 +10,7 @@


 export interface CreateMessageDto {
-    libelle?: string | null;
-    sendDate?: string;
+    libelle: string;
+    sendDate: string;
 }

@@ -10,10 +10,10 @@


 export interface CreateUserDto {
-    firstName?: string | null;
-    name?: string | null;
-    username?: string | null;
-    email?: string | null;
-    password?: string | null;
+    firstName: string;
+    name: string;
+    username: string;
+    email: string;
+    password: string;
 }

@@ -16,7 +16,7 @@ export interface GetUserDetailsDto {
    name?: string | null;
    username?: string | null;
    email?: string | null;
-    designationId?: number;
+    designationId?: number | null;
    creationDate?: string;
    getUserStatsDto?: GetUserStatsDto | null;
 }
@@ -15,7 +15,7 @@ export interface GetUserDto {
    firstName?: string | null;
    name?: string | null;
    username?: string | null;
-    designationId?: number;
+    designationId?: number | null;
    getUserStatsDto?: GetUserStatsDto | null;
 }

@@ -10,7 +10,7 @@


 export interface LoginDto {
-    username?: string | null;
-    password?: string | null;
+    username: string;
+    password: string;
 }

@@ -4,6 +4,7 @@ export * from './create-message-dto';
 export * from './create-user-dto';
 export * from './create-user-group-dto';
 export * from './delete-friend-request';
+export * from './error-response';
 export * from './get-achievement-dto';
 export * from './get-designation-dto';
 export * from './get-friend-dto';
@@ -10,6 +10,6 @@


 export interface PatchUserDesignationDto {
-    designationId?: number;
+    designationId: number;
 }

@@ -10,6 +10,6 @@


 export interface PatchUserPasswordDto {
-    password?: string | null;
+    password: string;
 }

@@ -10,6 +10,6 @@


 export interface RefreshTokenDto {
-    token?: string | null;
+    token: string;
 }

@@ -10,9 +10,9 @@


 export interface UpdateUserDto {
-    firstName?: string | null;
-    name?: string | null;
-    username?: string | null;
-    email?: string | null;
+    firstName: string;
+    name: string;
+    username: string;
+    email: string;
 }

@@ -0,0 +1,33 @@
+import {inject, Injectable} from '@angular/core';
+import {firstValueFrom} from 'rxjs';
+import {AuthService} from "./api";
+
+@Injectable({
+    providedIn: 'root',
+})
+export class AuthManageService {
+    private loginService = inject(AuthService);
+
+    async connectUser(username: string, password: string) {
+        try {
+            const loginDto = {username, password};
+            const res = await firstValueFrom(this.loginService.loginEndpoint(loginDto));
+            localStorage.setItem('jwt', res.token);
+        } catch (e) {
+            console.log(e)
+        }
+    }
+
+    getToken(): string | null {
+        return localStorage.getItem('jwt');
+    }
+
+    setToken(token: string) {
+        localStorage.setItem('jwt', token);
+    }
+
+    logout() {
+        localStorage.removeItem('jwt');
+    }
+
+}