added functions and web-socket to chat in group

src/app/components/message-form/message-form.component.html

@@ -1,7 +1,7 @@
-<form [formGroup]="messageForm" class="relative">
+<form [formGroup]="messageForm">
-    <ion-item lines="none" class="rounded-2xl border border-stone-200 fixed bottom-4 left-4 right-4">
+    <ion-item lines="none" class="rounded-2xl border border-stone-200 mt-2">
-        <ion-input placeholder="Envoyer un message ..." formControlName="libelle"></ion-input>
+        <ion-input placeholder="Envoyer un message..." formControlName="libelle"></ion-input>
-        <ion-button style="--background: white">
+        <ion-button style="--background: white" (click)="sendMessageOnGroup()">
             <ion-icon name="send-outline" class="text-xl text-stone-400"></ion-icon>
         </ion-button>
     </ion-item>

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

@@ -1,8 +1,10 @@
-import {Component} from '@angular/core';
+import {Component, inject, input} from '@angular/core';
-import {IonicModule} from "@ionic/angular";
+import {IonicModule, LoadingController, ToastController} from "@ionic/angular";
 import {FormControl, FormGroup, ReactiveFormsModule, Validators} from "@angular/forms";
 import {addIcons} from "ionicons";
 import {sendOutline} from 'ionicons/icons';
+import {GetGroupDetailsDto, MessagesService} from "../../services/api";
+import {firstValueFrom} from "rxjs";
 addIcons({
     "send-outline" : sendOutline
 })
@@ -17,7 +19,48 @@ addIcons({
     ]
 })
 export class MessageFormComponent {
+    private messagesService = inject(MessagesService);
+    private loadCtrl = inject(LoadingController);
+    private toastCtrl = inject(ToastController);
+
+    groupId = input.required<GetGroupDetailsDto["id"]>();
+
     messageForm: FormGroup = new FormGroup({
         libelle: new FormControl<string>(null, [Validators.required]),
     })
+
+    async sendMessageOnGroup(){
+        const loading = await this.loadCtrl.create({
+            message: 'Envoi...',
+            spinner: 'lines-sharp-small'
+        });
+        await loading.present();
+
+        if (this.messageForm.invalid) {
+            this.messageForm.reset();
+            const toast = await this.toastCtrl.create({
+                message: 'Message incorrect',
+                duration: 2000,
+                color: 'danger'
+            });
+            await toast.present();
+
+            return;
+        }
+
+        try {
+            await firstValueFrom(this.messagesService.sendMessageEndpoint(this.groupId(), this.messageForm.getRawValue()));
+            this.messageForm.reset();
+        }
+        catch {
+            const toast = await this.toastCtrl.create({
+                message: 'Impossible d\'envoyer le messages.',
+                duration: 2000,
+                color: 'danger'
+            });
+            await toast.present();
+            this.messageForm.reset();
+        }
+        await loading.dismiss();
+    }
 }

src/app/components/message/message.component.html

@@ -1,36 +1,7 @@
 @if (messages().length) {
-    @for (message of messages(); track message.id) {
+    <div class="overflow-scroll h-11/12">
-        @if (message.userId === currentUser) {
+        <app-messages-list [messages]="messages()"></app-messages-list>
-            <div class="flex flex-row-reverse items-end">
-                <div class="flex flex-col items-end">
-                    <div class="px-3.5 py-2 text-sm rounded-3xl rounded-br-sm bg-violet-700 text-white">
-                        {{ message.libelle }}
     </div>
-                    <span class="text-[10px] mt-0.5 mr-1">
-          {{ message.sendDate | date:'HH:mm' }}
-        </span>
-                </div>
-            </div>
-
-        } @else {
-            <div class="flex items-end gap-2">
-                <div class="w-8 h-8 rounded-full flex items-center justify-center text-xs mb-2 bg-teal-100 text-teal-700">
-                    {{ message.username.substring(0, 2) }}
-                </div>
-                <div class="flex flex-col">
-                <span class="text-[11px] mb-1 ml-1">
-                  {{ message.username }}
-                </span>
-                    <div class="px-3.5 py-2 text-sm rounded-3xl rounded-bl-sm border">
-                        {{ message.libelle }}
-                    </div>
-                    <span class="text-[10px] mt-0.5 mx-1">
-                  {{ message.sendDate | date:'HH:mm' }}
-                </span>
-                </div>
-            </div>
-        }
-    }
 } @else {
     <ion-item lines="none" class="mt-[60%]" style="--background: #F7F6F2;">
         <div class="flex flex-col items-center w-full gap-3">
@@ -49,3 +20,5 @@
         </div>
     </ion-item>
 }
