diff --git a/src/app/components/profil-form/profil-form.component.html b/src/app/components/profil-form/profil-form.component.html
index 196eac0..3269849 100644
--- a/src/app/components/profil-form/profil-form.component.html
+++ b/src/app/components/profil-form/profil-form.component.html
@@ -1,25 +1,60 @@
-<div class="bg-white rounded-2xl p-2">
-    <form [formGroup]="profileForm">
-        <ion-item lines="none">
-            <ion-label position="stacked">Prénom  <ion-text color="danger">*</ion-text></ion-label>
-            <ion-input placeholder="Prénom" [clearInput]="true" formControlName="firstName"></ion-input>
+<div class="bg-white rounded-xl p-5 shadow-sm border border-gray-200">
+    <form [formGroup]="profileForm" class="space-y-5">
+
+        <ion-label class="text-xs text-gray-500 mb-1 block">
+            Prénom
+            <ion-text color="danger">*</ion-text>
+        </ion-label>
+        <ion-item lines="none" class="rounded-xl border border-gray-200 px-3">
+            <ion-input placeholder="Prénom"
+                       [clearInput]="true"
+                       formControlName="firstName"
+                       class="text-gray-800">
+            </ion-input>
         </ion-item>
 
-        <ion-item lines="none">
-            <ion-label position="stacked">Nom  <ion-text color="danger">*</ion-text></ion-label>
-            <ion-input placeholder="Nom de famille" [clearInput]="true" formControlName="name"></ion-input>
+        <ion-label class="text-xs text-gray-500 mb-1 block">
+            Nom
+            <ion-text color="danger">*</ion-text>
+        </ion-label>
+        <ion-item lines="none" class="rounded-xl border border-gray-200 px-3">
+            <ion-input placeholder="Nom de famille"
+                       [clearInput]="true"
+                       formControlName="name"
+                       class="text-gray-800">
+            </ion-input>
         </ion-item>
 
-        <ion-item lines="none">
-            <ion-label position="stacked">Pseudo  <ion-text color="danger">*</ion-text></ion-label>
-            <ion-input placeholder="Nom d'utilisateur" [clearInput]="true" formControlName="username"></ion-input>
+        <ion-label class="text-xs text-gray-500 mb-1 block">
+            Pseudo
+            <ion-text color="danger">*</ion-text>
+        </ion-label>
+        <ion-item lines="none" class="rounded-xl border border-gray-200 px-3">
+            <ion-input placeholder="Nom d'utilisateur"
+                       [clearInput]="true"
+                       formControlName="username"
+                       class="text-gray-800">
+            </ion-input>
         </ion-item>
 
-        <ion-item lines="none">
-            <ion-label position="stacked">Adresse email  <ion-text color="danger">*</ion-text></ion-label>
-            <ion-input placeholder="Email" type="email" [clearInput]="true" email formControlName="email"></ion-input>
+        <ion-label class="text-xs text-gray-500 mb-1 block">
+            Email
+            <ion-text color="danger">*</ion-text>
+        </ion-label>
+        <ion-item lines="none" class="rounded-xl border border-gray-200 px-3">
+            <ion-input placeholder="Email"
+                       type="email"
+                       [clearInput]="true"
+                       formControlName="email"
+                       class="text-gray-800">
+            </ion-input>
         </ion-item>
 
-        <ion-button class="mt-4" expand="block" (click)="updateUser()">Modifier</ion-button>
+        <ion-button expand="block"
+                    class="mt-6 rounded-xl font-medium"
+                    style="--background: #1f2937;"
+                    (click)="updateUser()">
+            Modifier
+        </ion-button>
     </form>
 </div>
\ No newline at end of file
diff --git a/src/app/components/profil-form/profil-form.component.ts b/src/app/components/profil-form/profil-form.component.ts
index 17b4f26..0f6692b 100644
--- a/src/app/components/profil-form/profil-form.component.ts
+++ b/src/app/components/profil-form/profil-form.component.ts
@@ -1,7 +1,7 @@
-import {Component, inject, input, OnInit} from '@angular/core';
+import {Component, inject, input, OnInit, output} from '@angular/core';
 import {FormControl, FormGroup, FormsModule, ReactiveFormsModule, Validators} from "@angular/forms";
 import {IonicModule, LoadingController, ToastController} from "@ionic/angular";
