karibu-layer 1.0.0 → 1.0.2

package/README.md

@@ -1,4 +1,4 @@
-# karibu-api-client@1.0.0
+# karibu-layer@1.0.0
 
 API pour la gestion des établissements karibu
 
@@ -24,7 +24,7 @@ Navigate to the folder of your consuming project and run one of next commands.
 _published:_
 
 ```console
-npm install karibu-api-client@1.0.0 --save
+npm install karibu-layer@1.0.0 --save
 ```
 
 _without publishing (not recommended):_
@@ -46,7 +46,7 @@ npm link
 In your project:
 
 ```console
-npm link karibu-api-client
+npm link karibu-layer
 ```
 
 __Note for Windows users:__ The Angular CLI has troubles to use linked npm packages.
@@ -59,7 +59,7 @@ In your Angular project:
 
 ```typescript
 // without configuring providers
-import { ApiModule } from 'karibu-api-client';
+import { ApiModule } from 'karibu-layer';
 import { HttpClientModule } from '@angular/common/http';
 
 @NgModule({
@@ -78,7 +78,7 @@ export class AppModule {}
 
 ```typescript
 // configuring providers
-import { ApiModule, Configuration, ConfigurationParameters } from 'karibu-api-client';
+import { ApiModule, Configuration, ConfigurationParameters } from 'karibu-layer';
 
 export function apiConfigFactory (): Configuration {
   const params: ConfigurationParameters = {
@@ -98,7 +98,7 @@ export class AppModule {}
 
 ```typescript
 // configuring providers with an authentication service that manages your access tokens
-import { ApiModule, Configuration } from 'karibu-api-client';
+import { ApiModule, Configuration } from 'karibu-layer';
 
 @NgModule({
     imports: [ ApiModule ],
@@ -122,7 +122,7 @@ export class AppModule {}
 ```
 
 ```typescript
-import { DefaultApi } from 'karibu-api-client';
+import { DefaultApi } from 'karibu-layer';
 
 export class AppComponent {
     constructor(private apiGateway: DefaultApi) { }
@@ -162,7 +162,7 @@ export class AppModule {
 If different than the generated base path, during app bootstrap, you can provide the base path to your service.
 
 ```typescript
-import { BASE_PATH } from 'karibu-api-client';
+import { BASE_PATH } from 'karibu-layer';
 
 bootstrap(AppComponent, [
     { provide: BASE_PATH, useValue: 'https://your-web-service.com' },
@@ -172,7 +172,7 @@ bootstrap(AppComponent, [
 or
 
 ```typescript
-import { BASE_PATH } from 'karibu-api-client';
+import { BASE_PATH } from 'karibu-layer';
 
 @NgModule({
     imports: [],
@@ -197,7 +197,7 @@ export const environment = {
 In the src/app/app.module.ts:
 
 ```typescript
-import { BASE_PATH } from 'karibu-api-client';
+import { BASE_PATH } from 'karibu-layer';
 import { environment } from '../environments/environment';
 
 @NgModule({

package/api/api.d.ts

@@ -2,6 +2,8 @@ export * from './authentication.service';
 import { AuthenticationService } from './authentication.service';
 export * from './board.service';
 import { BoardService } from './board.service';
+export * from './category.service';
+import { CategoryService } from './category.service';
 export * from './establishment.service';
 import { EstablishmentService } from './establishment.service';
 export * from './establishmentAccessor.service';
@@ -20,4 +22,4 @@ export * from './role.service';
 import { RoleService } from './role.service';
 export * from './user.service';
 import { UserService } from './user.service';
-export declare const APIS: (typeof AuthenticationService | typeof BoardService | typeof EstablishmentService | typeof EstablishmentAccessorService | typeof InvoiceService | typeof OrderService | typeof OrderItemService | typeof PaymentService | typeof ProductService | typeof RoleService | typeof UserService)[];
+export declare const APIS: (typeof CategoryService | typeof AuthenticationService | typeof BoardService | typeof EstablishmentService | typeof EstablishmentAccessorService | typeof InvoiceService | typeof OrderService | typeof OrderItemService | typeof PaymentService | typeof ProductService | typeof RoleService | typeof UserService)[];

package/api/category.service.d.ts

@@ -0,0 +1,245 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { CategoryRequestDTO } from '../model/categoryRequestDTO';
+import { CategoryResponseDTO } from '../model/categoryResponseDTO';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export declare class CategoryService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Créer une nouvelle catégorie
+     * @param categoryRequestDTO
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    createCategory(categoryRequestDTO: CategoryRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<CategoryResponseDTO>;
+    createCategory(categoryRequestDTO: CategoryRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<CategoryResponseDTO>>;
+    createCategory(categoryRequestDTO: CategoryRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<CategoryResponseDTO>>;
+    /**
+     * Supprimer une catégorie
+     * @param id
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    removeCategory(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    removeCategory(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    removeCategory(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * Récupérer toutes les catégories
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    retrieveAllCategories(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Array<CategoryResponseDTO>>;
+    retrieveAllCategories(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Array<CategoryResponseDTO>>>;
+    retrieveAllCategories(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Array<CategoryResponseDTO>>>;
+    /**
+     * Récupérer les catégories par établissement
+     * @param establishmentId
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    retrieveCategoriesByEstablishmentId(establishmentId: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Array<CategoryResponseDTO>>;
+    retrieveCategoriesByEstablishmentId(establishmentId: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Array<CategoryResponseDTO>>>;
+    retrieveCategoriesByEstablishmentId(establishmentId: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Array<CategoryResponseDTO>>>;
+    /**
+     * Récupérer les catégories par statut
+     * @param active
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    retrieveCategoriesByStatus(active: boolean, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Array<CategoryResponseDTO>>;
+    retrieveCategoriesByStatus(active: boolean, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Array<CategoryResponseDTO>>>;
+    retrieveCategoriesByStatus(active: boolean, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Array<CategoryResponseDTO>>>;
+    /**
+     * Récupérer une catégorie par ID
+     * @param id
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    retrieveCategory(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<CategoryResponseDTO>;
+    retrieveCategory(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<CategoryResponseDTO>>;
+    retrieveCategory(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<CategoryResponseDTO>>;
+    /**
+     * Récupérer une catégorie par code
+     * @param code
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    retrieveCategoryByCode(code: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<CategoryResponseDTO>;
+    retrieveCategoryByCode(code: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<CategoryResponseDTO>>;
+    retrieveCategoryByCode(code: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<CategoryResponseDTO>>;
+    /**
+     * Rechercher des catégories par nom
+     * @param name
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    searchCategoriesByName(name: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Array<CategoryResponseDTO>>;
+    searchCategoriesByName(name: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Array<CategoryResponseDTO>>>;
+    searchCategoriesByName(name: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Array<CategoryResponseDTO>>>;
+    /**
+     * Activer/désactiver une catégorie
+     * @param id
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    toggleCategoryStatus(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<CategoryResponseDTO>;
+    toggleCategoryStatus(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<CategoryResponseDTO>>;
+    toggleCategoryStatus(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<CategoryResponseDTO>>;
+    /**
+     * Mettre à jour une catégorie
+     * @param id
+     * @param categoryRequestDTO
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    updateCategory(id: number, categoryRequestDTO: CategoryRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<CategoryResponseDTO>;
+    updateCategory(id: number, categoryRequestDTO: CategoryRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<CategoryResponseDTO>>;
+    updateCategory(id: number, categoryRequestDTO: CategoryRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<CategoryResponseDTO>>;
+    /**
+     * Mettre à jour l\&#39;image d\&#39;une catégorie
+     * @param id
+     * @param body
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    updateCategoryImage(id: number, body: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<CategoryResponseDTO>;
+    updateCategoryImage(id: number, body: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<CategoryResponseDTO>>;
+    updateCategoryImage(id: number, body: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<CategoryResponseDTO>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CategoryService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CategoryService>;
+}

package/esm2022/api/api.mjs

@@ -2,6 +2,8 @@ export * from './authentication.service';
 import { AuthenticationService } from './authentication.service';
 export * from './board.service';
 import { BoardService } from './board.service';
+export * from './category.service';
+import { CategoryService } from './category.service';
 export * from './establishment.service';
 import { EstablishmentService } from './establishment.service';
 export * from './establishmentAccessor.service';
@@ -20,5 +22,5 @@ export * from './role.service';
 import { RoleService } from './role.service';
 export * from './user.service';
 import { UserService } from './user.service';
-export const APIS = [AuthenticationService, BoardService, EstablishmentService, EstablishmentAccessorService, InvoiceService, OrderService, OrderItemService, PaymentService, ProductService, RoleService, UserService];
-//# sourceMappingURL=data:application/json;base64,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
+export const APIS = [AuthenticationService, BoardService, CategoryService, EstablishmentService, EstablishmentAccessorService, InvoiceService, OrderService, OrderItemService, PaymentService, ProductService, RoleService, UserService];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/api/authentication.service.mjs

@@ -301,4 +301,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }] }, { type: i2.Configuration, decorators: [{
                     type: Optional
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authentication.service.js","sourceRoot":"","sources":["../../../api/authentication.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * karibu API\n *\n * Contact: support@karibu.ga\n *\n * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).\n * https://openapi-generator.tech\n * Do not edit the class manually.\n */\n/* tslint:disable:no-unused-variable member-ordering */\n\nimport { Inject, Injectable, Optional }                      from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams,\n         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext \n        }       from '@angular/common/http';\nimport { CustomHttpParameterCodec }                          from '../encoder';\nimport { Observable }                                        from 'rxjs';\n\n// @ts-ignore\nimport { LoginRequestDTO } from '../model/loginRequestDTO';\n// @ts-ignore\nimport { LoginResponseDTO } from '../model/loginResponseDTO';\n// @ts-ignore\nimport { TokenRequest } from '../model/tokenRequest';\n// @ts-ignore\nimport { TokenResponse } from '../model/tokenResponse';\n\n// @ts-ignore\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\nimport { BaseService } from '../api.base.service';\n\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AuthenticationService extends BaseService {\n\n    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {\n        super(basePath, configuration);\n    }\n\n    /**\n     * Authentification dédiée pour les administrateurs\n     * @param loginRequestDTO \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public adminLogin(loginRequestDTO: LoginRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<LoginResponseDTO>;\n    public adminLogin(loginRequestDTO: LoginRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<LoginResponseDTO>>;\n    public adminLogin(loginRequestDTO: LoginRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<LoginResponseDTO>>;\n    public adminLogin(loginRequestDTO: LoginRequestDTO, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (loginRequestDTO === null || loginRequestDTO === undefined) {\n            throw new Error('Required parameter loginRequestDTO was null or undefined when calling adminLogin.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/login/admin`;\n        return this.httpClient.request<LoginResponseDTO>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: loginRequestDTO,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Génère un token avec droits admin (protégé)\n     * @param tokenRequest \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public generateAdminToken(tokenRequest: TokenRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<TokenResponse>;\n    public generateAdminToken(tokenRequest: TokenRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<TokenResponse>>;\n    public generateAdminToken(tokenRequest: TokenRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<TokenResponse>>;\n    public generateAdminToken(tokenRequest: TokenRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (tokenRequest === null || tokenRequest === undefined) {\n            throw new Error('Required parameter tokenRequest was null or undefined when calling generateAdminToken.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/admin-token`;\n        return this.httpClient.request<TokenResponse>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: tokenRequest,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Génère un token personnalisé pour un utilisateur\n     * @param tokenRequest \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public generateCustomToken(tokenRequest: TokenRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<TokenResponse>;\n    public generateCustomToken(tokenRequest: TokenRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<TokenResponse>>;\n    public generateCustomToken(tokenRequest: TokenRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<TokenResponse>>;\n    public generateCustomToken(tokenRequest: TokenRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (tokenRequest === null || tokenRequest === undefined) {\n            throw new Error('Required parameter tokenRequest was null or undefined when calling generateCustomToken.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/token`;\n        return this.httpClient.request<TokenResponse>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: tokenRequest,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Génère un token avec des claims personnalisés\n     * @param tokenRequest \n     * @param role \n     * @param establishmentAccess \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<TokenResponse>;\n    public generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<TokenResponse>>;\n    public generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<TokenResponse>>;\n    public generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (tokenRequest === null || tokenRequest === undefined) {\n            throw new Error('Required parameter tokenRequest was null or undefined when calling generateTokenWithClaims.');\n        }\n\n        let localVarQueryParameters = new HttpParams({encoder: this.encoder});\n        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n          <any>role, 'role');\n        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n          <any>establishmentAccess, 'establishmentAccess');\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/token-with-claims`;\n        return this.httpClient.request<TokenResponse>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: tokenRequest,\n                params: localVarQueryParameters,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Authentification et génération d\\&#39;un token selon le rôle\n     * @param loginRequestDTO \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public login(loginRequestDTO: LoginRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<LoginResponseDTO>;\n    public login(loginRequestDTO: LoginRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<LoginResponseDTO>>;\n    public login(loginRequestDTO: LoginRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<LoginResponseDTO>>;\n    public login(loginRequestDTO: LoginRequestDTO, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (loginRequestDTO === null || loginRequestDTO === undefined) {\n            throw new Error('Required parameter loginRequestDTO was null or undefined when calling login.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/login`;\n        return this.httpClient.request<LoginResponseDTO>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: loginRequestDTO,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Révoque tous les tokens d\\&#39;un utilisateur (déconnexion forcée)\n     * @param uid \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public revokeTokens(uid: string, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;\n    public revokeTokens(uid: string, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;\n    public revokeTokens(uid: string, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;\n    public revokeTokens(uid: string, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (uid === null || uid === undefined) {\n            throw new Error('Required parameter uid was null or undefined when calling revokeTokens.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/revoke-tokens/${this.configuration.encodeParam({name: \"uid\", value: uid, in: \"path\", style: \"simple\", explode: false, dataType: \"string\", dataFormat: undefined})}`;\n        return this.httpClient.request<any>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authentication.service.js","sourceRoot":"","sources":["../../../api/authentication.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,uDAAuD;AAEvD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAA2B,eAAe,CAAC;AAClF,OAAO,EAA2B,UAAU,EACU,WAAW,EACxD,MAAY,sBAAsB,CAAC;AAa5C,aAAa;AACb,OAAO,EAAE,SAAS,EAAsB,MAA0B,cAAc,CAAC;AAEjF,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;;;;AAOlD,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IAE5B;IAAtB,YAAsB,UAAsB,EAAiC,QAAyB,EAAc,aAA6B;QAC7I,KAAK,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QADb,eAAU,GAAV,UAAU,CAAY;IAE5C,CAAC;IAWM,UAAU,CAAC,eAAgC,EAAE,UAAe,MAAM,EAAE,iBAA0B,KAAK,EAAE,OAAiG;QACzM,IAAI,eAAe,KAAK,IAAI,IAAI,eAAe,KAAK,SAAS,EAAE;YAC3D,MAAM,IAAI,KAAK,CAAC,mFAAmF,CAAC,CAAC;SACxG;QAED,IAAI,eAAe,GAAG,IAAI,CAAC,cAAc,CAAC;QAE1C,MAAM,gCAAgC,GAAuB,OAAO,EAAE,gBAAgB,IAAI,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC;YAC5H,kBAAkB;SACrB,CAAC,CAAC;QACH,IAAI,gCAAgC,KAAK,SAAS,EAAE;YAChD,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,gCAAgC,CAAC,CAAC;SACrF;QAED,MAAM,mBAAmB,GAAgB,OAAO,EAAE,OAAO,IAAI,IAAI,WAAW,EAAE,CAAC;QAE/E,MAAM,qBAAqB,GAAY,OAAO,EAAE,aAAa,IAAI,IAAI,CAAC;QAGtE,uCAAuC;QACvC,MAAM,QAAQ,GAAa;YACvB,kBAAkB;SACrB,CAAC;QACF,MAAM,uBAAuB,GAAuB,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;QACzG,IAAI,uBAAuB,KAAK,SAAS,EAAE;YACvC,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,cAAc,EAAE,uBAAuB,CAAC,CAAC;SAClF;QAED,IAAI,aAAa,GAA6B,MAAM,CAAC;QACrD,IAAI,gCAAgC,EAAE;YAClC,IAAI,gCAAgC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBACrD,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,gCAAgC,CAAC,EAAE;gBACxE,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM;gBACH,aAAa,GAAG,MAAM,CAAC;aAC1B;SACJ;QAED,IAAI,YAAY,GAAG,mBAAmB,CAAC;QACvC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAmB,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,YAAY,EAAE,EACpG;YACI,OAAO,EAAE,mBAAmB;YAC5B,IAAI,EAAE,eAAe;YACrB,YAAY,EAAO,aAAa;YAChC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,eAAe;YACnD,OAAO,EAAE,eAAe;YACxB,OAAO,EAAE,OAAO;YAChB,aAAa,EAAE,qBAAqB;YACpC,cAAc,EAAE,cAAc;SACjC,CACJ,CAAC;IACN,CAAC;IAWM,kBAAkB,CAAC,YAA0B,EAAE,UAAe,MAAM,EAAE,iBAA0B,KAAK,EAAE,OAAiG;QAC3M,IAAI,YAAY,KAAK,IAAI,IAAI,YAAY,KAAK,SAAS,EAAE;YACrD,MAAM,IAAI,KAAK,CAAC,wFAAwF,CAAC,CAAC;SAC7G;QAED,IAAI,eAAe,GAAG,IAAI,CAAC,cAAc,CAAC;QAE1C,MAAM,gCAAgC,GAAuB,OAAO,EAAE,gBAAgB,IAAI,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC;YAC5H,kBAAkB;SACrB,CAAC,CAAC;QACH,IAAI,gCAAgC,KAAK,SAAS,EAAE;YAChD,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,gCAAgC,CAAC,CAAC;SACrF;QAED,MAAM,mBAAmB,GAAgB,OAAO,EAAE,OAAO,IAAI,IAAI,WAAW,EAAE,CAAC;QAE/E,MAAM,qBAAqB,GAAY,OAAO,EAAE,aAAa,IAAI,IAAI,CAAC;QAGtE,uCAAuC;QACvC,MAAM,QAAQ,GAAa;YACvB,kBAAkB;SACrB,CAAC;QACF,MAAM,uBAAuB,GAAuB,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;QACzG,IAAI,uBAAuB,KAAK,SAAS,EAAE;YACvC,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,cAAc,EAAE,uBAAuB,CAAC,CAAC;SAClF;QAED,IAAI,aAAa,GAA6B,MAAM,CAAC;QACrD,IAAI,gCAAgC,EAAE;YAClC,IAAI,gCAAgC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBACrD,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,gCAAgC,CAAC,EAAE;gBACxE,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM;gBACH,aAAa,GAAG,MAAM,CAAC;aAC1B;SACJ;QAED,IAAI,YAAY,GAAG,mBAAmB,CAAC;QACvC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAgB,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,YAAY,EAAE,EACjG;YACI,OAAO,EAAE,mBAAmB;YAC5B,IAAI,EAAE,YAAY;YAClB,YAAY,EAAO,aAAa;YAChC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,eAAe;YACnD,OAAO,EAAE,eAAe;YACxB,OAAO,EAAE,OAAO;YAChB,aAAa,EAAE,qBAAqB;YACpC,cAAc,EAAE,cAAc;SACjC,CACJ,CAAC;IACN,CAAC;IAWM,mBAAmB,CAAC,YAA0B,EAAE,UAAe,MAAM,EAAE,iBAA0B,KAAK,EAAE,OAAiG;QAC5M,IAAI,YAAY,KAAK,IAAI,IAAI,YAAY,KAAK,SAAS,EAAE;YACrD,MAAM,IAAI,KAAK,CAAC,yFAAyF,CAAC,CAAC;SAC9G;QAED,IAAI,eAAe,GAAG,IAAI,CAAC,cAAc,CAAC;QAE1C,MAAM,gCAAgC,GAAuB,OAAO,EAAE,gBAAgB,IAAI,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC;YAC5H,kBAAkB;SACrB,CAAC,CAAC;QACH,IAAI,gCAAgC,KAAK,SAAS,EAAE;YAChD,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,gCAAgC,CAAC,CAAC;SACrF;QAED,MAAM,mBAAmB,GAAgB,OAAO,EAAE,OAAO,IAAI,IAAI,WAAW,EAAE,CAAC;QAE/E,MAAM,qBAAqB,GAAY,OAAO,EAAE,aAAa,IAAI,IAAI,CAAC;QAGtE,uCAAuC;QACvC,MAAM,QAAQ,GAAa;YACvB,kBAAkB;SACrB,CAAC;QACF,MAAM,uBAAuB,GAAuB,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;QACzG,IAAI,uBAAuB,KAAK,SAAS,EAAE;YACvC,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,cAAc,EAAE,uBAAuB,CAAC,CAAC;SAClF;QAED,IAAI,aAAa,GAA6B,MAAM,CAAC;QACrD,IAAI,gCAAgC,EAAE;YAClC,IAAI,gCAAgC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBACrD,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,gCAAgC,CAAC,EAAE;gBACxE,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM;gBACH,aAAa,GAAG,MAAM,CAAC;aAC1B;SACJ;QAED,IAAI,YAAY,GAAG,aAAa,CAAC;QACjC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAgB,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,YAAY,EAAE,EACjG;YACI,OAAO,EAAE,mBAAmB;YAC5B,IAAI,EAAE,YAAY;YAClB,YAAY,EAAO,aAAa;YAChC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,eAAe;YACnD,OAAO,EAAE,eAAe;YACxB,OAAO,EAAE,OAAO;YAChB,aAAa,EAAE,qBAAqB;YACpC,cAAc,EAAE,cAAc;SACjC,CACJ,CAAC;IACN,CAAC;IAaM,uBAAuB,CAAC,YAA0B,EAAE,IAAa,EAAE,mBAA6B,EAAE,UAAe,MAAM,EAAE,iBAA0B,KAAK,EAAE,OAAiG;QAC9P,IAAI,YAAY,KAAK,IAAI,IAAI,YAAY,KAAK,SAAS,EAAE;YACrD,MAAM,IAAI,KAAK,CAAC,6FAA6F,CAAC,CAAC;SAClH;QAED,IAAI,uBAAuB,GAAG,IAAI,UAAU,CAAC,EAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAC,CAAC,CAAC;QACtE,uBAAuB,GAAG,IAAI,CAAC,eAAe,CAAC,uBAAuB,EAC/D,IAAI,EAAE,MAAM,CAAC,CAAC;QACrB,uBAAuB,GAAG,IAAI,CAAC,eAAe,CAAC,uBAAuB,EAC/D,mBAAmB,EAAE,qBAAqB,CAAC,CAAC;QAEnD,IAAI,eAAe,GAAG,IAAI,CAAC,cAAc,CAAC;QAE1C,MAAM,gCAAgC,GAAuB,OAAO,EAAE,gBAAgB,IAAI,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC;YAC5H,kBAAkB;SACrB,CAAC,CAAC;QACH,IAAI,gCAAgC,KAAK,SAAS,EAAE;YAChD,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,gCAAgC,CAAC,CAAC;SACrF;QAED,MAAM,mBAAmB,GAAgB,OAAO,EAAE,OAAO,IAAI,IAAI,WAAW,EAAE,CAAC;QAE/E,MAAM,qBAAqB,GAAY,OAAO,EAAE,aAAa,IAAI,IAAI,CAAC;QAGtE,uCAAuC;QACvC,MAAM,QAAQ,GAAa;YACvB,kBAAkB;SACrB,CAAC;QACF,MAAM,uBAAuB,GAAuB,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;QACzG,IAAI,uBAAuB,KAAK,SAAS,EAAE;YACvC,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,cAAc,EAAE,uBAAuB,CAAC,CAAC;SAClF;QAED,IAAI,aAAa,GAA6B,MAAM,CAAC;QACrD,IAAI,gCAAgC,EAAE;YAClC,IAAI,gCAAgC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBACrD,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,gCAAgC,CAAC,EAAE;gBACxE,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM;gBACH,aAAa,GAAG,MAAM,CAAC;aAC1B;SACJ;QAED,IAAI,YAAY,GAAG,yBAAyB,CAAC;QAC7C,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAgB,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,YAAY,EAAE,EACjG;YACI,OAAO,EAAE,mBAAmB;YAC5B,IAAI,EAAE,YAAY;YAClB,MAAM,EAAE,uBAAuB;YAC/B,YAAY,EAAO,aAAa;YAChC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,eAAe;YACnD,OAAO,EAAE,eAAe;YACxB,OAAO,EAAE,OAAO;YAChB,aAAa,EAAE,qBAAqB;YACpC,cAAc,EAAE,cAAc;SACjC,CACJ,CAAC;IACN,CAAC;IAWM,KAAK,CAAC,eAAgC,EAAE,UAAe,MAAM,EAAE,iBAA0B,KAAK,EAAE,OAAiG;QACpM,IAAI,eAAe,KAAK,IAAI,IAAI,eAAe,KAAK,SAAS,EAAE;YAC3D,MAAM,IAAI,KAAK,CAAC,8EAA8E,CAAC,CAAC;SACnG;QAED,IAAI,eAAe,GAAG,IAAI,CAAC,cAAc,CAAC;QAE1C,MAAM,gCAAgC,GAAuB,OAAO,EAAE,gBAAgB,IAAI,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC;YAC5H,kBAAkB;SACrB,CAAC,CAAC;QACH,IAAI,gCAAgC,KAAK,SAAS,EAAE;YAChD,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,gCAAgC,CAAC,CAAC;SACrF;QAED,MAAM,mBAAmB,GAAgB,OAAO,EAAE,OAAO,IAAI,IAAI,WAAW,EAAE,CAAC;QAE/E,MAAM,qBAAqB,GAAY,OAAO,EAAE,aAAa,IAAI,IAAI,CAAC;QAGtE,uCAAuC;QACvC,MAAM,QAAQ,GAAa;YACvB,kBAAkB;SACrB,CAAC;QACF,MAAM,uBAAuB,GAAuB,IAAI,CAAC,aAAa,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;QACzG,IAAI,uBAAuB,KAAK,SAAS,EAAE;YACvC,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,cAAc,EAAE,uBAAuB,CAAC,CAAC;SAClF;QAED,IAAI,aAAa,GAA6B,MAAM,CAAC;QACrD,IAAI,gCAAgC,EAAE;YAClC,IAAI,gCAAgC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBACrD,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,gCAAgC,CAAC,EAAE;gBACxE,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM;gBACH,aAAa,GAAG,MAAM,CAAC;aAC1B;SACJ;QAED,IAAI,YAAY,GAAG,aAAa,CAAC;QACjC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAmB,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,YAAY,EAAE,EACpG;YACI,OAAO,EAAE,mBAAmB;YAC5B,IAAI,EAAE,eAAe;YACrB,YAAY,EAAO,aAAa;YAChC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,eAAe;YACnD,OAAO,EAAE,eAAe;YACxB,OAAO,EAAE,OAAO;YAChB,aAAa,EAAE,qBAAqB;YACpC,cAAc,EAAE,cAAc;SACjC,CACJ,CAAC;IACN,CAAC;IAWM,YAAY,CAAC,GAAW,EAAE,UAAe,MAAM,EAAE,iBAA0B,KAAK,EAAE,OAAwF;QAC7K,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS,EAAE;YACnC,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;SAC9F;QAED,IAAI,eAAe,GAAG,IAAI,CAAC,cAAc,CAAC;QAE1C,MAAM,gCAAgC,GAAuB,OAAO,EAAE,gBAAgB,IAAI,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,EAC/H,CAAC,CAAC;QACH,IAAI,gCAAgC,KAAK,SAAS,EAAE;YAChD,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,gCAAgC,CAAC,CAAC;SACrF;QAED,MAAM,mBAAmB,GAAgB,OAAO,EAAE,OAAO,IAAI,IAAI,WAAW,EAAE,CAAC;QAE/E,MAAM,qBAAqB,GAAY,OAAO,EAAE,aAAa,IAAI,IAAI,CAAC;QAGtE,IAAI,aAAa,GAA6B,MAAM,CAAC;QACrD,IAAI,gCAAgC,EAAE;YAClC,IAAI,gCAAgC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBACrD,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,gCAAgC,CAAC,EAAE;gBACxE,aAAa,GAAG,MAAM,CAAC;aAC1B;iBAAM;gBACH,aAAa,GAAG,MAAM,CAAC;aAC1B;SACJ;QAED,IAAI,YAAY,GAAG,uBAAuB,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAC,CAAC,EAAE,CAAC;QAC9L,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAM,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,YAAY,EAAE,EACvF;YACI,OAAO,EAAE,mBAAmB;YAC5B,YAAY,EAAO,aAAa;YAChC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,eAAe;YACnD,OAAO,EAAE,eAAe;YACxB,OAAO,EAAE,OAAO;YAChB,aAAa,EAAE,qBAAqB;YACpC,cAAc,EAAE,cAAc;SACjC,CACJ,CAAC;IACN,CAAC;wGA5XQ,qBAAqB,4CAEoC,SAAS;4GAFlE,qBAAqB,cAFpB,MAAM;;4FAEP,qBAAqB;kBAHjC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAGkD,QAAQ;;0BAAI,MAAM;2BAAC,SAAS;;0BAA8B,QAAQ","sourcesContent":["/**\n * karibu API\n *\n * Contact: support@karibu.ga\n *\n * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).\n * https://openapi-generator.tech\n * Do not edit the class manually.\n */\n/* tslint:disable:no-unused-variable member-ordering */\n\nimport { Inject, Injectable, Optional }                      from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams,\n         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext \n        }       from '@angular/common/http';\nimport { CustomHttpParameterCodec }                          from '../encoder';\nimport { Observable }                                        from 'rxjs';\n\n// @ts-ignore\nimport { LoginRequestDTO } from '../model/loginRequestDTO';\n// @ts-ignore\nimport { LoginResponseDTO } from '../model/loginResponseDTO';\n// @ts-ignore\nimport { TokenRequest } from '../model/tokenRequest';\n// @ts-ignore\nimport { TokenResponse } from '../model/tokenResponse';\n\n// @ts-ignore\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\nimport { BaseService } from '../api.base.service';\n\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AuthenticationService extends BaseService {\n\n    constructor(protected httpClient: HttpClient, @Optional() @Inject(BASE_PATH) basePath: string|string[], @Optional() configuration?: Configuration) {\n        super(basePath, configuration);\n    }\n\n    /**\n     * Authentification dédiée pour les administrateurs\n     * @param loginRequestDTO \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public adminLogin(loginRequestDTO: LoginRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<LoginResponseDTO>;\n    public adminLogin(loginRequestDTO: LoginRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<LoginResponseDTO>>;\n    public adminLogin(loginRequestDTO: LoginRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<LoginResponseDTO>>;\n    public adminLogin(loginRequestDTO: LoginRequestDTO, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (loginRequestDTO === null || loginRequestDTO === undefined) {\n            throw new Error('Required parameter loginRequestDTO was null or undefined when calling adminLogin.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/login/admin`;\n        return this.httpClient.request<LoginResponseDTO>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: loginRequestDTO,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Génère un token avec droits admin (protégé)\n     * @param tokenRequest \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public generateAdminToken(tokenRequest: TokenRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<TokenResponse>;\n    public generateAdminToken(tokenRequest: TokenRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<TokenResponse>>;\n    public generateAdminToken(tokenRequest: TokenRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<TokenResponse>>;\n    public generateAdminToken(tokenRequest: TokenRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (tokenRequest === null || tokenRequest === undefined) {\n            throw new Error('Required parameter tokenRequest was null or undefined when calling generateAdminToken.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/admin-token`;\n        return this.httpClient.request<TokenResponse>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: tokenRequest,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Génère un token personnalisé pour un utilisateur\n     * @param tokenRequest \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public generateCustomToken(tokenRequest: TokenRequest, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<TokenResponse>;\n    public generateCustomToken(tokenRequest: TokenRequest, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<TokenResponse>>;\n    public generateCustomToken(tokenRequest: TokenRequest, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<TokenResponse>>;\n    public generateCustomToken(tokenRequest: TokenRequest, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (tokenRequest === null || tokenRequest === undefined) {\n            throw new Error('Required parameter tokenRequest was null or undefined when calling generateCustomToken.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/token`;\n        return this.httpClient.request<TokenResponse>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: tokenRequest,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Génère un token avec des claims personnalisés\n     * @param tokenRequest \n     * @param role \n     * @param establishmentAccess \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<TokenResponse>;\n    public generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<TokenResponse>>;\n    public generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<TokenResponse>>;\n    public generateTokenWithClaims(tokenRequest: TokenRequest, role?: string, establishmentAccess?: boolean, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (tokenRequest === null || tokenRequest === undefined) {\n            throw new Error('Required parameter tokenRequest was null or undefined when calling generateTokenWithClaims.');\n        }\n\n        let localVarQueryParameters = new HttpParams({encoder: this.encoder});\n        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n          <any>role, 'role');\n        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n          <any>establishmentAccess, 'establishmentAccess');\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/token-with-claims`;\n        return this.httpClient.request<TokenResponse>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: tokenRequest,\n                params: localVarQueryParameters,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Authentification et génération d\\&#39;un token selon le rôle\n     * @param loginRequestDTO \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public login(loginRequestDTO: LoginRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<LoginResponseDTO>;\n    public login(loginRequestDTO: LoginRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<LoginResponseDTO>>;\n    public login(loginRequestDTO: LoginRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<LoginResponseDTO>>;\n    public login(loginRequestDTO: LoginRequestDTO, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (loginRequestDTO === null || loginRequestDTO === undefined) {\n            throw new Error('Required parameter loginRequestDTO was null or undefined when calling login.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n            'application/json'\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/login`;\n        return this.httpClient.request<LoginResponseDTO>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                body: loginRequestDTO,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Révoque tous les tokens d\\&#39;un utilisateur (déconnexion forcée)\n     * @param uid \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public revokeTokens(uid: string, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;\n    public revokeTokens(uid: string, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;\n    public revokeTokens(uid: string, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;\n    public revokeTokens(uid: string, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (uid === null || uid === undefined) {\n            throw new Error('Required parameter uid was null or undefined when calling revokeTokens.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n\n        const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([\n        ]);\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();\n\n        const localVarTransferCache: boolean = options?.transferCache ?? true;\n\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/auth/revoke-tokens/${this.configuration.encodeParam({name: \"uid\", value: uid, in: \"path\", style: \"simple\", explode: false, dataType: \"string\", dataFormat: undefined})}`;\n        return this.httpClient.request<any>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                transferCache: localVarTransferCache,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n}\n"]}