+
+<app-message-form [groupId]="groupId()"></app-message-form>

src/app/components/message/message.component.ts

@@ -1,12 +1,12 @@
-import {Component, inject, input, OnInit, signal} from '@angular/core';
+import {Component, inject, input, OnDestroy, OnInit} from '@angular/core';
-import {GetGroupDetailsDto, GetMessageDto, MessagesService} from "../../services/api";
+import {GetGroupDetailsDto, MessagesService} from "../../services/api";
 import {firstValueFrom} from "rxjs";
 import {IonicModule, LoadingController, ToastController} from "@ionic/angular";
-import {AuthManageService} from "../../services/auth-manage";
-import {jwtDecode} from "jwt-decode";
-import {DatePipe} from "@angular/common";
 import {addIcons} from "ionicons";
 import {chatbubbleEllipsesOutline, moonOutline} from 'ionicons/icons';
+import {ChatService} from "../../services/chat-service";
+import {MessagesListComponent} from "../messages-list/messages-list.component";
+import {MessageFormComponent} from "../message-form/message-form.component";
 
 addIcons({
     "chatbubble-ellipses-outline" : chatbubbleEllipsesOutline,
@@ -18,21 +18,20 @@ addIcons({
     templateUrl: './message.component.html',
     styleUrls: ['./message.component.scss'],
     imports: [
-        DatePipe,
+        IonicModule,
-        IonicModule
+        MessagesListComponent,
+        MessageFormComponent
     ]
 })
-export class MessageComponent implements OnInit {
+export class MessageComponent implements OnInit, OnDestroy {
     private messagesService = inject(MessagesService);
-    private authService = inject(AuthManageService);
     private loadCtrl = inject(LoadingController);
     private toastCtrl = inject(ToastController);
+    private chatService = inject(ChatService);
 
-    messages = signal<GetMessageDto[]>([]);
+    messages = this.chatService.messages;
     groupId = input.required<GetGroupDetailsDto["id"]>();
 
-    currentUser = 0;
-
     async ngOnInit() {
         const loading = await this.loadCtrl.create({
             message: 'Chargement...',
@@ -42,8 +41,8 @@ export class MessageComponent implements OnInit {
 
         try {
             const messages = await firstValueFrom(this.messagesService.getMessagesEndpoint(this.groupId()));
-            this.messages.set(messages);
+            this.chatService.setMessages(messages);
-            this.currentUser = Number(jwtDecode<any>(this.authService.getToken()).UserId);
+            await this.chatService.connect(this.groupId());
         }
         catch {
             const toast = await this.toastCtrl.create({
@@ -55,4 +54,8 @@ export class MessageComponent implements OnInit {
         }
         await loading.dismiss();
     }
+
+    async ngOnDestroy() {
+        await this.chatService.disconnect();
+    }
 }

src/app/pages/home/home.component.html

@@ -50,7 +50,6 @@
     @if (groupSelected()) {
         <app-modal>
             <app-message [groupId]="groupSelected().id"></app-message>
-            <app-message-form></app-message-form>
         </app-modal>
     }
 </ion-content>

src/app/services/api/README.md

@@ -59,9 +59,9 @@ In your Angular project:
 
 ```typescript
 
-import {ApplicationConfig} from '@angular/core';
+import { ApplicationConfig } from '@angular/core';
-import {provideHttpClient} from '@angular/common/http';
+import { provideHttpClient } from '@angular/common/http';
-import {provideApi} from '';
+import { provideApi } from '';
 
 export const appConfig: ApplicationConfig = {
     providers: [
@@ -73,19 +73,17 @@ export const appConfig: ApplicationConfig = {
 ```
 
 **NOTE**
-If you're still using `AppModule` and haven't [migrated](https://angular.dev/reference/migrations/standalone) yet, you
+If you're still using `AppModule` and haven't [migrated](https://angular.dev/reference/migrations/standalone) yet, you can still import an Angular module:
-can still import an Angular module:
-
 ```typescript
-import {ApiModule} from '';
+import { ApiModule } from '';
 ```
 
 If different from the generated base path, during app bootstrap, you can provide the base path to your service.
 
 ```typescript
-import {ApplicationConfig} from '@angular/core';
+import { ApplicationConfig } from '@angular/core';
-import {provideHttpClient} from '@angular/common/http';
+import { provideHttpClient } from '@angular/common/http';
-import {provideApi} from '';
+import { provideApi } from '';
 
 export const appConfig: ApplicationConfig = {
     providers: [
@@ -98,9 +96,9 @@ export const appConfig: ApplicationConfig = {
 
 ```typescript
 // with a custom configuration
-import {ApplicationConfig} from '@angular/core';
+import { ApplicationConfig } from '@angular/core';
-import {provideHttpClient} from '@angular/common/http';
+import { provideHttpClient } from '@angular/common/http';
-import {provideApi} from '';
+import { provideApi } from '';
 
 export const appConfig: ApplicationConfig = {
     providers: [
@@ -117,9 +115,9 @@ export const appConfig: ApplicationConfig = {
 
 ```typescript
 // with factory building a custom configuration
-import {ApplicationConfig} from '@angular/core';
+import { ApplicationConfig } from '@angular/core';
-import {provideHttpClient} from '@angular/common/http';
+import { provideHttpClient } from '@angular/common/http';
-import {provideApi, Configuration} from '';
+import { provideApi, Configuration } from '';
 
 export const appConfig: ApplicationConfig = {
     providers: [
@@ -147,10 +145,10 @@ you can create an alias name when importing the modules
 in order to avoid naming conflicts:
 
 ```typescript
-import {provideApi as provideUserApi} from 'my-user-api-path';
+import { provideApi as provideUserApi } from 'my-user-api-path';
-import {provideApi as provideAdminApi} from 'my-admin-api-path';
+import { provideApi as provideAdminApi } from 'my-admin-api-path';
-import {HttpClientModule} from '@angular/common/http';
+import { HttpClientModule } from '@angular/common/http';
-import {environment} from '../environments/environment';
+import { environment } from '../environments/environment';
 
 export const appConfig: ApplicationConfig = {
     providers: [
@@ -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

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

@@ -7,10 +7,10 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-import {HttpHeaders, HttpParams, HttpParameterCodec} from '@angular/common/http';
+import { HttpHeaders, HttpParams, HttpParameterCodec } from '@angular/common/http';
-import {CustomHttpParameterCodec} from './encoder';
+import { CustomHttpParameterCodec } from './encoder';
-import {Configuration} from './configuration';
+import { Configuration } from './configuration';
-import {OpenApiHttpParams, QueryParamStyle, concatHttpParamsObject} from './query.params';
+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;

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

@@ -1,6 +1,6 @@
-import {NgModule, ModuleWithProviders, SkipSelf, Optional} from '@angular/core';
+import { NgModule, ModuleWithProviders, SkipSelf, Optional } from '@angular/core';
-import {Configuration} from './configuration';
+import { Configuration } from './configuration';
-import {HttpClient} from '@angular/common/http';
+import { HttpClient } from '@angular/common/http';
 
 
 @NgModule({
@@ -13,11 +13,11 @@ 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,
+    constructor( @Optional() @SkipSelf() parentModule: ApiModule,
                  @Optional() http: HttpClient) {
         if (parentModule) {
             throw new Error('ApiModule is already loaded. Import in your base AppModule only.');

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

@@ -9,23 +9,23 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+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 { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -33,7 +33,7 @@ import {BaseService} from '../api.base.service';
 })
 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?: {
+    public getAllAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAchievementDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAchievementDto>>>;
-        context?: HttpContext,
+    public getAllAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAchievementDto>>>;
-        transferCache?: boolean
+    public getAllAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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?: {
+    public getLockedAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAchievementDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getLockedAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAchievementDto>>>;
-        context?: HttpContext,
+    public getLockedAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAchievementDto>>>;
-        transferCache?: boolean
+    public getLockedAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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?: {
+    public getUserAchievementsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetAchievementDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getUserAchievementsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetAchievementDto>>>;
-        context?: HttpContext,
+    public getUserAchievementsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetAchievementDto>>>;
-        transferCache?: boolean
+    public getUserAchievementsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );
@@ -254,26 +206,10 @@ export class AchievementsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public unlockAchievementEndpoint(achievementId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: 'application/problem+json',
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public unlockAchievementEndpoint(achievementId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public unlockAchievementEndpoint(achievementId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        let localVarPath = `/API/Achievements/${this.configuration.encodeParam({name: "achievementId", value: achievementId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users`;
-            name: "achievementId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );

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

@@ -1,31 +1,21 @@
 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 './posts.service';
-import {PostsService} from './posts.service';
+import { PostsService } from './posts.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, PostsService, RandomchallengesService, UsersService];

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

@@ -9,27 +9,27 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+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 { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -37,7 +37,7 @@ import {BaseService} from '../api.base.service';
 })
 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);
     }
 
@@ -48,26 +48,10 @@ export class AuthService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public loginEndpoint(loginDto: LoginDto, observe?: 'body', reportProgress?: boolean, options?: {
+    public loginEndpoint(loginDto: LoginDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<GetTokenDto>;
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
+    public loginEndpoint(loginDto: LoginDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetTokenDto>>;
-        context?: HttpContext,
+    public loginEndpoint(loginDto: LoginDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetTokenDto>>;
-        transferCache?: boolean
+    public loginEndpoint(loginDto: LoginDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );
@@ -130,26 +114,10 @@ export class AuthService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'body', reportProgress?: boolean, options?: {
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<GetTokenDto>;
-        httpHeaderAccept?: 'application/json' | 'application/problem+json',
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetTokenDto>>;
-        context?: HttpContext,
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetTokenDto>>;
-        transferCache?: boolean
+    public refreshTokenEndpoint(refreshTokenDto: RefreshTokenDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json' | 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );

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

@@ -9,21 +9,21 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+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 { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -31,7 +31,7 @@ import {BaseService} from '../api.base.service';
 })
 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?: {
+    public getAllDesignationsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetDesignationDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllDesignationsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetDesignationDto>>>;
-        context?: HttpContext,
+    public getAllDesignationsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetDesignationDto>>>;
-        transferCache?: boolean
+    public getAllDesignationsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );

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

@@ -9,23 +9,23 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+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 { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -33,7 +33,7 @@ import {BaseService} from '../api.base.service';
 })
 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);
     }
 
@@ -44,26 +44,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public acceptFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public acceptFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public acceptFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Request`;
-            name: "friendId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -124,26 +101,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteFriendEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public deleteFriendEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public deleteFriendEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public deleteFriendEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public deleteFriendEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
-            name: "friendId",
+        const { basePath, withCredentials } = this.configuration;
-            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?: {
+    public getAllFriendRequestsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetFriendRequestDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllFriendRequestsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetFriendRequestDto>>>;
-        context?: HttpContext,
+    public getAllFriendRequestsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetFriendRequestDto>>>;
-        transferCache?: boolean
+    public getAllFriendRequestsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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?: {
+    public getAllFriendsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetFriendDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllFriendsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetFriendDto>>>;
-        context?: HttpContext,
+    public getAllFriendsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetFriendDto>>>;
-        transferCache?: boolean
+    public getAllFriendsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );
@@ -344,26 +266,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public rejectFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public rejectFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public rejectFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Request`;
-            name: "friendId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -424,26 +323,10 @@ export class FriendsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public sendFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public sendFriendRequestEndpoint(friendId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public sendFriendRequestEndpoint(friendId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        let localVarPath = `/API/Friends/${this.configuration.encodeParam({name: "friendId", value: friendId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
-            name: "friendId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );

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

@@ -9,29 +9,29 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+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 {GetUserGroupDto} from '../model/get-user-group-dto';
+import { GetUserGroupDto } from '../model/get-user-group-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -39,7 +39,7 @@ import {BaseService} from '../api.base.service';
 })
 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);
     }
 
@@ -51,26 +51,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public addUserToGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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.');
         }
@@ -83,7 +67,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);
         }
@@ -104,32 +89,16 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+        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"})}`;
-            name: "groupId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -142,26 +111,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'body', reportProgress?: boolean, options?: {
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: 'application/problem+json',
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public createGroupEndpoint(createGroupDto: CreateGroupDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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.');
         }
@@ -204,16 +157,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
             }
         );
@@ -226,26 +179,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public deleteGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public deleteGroupEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public deleteGroupEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public deleteGroupEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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.');
         }
@@ -255,7 +192,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);
         }
@@ -276,24 +214,16 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
-            name: "id",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -307,26 +237,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public deleteUserFromGroupEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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.');
         }
@@ -339,7 +253,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);
         }
@@ -360,32 +275,16 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+        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"})}`;
-            name: "groupId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -398,26 +297,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllGroupUsersEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public getAllGroupUsersEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserGroupDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllGroupUsersEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserGroupDto>>>;
-        context?: HttpContext,
+    public getAllGroupUsersEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserGroupDto>>>;
-        transferCache?: boolean
+    public getAllGroupUsersEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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.');
         }
@@ -450,24 +333,16 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Users`;
-            name: "id",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -479,26 +354,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?: {
+    public getAllGroupsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetGroupDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllGroupsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetGroupDto>>>;
-        context?: HttpContext,
+    public getAllGroupsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetGroupDto>>>;
-        transferCache?: boolean
+    public getAllGroupsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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;
 
@@ -529,15 +388,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
             }
         );
@@ -550,26 +409,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getGroupDetailsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public getGroupDetailsEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetGroupDetailsDto>;
-        httpHeaderAccept?: 'application/json',
+    public getGroupDetailsEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetGroupDetailsDto>>;
-        context?: HttpContext,
+    public getGroupDetailsEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetGroupDetailsDto>>;
-        transferCache?: boolean
+    public getGroupDetailsEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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.');
         }
@@ -602,24 +445,16 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
-            name: "id",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -632,26 +467,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public leaveGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public leaveGroupEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public leaveGroupEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public leaveGroupEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public leaveGroupEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): Observable<any>;
-    public leaveGroupEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public leaveGroupEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public leaveGroupEndpoint(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 leaveGroupEndpoint.');
         }
@@ -661,7 +480,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);
         }
@@ -682,24 +502,16 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+        let localVarPath = `/API/Groups/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/User`;
-            name: "id",
+        const { basePath, withCredentials } = this.configuration;
-            value: id,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/User`;
-        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
             }
         );
@@ -713,26 +525,10 @@ export class GroupsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetGroupDetailsDto>;
-        httpHeaderAccept?: 'application/json',
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetGroupDetailsDto>>;
-        context?: HttpContext,
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetGroupDetailsDto>>;
-        transferCache?: boolean
+    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): Observable<GetGroupDetailsDto>;
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<GetGroupDetailsDto>>;
-    public patchGroupUserRoleEndpoint(groupId: number, userId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<GetGroupDetailsDto>>;
-    public patchGroupUserRoleEndpoint(groupId: number, userId: 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 patchGroupUserRoleEndpoint.');
         }
@@ -768,32 +564,16 @@ export class GroupsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Groups/${this.configuration.encodeParam({
+        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`;
-            name: "groupId",
+        const { basePath, withCredentials } = this.configuration;
-            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<GetGroupDetailsDto>('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
             }
         );

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

@@ -9,25 +9,25 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+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 { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -35,7 +35,7 @@ import {BaseService} from '../api.base.service';
 })
 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);
     }
 
@@ -47,26 +47,10 @@ export class MessagesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public deleteMessageEndpoint(id: number, groupId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public deleteMessageEndpoint(id: number, groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        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"})}`;
-            name: "id",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -138,26 +107,10 @@ export class MessagesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getMessagesEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public getMessagesEndpoint(groupId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetMessageDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getMessagesEndpoint(groupId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetMessageDto>>>;
-        context?: HttpContext,
+    public getMessagesEndpoint(groupId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetMessageDto>>>;
-        transferCache?: boolean
+    public getMessagesEndpoint(groupId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
-            name: "groupId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -221,26 +166,10 @@ export class MessagesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'body', reportProgress?: boolean, options?: {
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: 'application/problem+json',
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public sendMessageEndpoint(groupId: number, createMessageDto: CreateMessageDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        let localVarPath = `/API/Messages/Groups/${this.configuration.encodeParam({name: "groupId", value: groupId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
-            name: "groupId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );

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

@@ -9,21 +9,21 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+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 { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -31,7 +31,7 @@ import {BaseService} from '../api.base.service';
 })
 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?: {
+    public getOverallRankingEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getOverallRankingEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserDto>>>;
-        context?: HttpContext,
+    public getOverallRankingEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserDto>>>;
-        transferCache?: boolean
+    public getOverallRankingEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );

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

@@ -9,21 +9,21 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
-import {GetPostDto} from '../model/get-post-dto';
+import { GetPostDto } from '../model/get-post-dto';
 
 // @ts-ignore
-import {BASE_PATH, COLLECTION_FORMATS} from '../variables';
+import { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -31,7 +31,7 @@ import {BaseService} from '../api.base.service';
 })
 export class PostsService 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 PostsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getAllPostsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {
+    public getAllPostsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetPostDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllPostsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetPostDto>>>;
-        context?: HttpContext,
+    public getAllPostsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetPostDto>>>;
-        transferCache?: boolean
+    public getAllPostsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): Observable<Array<GetPostDto>>;
-    public getAllPostsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<Array<GetPostDto>>>;
-    public getAllPostsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json',
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<Array<GetPostDto>>>;
-    public getAllPostsEndpoint(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 PostsService extends BaseService {
         }
 
         let localVarPath = `/API/Posts`;
-        const {basePath, withCredentials} = this.configuration;
+        const { basePath, withCredentials } = this.configuration;
         return this.httpClient.request<Array<GetPostDto>>('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
             }
         );
@@ -112,26 +96,10 @@ export class PostsService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchLikeEndpoint(postId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public patchLikeEndpoint(postId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public patchLikeEndpoint(postId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public patchLikeEndpoint(postId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public patchLikeEndpoint(postId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): Observable<any>;
-    public patchLikeEndpoint(postId: number, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public patchLikeEndpoint(postId: number, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public patchLikeEndpoint(postId: number, observe: any = 'body', reportProgress: boolean = false, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<any> {
         if (postId === null || postId === undefined) {
             throw new Error('Required parameter postId was null or undefined when calling patchLikeEndpoint.');
         }
@@ -141,7 +109,8 @@ export class PostsService 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);
         }
@@ -162,24 +131,16 @@ export class PostsService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/Posts/${this.configuration.encodeParam({
+        let localVarPath = `/API/Posts/${this.configuration.encodeParam({name: "postId", value: postId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Like`;
-            name: "postId",
+        const { basePath, withCredentials } = this.configuration;
-            value: postId,
-            in: "path",
-            style: "simple",
-            explode: false,
-            dataType: "number",
-            dataFormat: "int32"
-        })}/Like`;
-        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
             }
         );

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

@@ -9,21 +9,21 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+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 { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -31,7 +31,7 @@ import {BaseService} from '../api.base.service';
 })
 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?: {
+    public generateRandomChallengeEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetRandomChallengeDto>;
-        httpHeaderAccept?: 'application/json',
+    public generateRandomChallengeEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetRandomChallengeDto>>;
-        context?: HttpContext,
+    public generateRandomChallengeEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetRandomChallengeDto>>;
-        transferCache?: boolean
+    public generateRandomChallengeEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );
@@ -112,26 +96,10 @@ export class RandomchallengesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetRandomChallengeDto>;
-        httpHeaderAccept?: 'application/json',
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetRandomChallengeDto>>;
-        context?: HttpContext,
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetRandomChallengeDto>>;
-        transferCache?: boolean
+    public getRandomChallengeEndpoint(randomChallengeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({name: "randomChallengeId", value: randomChallengeId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
-            name: "randomChallengeId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -196,26 +156,10 @@ export class RandomchallengesService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'body', reportProgress?: boolean, options?: {
+    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): Observable<any>;
-    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpResponse<any>>;
-    public patchProofEndpoint(randomChallengeId: number, libelle?: string, proof?: Blob, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: undefined,
-        context?: HttpContext,
-        transferCache?: boolean
-    }): Observable<HttpEvent<any>>;
-    public patchProofEndpoint(randomChallengeId: number, libelle?: string, 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.');
         }
@@ -225,7 +169,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);
         }
@@ -271,25 +216,17 @@ export class RandomchallengesService extends BaseService {
             }
         }
 
-        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({
+        let localVarPath = `/API/RandomChallenges/${this.configuration.encodeParam({name: "randomChallengeId", value: randomChallengeId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}/Proof`;
-            name: "randomChallengeId",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );

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

@@ -9,37 +9,37 @@
  */
 /* tslint:disable:no-unused-variable member-ordering */
 
-import {Inject, Injectable, Optional} from '@angular/core';
+import { Inject, Injectable, Optional }                      from '@angular/core';
-import {
+import { HttpClient, HttpHeaders, HttpParams,
-    HttpClient, HttpHeaders, HttpParams,
          HttpResponse, HttpEvent, HttpContext 
-} from '@angular/common/http';
+        }       from '@angular/common/http';
-import {Observable} from 'rxjs';
+import { Observable }                                        from 'rxjs';
-import {OpenApiHttpParams, QueryParamStyle} from '../query.params';
+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 { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';
-import {Configuration} from '../configuration';
+import { Configuration }                                     from '../configuration';
-import {BaseService} from '../api.base.service';
+import { BaseService } from '../api.base.service';
+
 
 
 @Injectable({
@@ -47,7 +47,7 @@ import {BaseService} from '../api.base.service';
 })
 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);
     }
 
@@ -58,26 +58,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: 'application/problem+json',
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public createUserEndpoint(createUserDto: CreateUserDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public createUserEndpoint(createUserDto: CreateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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?: {
+    public deleteUserEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: undefined,
+    public deleteUserEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public deleteUserEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public deleteUserEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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?: {
+    public getAllUserChallengesEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserChallengeDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllUserChallengesEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserChallengeDto>>>;
-        context?: HttpContext,
+    public getAllUserChallengesEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserChallengeDto>>>;
-        transferCache?: boolean
+    public getAllUserChallengesEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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?: {
+    public getAllUserProofsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserProofDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllUserProofsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserProofDto>>>;
-        context?: HttpContext,
+    public getAllUserProofsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserProofDto>>>;
-        transferCache?: boolean
+    public getAllUserProofsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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?: {
+    public getAllUsersEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<GetUserDto>>;
-        httpHeaderAccept?: 'application/json',
+    public getAllUsersEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<GetUserDto>>>;
-        context?: HttpContext,
+    public getAllUsersEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<GetUserDto>>>;
-        transferCache?: boolean
+    public getAllUsersEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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?: {
+    public getUserDetailsEndpoint(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetUserDetailsDto>;
-        httpHeaderAccept?: 'application/json',
+    public getUserDetailsEndpoint(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetUserDetailsDto>>;
-        context?: HttpContext,
+    public getUserDetailsEndpoint(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetUserDetailsDto>>;
-        transferCache?: boolean
+    public getUserDetailsEndpoint(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );
@@ -487,26 +392,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public getUserEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+    public getUserEndpoint(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<GetUserDto>;
-        httpHeaderAccept?: 'application/json',
+    public getUserEndpoint(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<GetUserDto>>;
-        context?: HttpContext,
+    public getUserEndpoint(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<GetUserDto>>;
-        transferCache?: boolean
+    public getUserEndpoint(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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({
+        let localVarPath = `/API/Users/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int32"})}`;
-            name: "id",
+        const { basePath, withCredentials } = this.configuration;
-            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
             }
         );
@@ -569,26 +450,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'body', reportProgress?: boolean, options?: {
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: 'application/problem+json',
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public patchUserDesignationEndpoint(patchUserDesignationDto: PatchUserDesignationDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );
@@ -653,26 +518,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'body', reportProgress?: boolean, options?: {
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: 'application/problem+json',
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public patchUserPasswordEndpoint(patchUserPasswordDto: PatchUserPasswordDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );
@@ -737,26 +586,10 @@ export class UsersService extends BaseService {
      * @param reportProgress flag to report request and response progress.
      * @param options additional options
      */
-    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'body', reportProgress?: boolean, options?: {
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
-        httpHeaderAccept?: 'application/problem+json',
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
-        context?: HttpContext,
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
-        transferCache?: boolean
+    public updateUserEndpoint(updateUserDto: UpdateUserDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/problem+json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
-    }): 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
             }
         );

src/app/services/api/configuration.ts

@@ -1,12 +1,12 @@
-import {HttpHeaders, HttpParameterCodec} from '@angular/common/http';
+import { HttpHeaders, HttpParameterCodec } from '@angular/common/http';
-import {Param} from './param';
+import { Param } from './param';
-import {OpenApiHttpParams} from './query.params';
+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({
+constructor({ accessToken, apiKeys, basePath, credentials, encodeParam, encoder, password, username, withCredentials }: ConfigurationParameters = {}) {
-                    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;
         }

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;
     }

src/app/services/api/model/create-group-dto.ts

@@ -7,7 +7,7 @@
  * 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 { 

src/app/services/api/model/create-message-dto.ts

@@ -11,6 +11,5 @@
 
 export interface CreateMessageDto { 
     libelle: string;
-    sendDate: string;
 }
 

src/app/services/api/model/get-group-details-dto.ts

@@ -7,8 +7,8 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-import {GetMessageDto} from './get-message-dto';
+import { GetMessageDto } from './get-message-dto';
-import {GetUserGroupDto} from './get-user-group-dto';
+import { GetUserGroupDto } from './get-user-group-dto';
 
 
 export interface GetGroupDetailsDto { 

src/app/services/api/model/get-user-details-dto.ts

@@ -7,7 +7,7 @@
  * 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 { 

src/app/services/api/model/get-user-dto.ts

@@ -7,7 +7,7 @@
  * 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 { 

src/app/services/api/provide-api.ts

@@ -1,15 +1,15 @@
-import {EnvironmentProviders, makeEnvironmentProviders} from "@angular/core";
+import { EnvironmentProviders, makeEnvironmentProviders } from "@angular/core";
-import {Configuration, ConfigurationParameters} from './configuration';
+import { Configuration, ConfigurationParameters } from './configuration';
-import {BASE_PATH} from './variables';
+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 }),
             },
     ]);
 }

src/app/services/api/query.params.ts

@@ -1,5 +1,5 @@
-import {HttpParams, HttpParameterCodec} from '@angular/common/http';
+import { HttpParams, HttpParameterCodec } from '@angular/common/http';
-import {CustomHttpParameterCodec, IdentityHttpParameterCodec} from './encoder';
+import { CustomHttpParameterCodec, IdentityHttpParameterCodec } from './encoder';
 
 export enum QueryParamStyle {
     Json,

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 = {

src/app/services/chat-service.ts

@@ -0,0 +1,46 @@
+import {Injectable, signal} from "@angular/core";
+import {GetMessageDto} from "./api";
+import * as signalR from '@microsoft/signalr';
+
+@Injectable({
+    providedIn: 'root'
+})
+
+export class ChatService {
+    private hubConnection!: signalR.HubConnection;
+
+    messages = signal<GetMessageDto[]>([]);
+
+    async connect(groupId: number) {
+        if (this.hubConnection) return;
+
+        this.hubConnection = new signalR.HubConnectionBuilder()
+            .withUrl(`http://localhost:5235/groupHub?groupId=${groupId}`)
+            .withAutomaticReconnect()
+            .build();
+
+        await this.hubConnection.start();
+
+        this.hubConnection.on(
+            'ReceiveMessage',
+            (message: GetMessageDto) => {
+
+                this.messages.update(messages => [
+                    ...messages,
+                    message
+                ]);
+            }
+        );
+    }
+
+    async disconnect() {
+        if (this.hubConnection) {
+            await this.hubConnection.stop();
+            this.hubConnection = undefined!;
+        }
+    }
+
+    setMessages(messages: GetMessageDto[]) {
+        this.messages.set(messages);
+    }
+}

src/app/services/friends-state.ts

@@ -1,6 +1,6 @@
 import {inject, Injectable, signal} from '@angular/core';
 import {FriendsService, GetFriendDto, GetFriendRequestDto} from "./api";
-import {LoadingController, ToastController} from "@ionic/angular";
+import {ToastController} from "@ionic/angular";
 import {firstValueFrom} from "rxjs";
 
 @Injectable({