-import {GetUserDetailsDto, GetUserDto, UsersService} from "../../services/api";
+import {GetUserDetailsDto, GetUserStatsDto, UsersService} from "../../services/api";
 import {firstValueFrom} from "rxjs";
 
 @Component({
@@ -27,6 +27,7 @@ export class ProfilFormComponent implements OnInit {
     })
 
     user = input.required<GetUserDetailsDto>();
+    userEdited = output<GetUserDetailsDto>();
 
     ngOnInit() {
         this.profileForm.patchValue({
@@ -64,12 +65,28 @@ export class ProfilFormComponent implements OnInit {
         await loading2.present();
 
         try {
-            await firstValueFrom(this.usersServices.updateUserEndpoint(this.profileForm.getRawValue()));
+            const form = this.profileForm.getRawValue();
+
+            await firstValueFrom(this.usersServices.updateUserEndpoint(form));
+            const userEdited = {
+                id: this.user().id,
+                firstName: form.firstName,
+                name: form.name,
+                username: form.username,
+                email: form.email,
+                designationName: this.user().designationName,
+                creationDate: this.user().creationDate,
+                getUserStatsDto: this.user().getUserStatsDto
+            }
+
+            this.userEdited.emit(userEdited);
+
             const toast = await this.toastCtrl.create({
                 message: 'Modification réussie',
                 duration: 2000,
                 color: 'success'
             });
+            
             await loading2.dismiss();
             await toast.present();
         } catch {
@@ -78,6 +95,7 @@ export class ProfilFormComponent implements OnInit {
                 duration: 2000,
                 color: 'danger'
             });
+            await loading2.dismiss();
             await toast.present();
         }
     }
diff --git a/src/app/pages/home/home.component.html b/src/app/pages/home/home.component.html
index 47c2c58..b4b4b48 100644
--- a/src/app/pages/home/home.component.html
+++ b/src/app/pages/home/home.component.html
@@ -88,7 +88,7 @@
                 @case ('profile') {
                     <app-modal>
                         <div class="p-4">
-                            <app-profil-form [user]="user()"></app-profil-form>
+                            <app-profil-form [user]="user()" (userEdited)="user.set($event)"></app-profil-form>
                         </div>
                     </app-modal>
                 }
diff --git a/src/app/services/api/README.md b/src/app/services/api/README.md
index 29f22fe..c2ba935 100644
--- a/src/app/services/api/README.md
+++ b/src/app/services/api/README.md
@@ -73,9 +73,7 @@ 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 '';
 ```
@@ -183,7 +181,5 @@ 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
diff --git a/src/app/services/api/api.base.service.ts b/src/app/services/api/api.base.service.ts
index b90fbe9..ca18710 100644
--- a/src/app/services/api/api.base.service.ts
+++ b/src/app/services/api/api.base.service.ts
@@ -1,16 +1,16 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-import {HttpHeaders, HttpParams, HttpParameterCodec} from '@angular/common/http';
-import {CustomHttpParameterCodec} from './encoder';
-import {Configuration} from './configuration';
-import {OpenApiHttpParams, QueryParamStyle, concatHttpParamsObject} from './query.params';
+import { HttpHeaders, HttpParams, HttpParameterCodec } from '@angular/common/http';
+import { CustomHttpParameterCodec } from './encoder';
+import { Configuration } from './configuration';
+import { OpenApiHttpParams, QueryParamStyle, concatHttpParamsObject} from './query.params';
 
 export class BaseService {
     protected basePath = 'http://localhost:5235';
@@ -18,7 +18,7 @@ export class BaseService {
     public configuration: Configuration;
     public encoder: HttpParameterCodec;
 
-    constructor(basePath?: string | string[], configuration?: Configuration) {
+    constructor(basePath?: string|string[], configuration?: Configuration) {
         this.configuration = configuration || new Configuration();
         if (typeof this.configuration.basePath !== 'string') {
             const firstBasePath = Array.isArray(basePath) ? basePath[0] : undefined;
diff --git a/src/app/services/api/api.module.ts b/src/app/services/api/api.module.ts
index 68ca8d7..58d341f 100644
--- a/src/app/services/api/api.module.ts
+++ b/src/app/services/api/api.module.ts
@@ -1,30 +1,30 @@
-import {NgModule, ModuleWithProviders, SkipSelf, Optional} from '@angular/core';
-import {Configuration} from './configuration';
-import {HttpClient} from '@angular/common/http';
+import { NgModule, ModuleWithProviders, SkipSelf, Optional } from '@angular/core';
+import { Configuration } from './configuration';
+import { HttpClient } from '@angular/common/http';
 
 
 @NgModule({
-    imports: [],
-    declarations: [],
-    exports: [],
-    providers: []
+  imports:      [],
+  declarations: [],
+  exports:      [],
+  providers: []
 })
 export class ApiModule {
     public static forRoot(configurationFactory: () => Configuration): ModuleWithProviders<ApiModule> {
         return {
             ngModule: ApiModule,
-            providers: [{provide: Configuration, useFactory: configurationFactory}]
+            providers: [ { provide: Configuration, useFactory: configurationFactory } ]
         };
     }
 
-    constructor(@Optional() @SkipSelf() parentModule: ApiModule,
-                @Optional() http: HttpClient) {
+    constructor( @Optional() @SkipSelf() parentModule: ApiModule,
+                 @Optional() http: HttpClient) {
         if (parentModule) {
             throw new Error('ApiModule is already loaded. Import in your base AppModule only.');
         }
         if (!http) {
             throw new Error('You need to import the HttpClientModule in your AppModule! \n' +
-                'See also https://github.com/angular/angular/issues/20575');
+            'See also https://github.com/angular/angular/issues/20575');
         }
     }
 }
diff --git a/src/app/services/api/api/achievements.service.ts b/src/app/services/api/api/achievements.service.ts
index 5f56895..7b77108 100644
--- a/src/app/services/api/api/achievements.service.ts
+++ b/src/app/services/api/api/achievements.service.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,31 +9,31 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
-    HttpResponse, HttpEvent, HttpContext
-} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { Inject, Injectable, Optional }                      from '@angular/core';
+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';
+import { ErrorResponse } from '../model/error-response';
 // @ts-ignore
-import {GetAchievementDto} from '../model/get-achievement-dto';
+import { GetAchievementDto } from '../model/get-achievement-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
-import {Configuration} from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class AchievementsService extends BaseService {
 
-    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string | string[], @Optional() configuration?: Configuration) {
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
         super(basePath, configuration);
     }
 
@@ -43,26 +43,10 @@ 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;
 
@@ -93,15 +77,15 @@ export class AchievementsService extends BaseService {
         }
 
         let localVarPath = `/API/Achievements`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetAchievementDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -113,26 +97,10 @@ 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;
 
@@ -163,15 +131,15 @@ export class AchievementsService extends BaseService {
         }
 
         let localVarPath = `/API/Achievements/Locked/Users`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetAchievementDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -183,26 +151,10 @@ 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;
 
@@ -233,15 +185,15 @@ export class AchievementsService extends BaseService {
         }
 
         let localVarPath = `/API/Achievements/Users`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetAchievementDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -249,31 +201,15 @@ export class AchievementsService extends BaseService {
 
     /**
      * @endpoint post /API/Achievements/{achievementId}/Users
-     * @param achievementId
+     * @param achievementId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public unlockAchievementEndpoint(achievementId: number, observe?: '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> {
+    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.');
         }
@@ -306,24 +242,16 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
diff --git a/src/app/services/api/api/api.ts b/src/app/services/api/api/api.ts
index 3f2adfb..43f3297 100644
--- a/src/app/services/api/api/api.ts
+++ b/src/app/services/api/api/api.ts
@@ -1,28 +1,19 @@
 export * from './achievements.service';
-import {AchievementsService} from './achievements.service';
-
+import { AchievementsService } from './achievements.service';
 export * from './auth.service';
-import {AuthService} from './auth.service';
-
+import { AuthService } from './auth.service';
 export * from './designations.service';
-import {DesignationsService} from './designations.service';
-
+import { DesignationsService } from './designations.service';
 export * from './friends.service';
-import {FriendsService} from './friends.service';
-
+import { FriendsService } from './friends.service';
 export * from './groups.service';
-import {GroupsService} from './groups.service';
-
+import { GroupsService } from './groups.service';
 export * from './messages.service';
-import {MessagesService} from './messages.service';
-
+import { MessagesService } from './messages.service';
 export * from './overallranking.service';
-import {OverallrankingService} from './overallranking.service';
-
+import { OverallrankingService } from './overallranking.service';
 export * from './randomchallenges.service';
-import {RandomchallengesService} from './randomchallenges.service';
-
+import { RandomchallengesService } from './randomchallenges.service';
 export * from './users.service';
-import {UsersService} from './users.service';
-
+import { UsersService } from './users.service';
 export const APIS = [AchievementsService, AuthService, DesignationsService, FriendsService, GroupsService, MessagesService, OverallrankingService, RandomchallengesService, UsersService];
diff --git a/src/app/services/api/api/auth.service.ts b/src/app/services/api/api/auth.service.ts
index 507c8aa..1a1435c 100644
--- a/src/app/services/api/api/auth.service.ts
+++ b/src/app/services/api/api/auth.service.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,65 +9,49 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
-    HttpResponse, HttpEvent, HttpContext
-} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { Inject, Injectable, Optional }                      from '@angular/core';
+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';
+import { ErrorResponse } from '../model/error-response';
 // @ts-ignore
-import {GetTokenDto} from '../model/get-token-dto';
+import { GetTokenDto } from '../model/get-token-dto';
 // @ts-ignore
-import {LoginDto} from '../model/login-dto';
+import { LoginDto } from '../model/login-dto';
 // @ts-ignore
-import {RefreshTokenDto} from '../model/refresh-token-dto';
+import { RefreshTokenDto } from '../model/refresh-token-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
-import {Configuration} from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class AuthService extends BaseService {
 
-    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string | string[], @Optional() configuration?: Configuration) {
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
         super(basePath, configuration);
     }
 
     /**
      * @endpoint post /API/Auth/Login
-     * @param loginDto
+     * @param loginDto 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public loginEndpoint(loginDto: LoginDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetTokenDto>;
-    public loginEndpoint(loginDto: LoginDto, observe?: '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> {
+    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.');
         }
@@ -108,16 +92,16 @@ export class AuthService extends BaseService {
         }
 
         let localVarPath = `/API/Auth/Login`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<GetTokenDto>('post', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 body: loginDto,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -125,31 +109,15 @@ export class AuthService extends BaseService {
 
     /**
      * @endpoint post /API/Auth/RefreshToken
-     * @param refreshTokenDto
+     * @param refreshTokenDto 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetTokenDto>;
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: '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> {
+    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.');
         }
@@ -190,16 +158,16 @@ export class AuthService extends BaseService {
         }
 
         let localVarPath = `/API/Auth/RefreshToken`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<GetTokenDto>('post', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 body: refreshTokenDto,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
diff --git a/src/app/services/api/api/designations.service.ts b/src/app/services/api/api/designations.service.ts
index 26f8137..ac5e332 100644
--- a/src/app/services/api/api/designations.service.ts
+++ b/src/app/services/api/api/designations.service.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,29 +9,29 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
-    HttpResponse, HttpEvent, HttpContext
-} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpContext 
+        }       from '@angular/common/http';
+import { Observable }                                        from 'rxjs';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
-import {GetDesignationDto} from '../model/get-designation-dto';
+import { GetDesignationDto } from '../model/get-designation-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
-import {Configuration} from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class DesignationsService extends BaseService {
 
-    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string | string[], @Optional() configuration?: Configuration) {
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
         super(basePath, configuration);
     }
 
@@ -41,26 +41,10 @@ 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;
 
@@ -91,15 +75,15 @@ export class DesignationsService extends BaseService {
         }
 
         let localVarPath = `/API/Designations`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetDesignationDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
diff --git a/src/app/services/api/api/friends.service.ts b/src/app/services/api/api/friends.service.ts
index 15ed277..fe0c0f8 100644
--- a/src/app/services/api/api/friends.service.ts
+++ b/src/app/services/api/api/friends.service.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,61 +9,45 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
-    HttpResponse, HttpEvent, HttpContext
-} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpContext 
+        }       from '@angular/common/http';
+import { Observable }                                        from 'rxjs';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
-import {GetFriendDto} from '../model/get-friend-dto';
+import { GetFriendDto } from '../model/get-friend-dto';
 // @ts-ignore
-import {GetFriendRequestDto} from '../model/get-friend-request-dto';
+import { GetFriendRequestDto } from '../model/get-friend-request-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
-import {Configuration} from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class FriendsService extends BaseService {
 
-    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string | string[], @Optional() configuration?: Configuration) {
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
         super(basePath, configuration);
     }
 
     /**
      * @endpoint put /API/Friends/{friendId}/Request
-     * @param friendId
+     * @param friendId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public acceptFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public acceptFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling acceptFriendRequestEndpoint.');
         }
@@ -73,7 +57,8 @@ 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);
         }
@@ -94,24 +79,16 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
-            name: "friendId",
-            value: friendId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Request`;
-        const {basePath, withCredentials} = this.configuration;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Request`;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('put', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -119,31 +96,15 @@ export class FriendsService extends BaseService {
 
     /**
      * @endpoint delete /API/Friends/{friendId}
-     * @param friendId
+     * @param friendId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteFriendEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public deleteFriendEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public deleteFriendEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public deleteFriendEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public deleteFriendEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public deleteFriendEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public deleteFriendEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public deleteFriendEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling deleteFriendEndpoint.');
         }
@@ -153,7 +114,8 @@ 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);
         }
@@ -174,24 +136,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -203,26 +157,10 @@ 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;
 
@@ -253,15 +191,15 @@ export class FriendsService extends BaseService {
         }
 
         let localVarPath = `/API/Friends/Requests`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetFriendRequestDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -273,26 +211,10 @@ 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;
 
@@ -323,15 +245,15 @@ export class FriendsService extends BaseService {
         }
 
         let localVarPath = `/API/Friends`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetFriendDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -339,31 +261,15 @@ export class FriendsService extends BaseService {
 
     /**
      * @endpoint delete /API/Friends/{friendId}/Request
-     * @param friendId
+     * @param friendId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public rejectFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public rejectFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (friendId === null || friendId === undefined) {
             throw new Error('Required parameter friendId was null or undefined when calling rejectFriendRequestEndpoint.');
         }
@@ -373,7 +279,8 @@ 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);
         }
@@ -394,24 +301,16 @@ export class FriendsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Friends/${this.configuration.encodeParam({
-            name: "friendId",
-            value: friendId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Request`;
-        const {basePath, withCredentials} = this.configuration;
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Request`;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -419,31 +318,15 @@ export class FriendsService extends BaseService {
 
     /**
      * @endpoint post /API/Friends/{friendId}
-     * @param friendId
+     * @param friendId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -453,7 +336,8 @@ 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);
         }
@@ -474,24 +358,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
diff --git a/src/app/services/api/api/groups.service.ts b/src/app/services/api/api/groups.service.ts
index 3a28fe9..34479a4 100644
--- a/src/app/services/api/api/groups.service.ts
+++ b/src/app/services/api/api/groups.service.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,76 +9,60 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
-    HttpResponse, HttpEvent, HttpContext
-} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpContext 
+        }       from '@angular/common/http';
+import { Observable }                                        from 'rxjs';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
-import {CreateGroupDto} from '../model/create-group-dto';
+import { CreateGroupDto } from '../model/create-group-dto';
 // @ts-ignore
-import {ErrorResponse} from '../model/error-response';
+import { ErrorResponse } from '../model/error-response';
 // @ts-ignore
-import {GetGroupDetailsDto} from '../model/get-group-details-dto';
+import { GetGroupDetailsDto } from '../model/get-group-details-dto';
 // @ts-ignore
-import {GetGroupDto} from '../model/get-group-dto';
+import { GetGroupDto } from '../model/get-group-dto';
 // @ts-ignore
-import {GetGroupRankingDto} from '../model/get-group-ranking-dto';
+import { GetGroupRankingDto } from '../model/get-group-ranking-dto';
 // @ts-ignore
-import {GetProofDto} from '../model/get-proof-dto';
+import { GetProofDto } from '../model/get-proof-dto';
 // @ts-ignore
-import {GetUserGroupDto} from '../model/get-user-group-dto';
+import { GetUserGroupDto } from '../model/get-user-group-dto';
 // @ts-ignore
-import {UserProofRequest} from '../model/user-proof-request';
+import { UserProofRequest } from '../model/user-proof-request';
 // @ts-ignore
-import {UserVoteRequest} from '../model/user-vote-request';
+import { UserVoteRequest } from '../model/user-vote-request';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
-import {Configuration} from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class GroupsService extends BaseService {
 
-    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string | string[], @Optional() configuration?: Configuration) {
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
         super(basePath, configuration);
     }
 
     /**
      * @endpoint post /API/Groups/{groupId}/Users/{userId}
-     * @param groupId
-     * @param userId
+     * @param groupId 
+     * @param userId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -91,7 +75,8 @@ 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);
         }
@@ -112,32 +97,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -145,31 +114,15 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint post /API/Groups
-     * @param createGroupDto
+     * @param createGroupDto 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: '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> {
+    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.');
         }
@@ -212,16 +165,16 @@ export class GroupsService extends BaseService {
         }
 
         let localVarPath = `/API/Groups`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 body: createGroupDto,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -229,31 +182,15 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint delete /API/Groups/{id}
-     * @param id
+     * @param id 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -263,7 +200,8 @@ 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);
         }
@@ -284,24 +222,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -309,32 +239,16 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint delete /API/Groups/{groupId}/Users/{userId}
-     * @param groupId
-     * @param userId
+     * @param groupId 
+     * @param userId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -347,7 +261,8 @@ 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);
         }
@@ -368,32 +283,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -401,31 +300,15 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint get /API/Groups/{id}/Users
-     * @param id
+     * @param id 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -458,24 +341,16 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -487,26 +362,10 @@ 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;
 
@@ -537,15 +396,15 @@ export class GroupsService extends BaseService {
         }
 
         let localVarPath = `/API/Groups/Users`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetGroupDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -553,31 +412,15 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint get /API/Groups/{id}/Proofs
-     * @param id
+     * @param id 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -610,24 +453,16 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -635,31 +470,15 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint get /API/Groups/{id}
-     * @param id
+     * @param id 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -692,24 +511,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -717,31 +528,15 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint get /API/Groups/{id}/GroupRank
-     * @param id
+     * @param id 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -774,24 +569,16 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -799,31 +586,15 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint patch /API/Groups/{groupId}/Status
-     * @param groupId
+     * @param groupId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -833,7 +604,8 @@ 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);
         }
@@ -854,24 +626,16 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -879,32 +643,16 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint patch /API/Groups/{groupId}/Users/Proof
-     * @param groupId
-     * @param userProofRequest
+     * @param groupId 
+     * @param userProofRequest 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -917,7 +665,8 @@ 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);
         }
@@ -947,25 +696,17 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 body: userProofRequest,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -973,32 +714,16 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint patch /API/Groups/{groupId}/Users/{userId}/Role
-     * @param groupId
-     * @param userId
+     * @param groupId 
+     * @param userId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -1011,7 +736,8 @@ 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);
         }
@@ -1032,32 +758,16 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -1065,32 +775,16 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint patch /API/Groups/{groupId}/Users/Vote
-     * @param groupId
-     * @param userVoteRequest
+     * @param groupId 
+     * @param userVoteRequest 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -1103,7 +797,8 @@ 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);
         }
@@ -1133,25 +828,17 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 body: userVoteRequest,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -1159,31 +846,15 @@ export class GroupsService extends BaseService {
 
     /**
      * @endpoint post /API/Groups/{id}/Vote
-     * @param id
+     * @param id 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -1193,7 +864,8 @@ 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);
         }
@@ -1214,24 +886,16 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
diff --git a/src/app/services/api/api/messages.service.ts b/src/app/services/api/api/messages.service.ts
index daa658f..bb14d82 100644
--- a/src/app/services/api/api/messages.service.ts
+++ b/src/app/services/api/api/messages.service.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,64 +9,48 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
-    HttpResponse, HttpEvent, HttpContext
-} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpContext 
+        }       from '@angular/common/http';
+import { Observable }                                        from 'rxjs';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
-import {CreateMessageDto} from '../model/create-message-dto';
+import { CreateMessageDto } from '../model/create-message-dto';
 // @ts-ignore
-import {ErrorResponse} from '../model/error-response';
+import { ErrorResponse } from '../model/error-response';
 // @ts-ignore
-import {GetMessageDto} from '../model/get-message-dto';
+import { GetMessageDto } from '../model/get-message-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
-import {Configuration} from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class MessagesService extends BaseService {
 
-    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string | string[], @Optional() configuration?: Configuration) {
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
         super(basePath, configuration);
     }
 
     /**
      * @endpoint delete /API/Messages/{id}/Groups/{groupId}
-     * @param id
-     * @param groupId
+     * @param id 
+     * @param groupId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -79,7 +63,8 @@ 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);
         }
@@ -100,32 +85,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -133,31 +102,15 @@ export class MessagesService extends BaseService {
 
     /**
      * @endpoint get /API/Messages/Groups/{groupId}
-     * @param groupId
+     * @param groupId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -190,24 +143,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -215,32 +160,16 @@ export class MessagesService extends BaseService {
 
     /**
      * @endpoint post /API/Messages/Groups/{groupId}
-     * @param groupId
-     * @param createMessageDto
+     * @param groupId 
+     * @param createMessageDto 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: '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> {
+    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.');
         }
@@ -285,25 +214,17 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 body: createMessageDto,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
diff --git a/src/app/services/api/api/overallranking.service.ts b/src/app/services/api/api/overallranking.service.ts
index b38e54d..f338e49 100644
--- a/src/app/services/api/api/overallranking.service.ts
+++ b/src/app/services/api/api/overallranking.service.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,29 +9,29 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
-    HttpResponse, HttpEvent, HttpContext
-} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpContext 
+        }       from '@angular/common/http';
+import { Observable }                                        from 'rxjs';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
-import {GetUserDto} from '../model/get-user-dto';
+import { GetUserDto } from '../model/get-user-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
-import {Configuration} from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class OverallrankingService extends BaseService {
 
-    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string | string[], @Optional() configuration?: Configuration) {
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
         super(basePath, configuration);
     }
 
@@ -41,26 +41,10 @@ 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;
 
@@ -91,15 +75,15 @@ export class OverallrankingService extends BaseService {
         }
 
         let localVarPath = `/API/OverallRanking`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetUserDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
diff --git a/src/app/services/api/api/randomchallenges.service.ts b/src/app/services/api/api/randomchallenges.service.ts
index 0b530bd..e86bbb0 100644
--- a/src/app/services/api/api/randomchallenges.service.ts
+++ b/src/app/services/api/api/randomchallenges.service.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,29 +9,29 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
-    HttpResponse, HttpEvent, HttpContext
-} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpContext 
+        }       from '@angular/common/http';
+import { Observable }                                        from 'rxjs';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
-import {GetRandomChallengeDto} from '../model/get-random-challenge-dto';
+import { GetRandomChallengeDto } from '../model/get-random-challenge-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
-import {Configuration} from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class RandomchallengesService extends BaseService {
 
-    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string | string[], @Optional() configuration?: Configuration) {
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
         super(basePath, configuration);
     }
 
@@ -41,26 +41,10 @@ export class RandomchallengesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public generateRandomChallengeEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<GetRandomChallengeDto>;
-    public generateRandomChallengeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetRandomChallengeDto>>;
-    public generateRandomChallengeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetRandomChallengeDto>>;
-    public generateRandomChallengeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public generateRandomChallengeEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetRandomChallengeDto>;
+    public generateRandomChallengeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetRandomChallengeDto>>;
+    public generateRandomChallengeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetRandomChallengeDto>>;
+    public generateRandomChallengeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
 
         let localVarHeaders = this.defaultHeaders;
 
@@ -91,15 +75,15 @@ export class RandomchallengesService extends BaseService {
         }
 
         let localVarPath = `/API/RandomChallenges`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<GetRandomChallengeDto>('post', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -107,31 +91,15 @@ export class RandomchallengesService extends BaseService {
 
     /**
      * @endpoint get /API/RandomChallenges/{randomChallengeId}
-     * @param randomChallengeId
+     * @param randomChallengeId 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -164,24 +132,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -189,32 +149,16 @@ export class RandomchallengesService extends BaseService {
 
     /**
      * @endpoint patch /API/RandomChallenges/{randomChallengeId}/Proof
-     * @param randomChallengeId
-     * @param proof
+     * @param randomChallengeId 
+     * @param proof 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
+    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
+    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
+    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
+    public patchProofEndpoint(randomChallengeId: number, proof?: Blob, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
         if (randomChallengeId === null || randomChallengeId === undefined) {
             throw new Error('Required parameter randomChallengeId was null or undefined when calling patchProofEndpoint.');
         }
@@ -224,7 +168,8 @@ 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);
         }
@@ -267,25 +212,17 @@ 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`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 body: localVarConvertFormParamsToString ? localVarFormParams.toString() : localVarFormParams,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
diff --git a/src/app/services/api/api/users.service.ts b/src/app/services/api/api/users.service.ts
index d3d33cc..408df79 100644
--- a/src/app/services/api/api/users.service.ts
+++ b/src/app/services/api/api/users.service.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,75 +9,59 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
-import {
-    HttpClient, HttpHeaders, HttpParams,
-    HttpResponse, HttpEvent, HttpContext
-} from '@angular/common/http';
-import {Observable} from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { Inject, Injectable, Optional }                      from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams,
+         HttpResponse, HttpEvent, HttpContext 
+        }       from '@angular/common/http';
+import { Observable }                                        from 'rxjs';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
-import {CreateUserDto} from '../model/create-user-dto';
+import { CreateUserDto } from '../model/create-user-dto';
 // @ts-ignore
-import {ErrorResponse} from '../model/error-response';
+import { ErrorResponse } from '../model/error-response';
 // @ts-ignore
-import {GetUserChallengeDto} from '../model/get-user-challenge-dto';
+import { GetUserChallengeDto } from '../model/get-user-challenge-dto';
 // @ts-ignore
-import {GetUserDetailsDto} from '../model/get-user-details-dto';
+import { GetUserDetailsDto } from '../model/get-user-details-dto';
 // @ts-ignore
-import {GetUserDto} from '../model/get-user-dto';
+import { GetUserDto } from '../model/get-user-dto';
 // @ts-ignore
-import {GetUserProofDto} from '../model/get-user-proof-dto';
+import { GetUserProofDto } from '../model/get-user-proof-dto';
 // @ts-ignore
-import {PatchUserDesignationDto} from '../model/patch-user-designation-dto';
+import { PatchUserDesignationDto } from '../model/patch-user-designation-dto';
 // @ts-ignore
-import {PatchUserPasswordDto} from '../model/patch-user-password-dto';
+import { PatchUserPasswordDto } from '../model/patch-user-password-dto';
 // @ts-ignore
-import {UpdateUserDto} from '../model/update-user-dto';
+import { UpdateUserDto } from '../model/update-user-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
-import {Configuration} from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
+import { Configuration }                                     from '../configuration';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class UsersService extends BaseService {
 
-    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string | string[], @Optional() configuration?: Configuration) {
+    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {
         super(basePath, configuration);
     }
 
     /**
      * @endpoint post /API/Users
-     * @param createUserDto
+     * @param createUserDto 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: '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> {
+    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.');
         }
@@ -117,16 +101,16 @@ export class UsersService extends BaseService {
         }
 
         let localVarPath = `/API/Users`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('post', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 body: createUserDto,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -138,33 +122,18 @@ 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);
         }
@@ -186,15 +155,15 @@ export class UsersService extends BaseService {
         }
 
         let localVarPath = `/API/Users`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -206,26 +175,10 @@ 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;
 
@@ -256,15 +209,15 @@ export class UsersService extends BaseService {
         }
 
         let localVarPath = `/API/Users/Challenges`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetUserChallengeDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -276,26 +229,10 @@ 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;
 
@@ -326,15 +263,15 @@ export class UsersService extends BaseService {
         }
 
         let localVarPath = `/API/Users/Proofs`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetUserProofDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -346,26 +283,10 @@ 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;
 
@@ -396,15 +317,15 @@ export class UsersService extends BaseService {
         }
 
         let localVarPath = `/API/Users`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetUserDto>>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -416,26 +337,10 @@ 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;
 
@@ -466,15 +371,15 @@ export class UsersService extends BaseService {
         }
 
         let localVarPath = `/API/Users/Details`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<GetUserDetailsDto>('get', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -482,31 +387,15 @@ export class UsersService extends BaseService {
 
     /**
      * @endpoint get /API/Users/{id}
-     * @param id
+     * @param id 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @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.');
         }
@@ -539,24 +428,16 @@ 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"
-        })}`;
-        const {basePath, withCredentials} = this.configuration;
+        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}`,
             {
                 context: localVarHttpContext,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -564,31 +445,15 @@ export class UsersService extends BaseService {
 
     /**
      * @endpoint patch /API/Users/Designation
-     * @param patchUserDesignationDto
+     * @param patchUserDesignationDto 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: '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> {
+    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.');
         }
@@ -631,16 +496,16 @@ export class UsersService extends BaseService {
         }
 
         let localVarPath = `/API/Users/Designation`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 body: patchUserDesignationDto,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -648,31 +513,15 @@ export class UsersService extends BaseService {
 
     /**
      * @endpoint patch /API/Users/Password
-     * @param patchUserPasswordDto
+     * @param patchUserPasswordDto 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: '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> {
+    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.');
         }
@@ -715,16 +564,16 @@ export class UsersService extends BaseService {
         }
 
         let localVarPath = `/API/Users/Password`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 body: patchUserPasswordDto,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
@@ -732,31 +581,15 @@ export class UsersService extends BaseService {
 
     /**
      * @endpoint put /API/Users
-     * @param updateUserDto
+     * @param updateUserDto 
      * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/problem+json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any>;
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: '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> {
+    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.');
         }
@@ -796,16 +629,16 @@ export class UsersService extends BaseService {
         }
 
         let localVarPath = `/API/Users`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<any>('put', `${basePath}${localVarPath}`,
             {
                 context: localVarHttpContext,
                 body: updateUserDto,
                 responseType: <any>responseType_,
-                ...(withCredentials ? {withCredentials} : {}),
+                ...(withCredentials ? { withCredentials } : {}),
                 headers: localVarHeaders,
                 observe: observe,
-                ...(localVarTransferCache !== undefined ? {transferCache: localVarTransferCache} : {}),
+                ...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
                 reportProgress: reportProgress
             }
         );
diff --git a/src/app/services/api/configuration.ts b/src/app/services/api/configuration.ts
index 75789a9..fde0c16 100644
--- a/src/app/services/api/configuration.ts
+++ b/src/app/services/api/configuration.ts
@@ -1,12 +1,12 @@
-import {HttpHeaders, HttpParameterCodec} from '@angular/common/http';
-import {Param} from './param';
-import {OpenApiHttpParams} from './query.params';
+import { HttpHeaders, HttpParameterCodec } from '@angular/common/http';
+import { Param } from './param';
+import { OpenApiHttpParams } from './query.params';
 
 export interface ConfigurationParameters {
     /**
      *  @deprecated Since 5.0. Use credentials instead
      */
-    apiKeys?: { [key: string]: string };
+    apiKeys?: {[ key: string ]: string};
     username?: string;
     password?: string;
     /**
@@ -32,14 +32,14 @@ export interface ConfigurationParameters {
      * document. They should map to the value used for authentication
      * minus any standard prefixes such as 'Basic' or 'Bearer'.
      */
-    credentials?: { [key: string]: string | (() => string | undefined) };
+    credentials?: {[ key: string ]: string | (() => string | undefined)};
 }
 
 export class Configuration {
     /**
      *  @deprecated Since 5.0. Use credentials instead
      */
-    apiKeys?: { [key: string]: string };
+    apiKeys?: {[ key: string ]: string};
     username?: string;
     password?: string;
     /**
@@ -65,19 +65,9 @@ export class Configuration {
      * document. They should map to the value used for authentication
      * minus any standard prefixes such as 'Basic' or 'Bearer'.
      */
-    credentials: { [key: string]: string | (() => string | undefined) };
+    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;
         }
@@ -119,7 +109,7 @@ export class Configuration {
      * @param contentTypes - the array of content types that are available for selection
      * @returns the selected content-type or <code>undefined</code> if no selection could be made.
      */
-    public selectHeaderContentType(contentTypes: string[]): string | undefined {
+    public selectHeaderContentType (contentTypes: string[]): string | undefined {
         if (contentTypes.length === 0) {
             return undefined;
         }
diff --git a/src/app/services/api/encoder.ts b/src/app/services/api/encoder.ts
index 6314562..af45235 100644
--- a/src/app/services/api/encoder.ts
+++ b/src/app/services/api/encoder.ts
@@ -1,4 +1,4 @@
-import {HttpParameterCodec} from '@angular/common/http';
+import { HttpParameterCodec } from '@angular/common/http';
 
 /**
  * Custom HttpParameterCodec
@@ -8,15 +8,12 @@ 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);
     }
@@ -26,15 +23,12 @@ 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;
     }
diff --git a/src/app/services/api/model/create-group-dto.ts b/src/app/services/api/model/create-group-dto.ts
index ecb4658..2a2cc1e 100644
--- a/src/app/services/api/model/create-group-dto.ts
+++ b/src/app/services/api/model/create-group-dto.ts
@@ -1,16 +1,16 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-import {CreateUserGroupDto} from './create-user-group-dto';
+import { CreateUserGroupDto } from './create-user-group-dto';
 
 
-export interface CreateGroupDto {
+export interface CreateGroupDto { 
     label: string;
     title: string;
     description: string;
diff --git a/src/app/services/api/model/create-message-dto.ts b/src/app/services/api/model/create-message-dto.ts
index 3a11aa7..4af4c4b 100644
--- a/src/app/services/api/model/create-message-dto.ts
+++ b/src/app/services/api/model/create-message-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface CreateMessageDto {
+export interface CreateMessageDto { 
     libelle: string;
     sendDate: string;
 }
diff --git a/src/app/services/api/model/create-user-dto.ts b/src/app/services/api/model/create-user-dto.ts
index f8ae0a8..30bfc5e 100644
--- a/src/app/services/api/model/create-user-dto.ts
+++ b/src/app/services/api/model/create-user-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface CreateUserDto {
+export interface CreateUserDto { 
     firstName: string;
     name: string;
     username: string;
diff --git a/src/app/services/api/model/create-user-group-dto.ts b/src/app/services/api/model/create-user-group-dto.ts
index 061a21a..8a361f8 100644
--- a/src/app/services/api/model/create-user-group-dto.ts
+++ b/src/app/services/api/model/create-user-group-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface CreateUserGroupDto {
+export interface CreateUserGroupDto { 
     userId?: number;
 }
 
diff --git a/src/app/services/api/model/error-response.ts b/src/app/services/api/model/error-response.ts
index 8934461..c98aa6d 100644
--- a/src/app/services/api/model/error-response.ts
+++ b/src/app/services/api/model/error-response.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -12,7 +12,7 @@
 /**
  * the dto used to send an error response to the client
  */
-export interface ErrorResponse {
+export interface ErrorResponse { 
     /**
      * the http status code sent to the client. default is 400.
      */
diff --git a/src/app/services/api/model/get-achievement-dto.ts b/src/app/services/api/model/get-achievement-dto.ts
index 8253746..82c40ca 100644
--- a/src/app/services/api/model/get-achievement-dto.ts
+++ b/src/app/services/api/model/get-achievement-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetAchievementDto {
+export interface GetAchievementDto { 
     id?: number;
     label?: string | null;
     description?: string | null;
diff --git a/src/app/services/api/model/get-designation-dto.ts b/src/app/services/api/model/get-designation-dto.ts
index 8eb51d7..5f6f7c7 100644
--- a/src/app/services/api/model/get-designation-dto.ts
+++ b/src/app/services/api/model/get-designation-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetDesignationDto {
+export interface GetDesignationDto { 
     id?: number;
     label?: string | null;
 }
diff --git a/src/app/services/api/model/get-friend-dto.ts b/src/app/services/api/model/get-friend-dto.ts
index 0fe8c39..b414ef4 100644
--- a/src/app/services/api/model/get-friend-dto.ts
+++ b/src/app/services/api/model/get-friend-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetFriendDto {
+export interface GetFriendDto { 
     friendId?: number;
     username?: string | null;
     score?: number;
diff --git a/src/app/services/api/model/get-friend-request-dto.ts b/src/app/services/api/model/get-friend-request-dto.ts
index bdf337c..03121b5 100644
--- a/src/app/services/api/model/get-friend-request-dto.ts
+++ b/src/app/services/api/model/get-friend-request-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetFriendRequestDto {
+export interface GetFriendRequestDto { 
     userId?: number;
     username?: string | null;
     score?: number;
diff --git a/src/app/services/api/model/get-group-details-dto.ts b/src/app/services/api/model/get-group-details-dto.ts
index 689f3fb..a029b73 100644
--- a/src/app/services/api/model/get-group-details-dto.ts
+++ b/src/app/services/api/model/get-group-details-dto.ts
@@ -1,17 +1,17 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-import {GetMessageDto} from './get-message-dto';
-import {GetUserGroupDto} from './get-user-group-dto';
+import { GetMessageDto } from './get-message-dto';
+import { GetUserGroupDto } from './get-user-group-dto';
 
 
-export interface GetGroupDetailsDto {
+export interface GetGroupDetailsDto { 
     id?: number;
     label?: string | null;
     isFinished?: boolean;
diff --git a/src/app/services/api/model/get-group-dto.ts b/src/app/services/api/model/get-group-dto.ts
index c743674..6457fcd 100644
--- a/src/app/services/api/model/get-group-dto.ts
+++ b/src/app/services/api/model/get-group-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetGroupDto {
+export interface GetGroupDto { 
     id?: number;
     label?: string | null;
     isFinished?: boolean;
diff --git a/src/app/services/api/model/get-group-ranking-dto.ts b/src/app/services/api/model/get-group-ranking-dto.ts
index 2f99531..4ec52ac 100644
--- a/src/app/services/api/model/get-group-ranking-dto.ts
+++ b/src/app/services/api/model/get-group-ranking-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetGroupRankingDto {
+export interface GetGroupRankingDto { 
     userId?: number;
     username?: string | null;
     score?: number;
diff --git a/src/app/services/api/model/get-message-dto.ts b/src/app/services/api/model/get-message-dto.ts
index 05bfa11..6ff10ce 100644
--- a/src/app/services/api/model/get-message-dto.ts
+++ b/src/app/services/api/model/get-message-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetMessageDto {
+export interface GetMessageDto { 
     id?: number;
     libelle?: string | null;
     sendDate?: string;
diff --git a/src/app/services/api/model/get-proof-dto.ts b/src/app/services/api/model/get-proof-dto.ts
index 86c6ab5..971acd2 100644
--- a/src/app/services/api/model/get-proof-dto.ts
+++ b/src/app/services/api/model/get-proof-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetProofDto {
+export interface GetProofDto { 
     userId?: number;
     username?: string | null;
     proof?: string | null;
diff --git a/src/app/services/api/model/get-random-challenge-dto.ts b/src/app/services/api/model/get-random-challenge-dto.ts
index 6c430e7..765c501 100644
--- a/src/app/services/api/model/get-random-challenge-dto.ts
+++ b/src/app/services/api/model/get-random-challenge-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetRandomChallengeDto {
+export interface GetRandomChallengeDto { 
     id?: number;
     label?: string | null;
     libelle?: string | null;
diff --git a/src/app/services/api/model/get-token-dto.ts b/src/app/services/api/model/get-token-dto.ts
index 80e7d8c..bce41dd 100644
--- a/src/app/services/api/model/get-token-dto.ts
+++ b/src/app/services/api/model/get-token-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetTokenDto {
+export interface GetTokenDto { 
     token?: string | null;
 }
 
diff --git a/src/app/services/api/model/get-user-challenge-dto.ts b/src/app/services/api/model/get-user-challenge-dto.ts
index db19891..245ced5 100644
--- a/src/app/services/api/model/get-user-challenge-dto.ts
+++ b/src/app/services/api/model/get-user-challenge-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetUserChallengeDto {
+export interface GetUserChallengeDto { 
     challengeTitle?: string | null;
     challengeDescription?: string | null;
     challengeDuration?: number;
diff --git a/src/app/services/api/model/get-user-details-dto.ts b/src/app/services/api/model/get-user-details-dto.ts
index e644f7a..5821693 100644
--- a/src/app/services/api/model/get-user-details-dto.ts
+++ b/src/app/services/api/model/get-user-details-dto.ts
@@ -1,16 +1,16 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-import {GetUserStatsDto} from './get-user-stats-dto';
+import { GetUserStatsDto } from './get-user-stats-dto';
 
 
-export interface GetUserDetailsDto {
+export interface GetUserDetailsDto { 
     id?: number;
     firstName?: string | null;
     name?: string | null;
diff --git a/src/app/services/api/model/get-user-dto.ts b/src/app/services/api/model/get-user-dto.ts
index a744617..6517cdb 100644
--- a/src/app/services/api/model/get-user-dto.ts
+++ b/src/app/services/api/model/get-user-dto.ts
@@ -1,16 +1,16 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-import {GetUserStatsDto} from './get-user-stats-dto';
+import { GetUserStatsDto } from './get-user-stats-dto';
 
 
-export interface GetUserDto {
+export interface GetUserDto { 
     id?: number;
     firstName?: string | null;
     name?: string | null;
diff --git a/src/app/services/api/model/get-user-group-dto.ts b/src/app/services/api/model/get-user-group-dto.ts
index b9c7515..5f85f9d 100644
--- a/src/app/services/api/model/get-user-group-dto.ts
+++ b/src/app/services/api/model/get-user-group-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetUserGroupDto {
+export interface GetUserGroupDto { 
     id?: number;
     username?: string | null;
     grade?: string | null;
diff --git a/src/app/services/api/model/get-user-proof-dto.ts b/src/app/services/api/model/get-user-proof-dto.ts
index ebeca93..4386726 100644
--- a/src/app/services/api/model/get-user-proof-dto.ts
+++ b/src/app/services/api/model/get-user-proof-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetUserProofDto {
+export interface GetUserProofDto { 
     id?: number;
     proof?: string | null;
 }
diff --git a/src/app/services/api/model/get-user-stats-dto.ts b/src/app/services/api/model/get-user-stats-dto.ts
index f454461..2825912 100644
--- a/src/app/services/api/model/get-user-stats-dto.ts
+++ b/src/app/services/api/model/get-user-stats-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface GetUserStatsDto {
+export interface GetUserStatsDto { 
     id?: number;
     score?: number;
     totalWin?: number;
diff --git a/src/app/services/api/model/login-dto.ts b/src/app/services/api/model/login-dto.ts
index 8d85c20..62776d3 100644
--- a/src/app/services/api/model/login-dto.ts
+++ b/src/app/services/api/model/login-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface LoginDto {
+export interface LoginDto { 
     username: string;
     password: string;
 }
diff --git a/src/app/services/api/model/patch-user-designation-dto.ts b/src/app/services/api/model/patch-user-designation-dto.ts
index aa05b51..71ebcfd 100644
--- a/src/app/services/api/model/patch-user-designation-dto.ts
+++ b/src/app/services/api/model/patch-user-designation-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface PatchUserDesignationDto {
+export interface PatchUserDesignationDto { 
     designationId: number;
 }
 
diff --git a/src/app/services/api/model/patch-user-password-dto.ts b/src/app/services/api/model/patch-user-password-dto.ts
index c0087ea..f15f874 100644
--- a/src/app/services/api/model/patch-user-password-dto.ts
+++ b/src/app/services/api/model/patch-user-password-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface PatchUserPasswordDto {
+export interface PatchUserPasswordDto { 
     password: string;
 }
 
diff --git a/src/app/services/api/model/refresh-token-dto.ts b/src/app/services/api/model/refresh-token-dto.ts
index efec088..3c53563 100644
--- a/src/app/services/api/model/refresh-token-dto.ts
+++ b/src/app/services/api/model/refresh-token-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface RefreshTokenDto {
+export interface RefreshTokenDto { 
     token: string;
 }
 
diff --git a/src/app/services/api/model/update-user-dto.ts b/src/app/services/api/model/update-user-dto.ts
index b0214dd..655d66f 100644
--- a/src/app/services/api/model/update-user-dto.ts
+++ b/src/app/services/api/model/update-user-dto.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface UpdateUserDto {
+export interface UpdateUserDto { 
     firstName: string;
     name: string;
     username: string;
diff --git a/src/app/services/api/model/user-proof-request.ts b/src/app/services/api/model/user-proof-request.ts
index 5e81efd..895b96a 100644
--- a/src/app/services/api/model/user-proof-request.ts
+++ b/src/app/services/api/model/user-proof-request.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface UserProofRequest {
+export interface UserProofRequest { 
     proof?: Blob | null;
 }
 
diff --git a/src/app/services/api/model/user-vote-request.ts b/src/app/services/api/model/user-vote-request.ts
index cb671df..6451aa5 100644
--- a/src/app/services/api/model/user-vote-request.ts
+++ b/src/app/services/api/model/user-vote-request.ts
@@ -1,7 +1,7 @@
 /**
  * BeReadyBackend
  *
- *
+ * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
  * https://openapi-generator.tech
@@ -9,7 +9,7 @@
  */
 
 
-export interface UserVoteRequest {
+export interface UserVoteRequest { 
     votedProofId?: number;
 }
 
diff --git a/src/app/services/api/param.ts b/src/app/services/api/param.ts
index 7f0592c..78a2d20 100644
--- a/src/app/services/api/param.ts
+++ b/src/app/services/api/param.ts
@@ -2,14 +2,14 @@
  * Standard parameter styles defined by OpenAPI spec
  */
 export type StandardParamStyle =
-    | 'matrix'
-    | 'label'
-    | 'form'
-    | 'simple'
-    | 'spaceDelimited'
-    | 'pipeDelimited'
-    | 'deepObject'
-    ;
+  | 'matrix'
+  | 'label'
+  | 'form'
+  | 'simple'
+  | 'spaceDelimited'
+  | 'pipeDelimited'
+  | 'deepObject'
+  ;
 
 /**
  * The OpenAPI standard {@link StandardParamStyle}s may be extended by custom styles by the user.
@@ -25,13 +25,13 @@ export type ParamLocation = 'query' | 'header' | 'path' | 'cookie';
  * Standard types as defined in <a href="https://swagger.io/specification/#data-types">OpenAPI Specification: Data Types</a>
  */
 export type StandardDataType =
-    | "integer"
-    | "number"
-    | "boolean"
-    | "string"
-    | "object"
-    | "array"
-    ;
+  | "integer"
+  | "number"
+  | "boolean"
+  | "string"
+  | "object"
+  | "array"
+  ;
 
 /**
  * Standard {@link DataType}s plus your own types/classes.
@@ -42,16 +42,16 @@ export type DataType = StandardDataType | string;
  * Standard formats as defined in <a href="https://swagger.io/specification/#data-types">OpenAPI Specification: Data Types</a>
  */
 export type StandardDataFormat =
-    | "int32"
-    | "int64"
-    | "float"
-    | "double"
-    | "byte"
-    | "binary"
-    | "date"
-    | "date-time"
-    | "password"
-    ;
+  | "int32"
+  | "int64"
+  | "float"
+  | "double"
+  | "byte"
+  | "binary"
+  | "date"
+  | "date-time"
+  | "password"
+  ;
 
 export type DataFormat = StandardDataFormat | string;
 
@@ -59,11 +59,11 @@ export type DataFormat = StandardDataFormat | string;
  * The parameter to encode.
  */
 export interface Param {
-    name: string;
-    value: unknown;
-    in: ParamLocation;
-    style: ParamStyle,
-    explode: boolean;
-    dataType: DataType;
-    dataFormat: DataFormat | undefined;
+  name: string;
+  value: unknown;
+  in: ParamLocation;
+  style: ParamStyle,
+  explode: boolean;
+  dataType: DataType;
+  dataFormat: DataFormat | undefined;
 }
diff --git a/src/app/services/api/provide-api.ts b/src/app/services/api/provide-api.ts
index b63aa71..19c762a 100644
--- a/src/app/services/api/provide-api.ts
+++ b/src/app/services/api/provide-api.ts
@@ -1,15 +1,15 @@
-import {EnvironmentProviders, makeEnvironmentProviders} from "@angular/core";
-import {Configuration, ConfigurationParameters} from './configuration';
-import {BASE_PATH} from './variables';
+import { EnvironmentProviders, makeEnvironmentProviders } from "@angular/core";
+import { Configuration, ConfigurationParameters } from './configuration';
+import { BASE_PATH } from './variables';
 
 // Returns the service class providers, to be used in the [ApplicationConfig](https://angular.dev/api/core/ApplicationConfig).
 export function provideApi(configOrBasePath: string | ConfigurationParameters): EnvironmentProviders {
     return makeEnvironmentProviders([
         typeof configOrBasePath === "string"
-            ? {provide: BASE_PATH, useValue: configOrBasePath}
+            ? { provide: BASE_PATH, useValue: configOrBasePath }
             : {
                 provide: Configuration,
-                useValue: new Configuration({...configOrBasePath}),
+                useValue: new Configuration({ ...configOrBasePath }),
             },
     ]);
 }
\ No newline at end of file
diff --git a/src/app/services/api/query.params.ts b/src/app/services/api/query.params.ts
index 9ee66e3..4076c11 100644
--- a/src/app/services/api/query.params.ts
+++ b/src/app/services/api/query.params.ts
@@ -1,5 +1,5 @@
-import {HttpParams, HttpParameterCodec} from '@angular/common/http';
-import {CustomHttpParameterCodec, IdentityHttpParameterCodec} from './encoder';
+import { HttpParams, HttpParameterCodec } from '@angular/common/http';
+import { CustomHttpParameterCodec, IdentityHttpParameterCodec } from './encoder';
 
 export enum QueryParamStyle {
     Json,
@@ -153,7 +153,7 @@ export function concatHttpParamsObject(httpParams: OpenApiHttpParams, key: strin
 
 function convertToString(value: any): string {
     if (value instanceof Date) {
-        return value.toISOString();
+         return value.toISOString();
     } else {
         return value.toString();
     }
diff --git a/src/app/services/api/variables.ts b/src/app/services/api/variables.ts
index ac9262f..6fe5854 100644
--- a/src/app/services/api/variables.ts
+++ b/src/app/services/api/variables.ts
@@ -1,4 +1,4 @@
-import {InjectionToken} from '@angular/core';
+import { InjectionToken } from '@angular/core';
 
 export const BASE_PATH = new InjectionToken<string>('basePath');
 export const COLLECTION_FORMATS = {