karibu-layer 1.0.2 → 1.0.5

package/api/api.d.ts

@@ -22,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 CategoryService | 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 EstablishmentAccessorService | typeof AuthenticationService | typeof BoardService | typeof CategoryService | typeof EstablishmentService | typeof InvoiceService | typeof OrderService | typeof OrderItemService | typeof PaymentService | typeof ProductService | typeof RoleService | typeof UserService)[];

package/api/establishmentAccessor.service.d.ts

@@ -12,20 +12,21 @@ export declare class EstablishmentAccessorService extends BaseService {
     /**
      * Créer un nouvel accès pour un établissement
      * @param establishmentId
+     * @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.
      */
-    createAccessor(establishmentId: number, observe?: 'body', reportProgress?: boolean, options?: {
+    createAccessor(establishmentId: number, name: string, observe?: 'body', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
         transferCache?: boolean;
     }): Observable<EstablishmentAccessorDTO>;
-    createAccessor(establishmentId: number, observe?: 'response', reportProgress?: boolean, options?: {
+    createAccessor(establishmentId: number, name: string, observe?: 'response', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
         transferCache?: boolean;
     }): Observable<HttpResponse<EstablishmentAccessorDTO>>;
-    createAccessor(establishmentId: number, observe?: 'events', reportProgress?: boolean, options?: {
+    createAccessor(establishmentId: number, name: string, observe?: 'events', reportProgress?: boolean, options?: {
         httpHeaderAccept?: 'application/json';
         context?: HttpContext;
         transferCache?: boolean;
@@ -51,6 +52,27 @@ export declare class EstablishmentAccessorService extends BaseService {
         context?: HttpContext;
         transferCache?: boolean;
     }): Observable<HttpEvent<any>>;
+    /**
+     * Récupérer un accès par ID d\&#39;établissement
+     * @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.
+     */
+    getAccessorByEstablishmentId(id: number, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<EstablishmentAccessorDTO>;
+    getAccessorByEstablishmentId(id: number, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<EstablishmentAccessorDTO>>;
+    getAccessorByEstablishmentId(id: number, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<EstablishmentAccessorDTO>>;
     /**
      * Récupérer un accès par ID
      * @param id

package/esm2022/api/establishmentAccessor.service.mjs

@@ -22,10 +22,15 @@ export class EstablishmentAccessorService extends BaseService {
         super(basePath, configuration);
         this.httpClient = httpClient;
     }
-    createAccessor(establishmentId, observe = 'body', reportProgress = false, options) {
+    createAccessor(establishmentId, name, observe = 'body', reportProgress = false, options) {
         if (establishmentId === null || establishmentId === undefined) {
             throw new Error('Required parameter establishmentId was null or undefined when calling createAccessor.');
         }
+        if (name === null || name === undefined) {
+            throw new Error('Required parameter name was null or undefined when calling createAccessor.');
+        }
+        let localVarQueryParameters = new HttpParams({ encoder: this.encoder });
+        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, name, 'name');
         let localVarHeaders = this.defaultHeaders;
         const localVarHttpHeaderAcceptSelected = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
             'application/json'
@@ -50,6 +55,7 @@ export class EstablishmentAccessorService extends BaseService {
         let localVarPath = `/establishment-accessors/create-accessor/${this.configuration.encodeParam({ name: "establishmentId", value: establishmentId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int64" })}`;
         return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
             context: localVarHttpContext,
+            params: localVarQueryParameters,
             responseType: responseType_,
             withCredentials: this.configuration.withCredentials,
             headers: localVarHeaders,
@@ -92,6 +98,42 @@ export class EstablishmentAccessorService extends BaseService {
             reportProgress: reportProgress
         });
     }
+    getAccessorByEstablishmentId(id, observe = 'body', reportProgress = false, options) {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getAccessorByEstablishmentId.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        const localVarHttpHeaderAcceptSelected = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        const localVarHttpContext = options?.context ?? new HttpContext();
+        const localVarTransferCache = options?.transferCache ?? true;
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/establishment-accessors/get-accessor-by-establishment/${this.configuration.encodeParam({ name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int64" })}`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            transferCache: localVarTransferCache,
+            reportProgress: reportProgress
+        });
+    }
     getAccessorById(id, observe = 'body', reportProgress = false, options) {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getAccessorById.');
@@ -292,4 +334,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":"establishmentAccessor.service.js","sourceRoot":"","sources":["../../../api/establishmentAccessor.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 { EstablishmentAccessorDTO } from '../model/establishmentAccessorDTO';\n// @ts-ignore\nimport { EstablishmentAccessorResponseDTO } from '../model/establishmentAccessorResponseDTO';\n// @ts-ignore\nimport { LoginAccessorRequestDTO } from '../model/loginAccessorRequestDTO';\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 EstablishmentAccessorService 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     * Créer un nouvel accès pour un établissement\n     * @param establishmentId \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 createAccessor(establishmentId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<EstablishmentAccessorDTO>;\n    public createAccessor(establishmentId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<EstablishmentAccessorDTO>>;\n    public createAccessor(establishmentId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<EstablishmentAccessorDTO>>;\n    public createAccessor(establishmentId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (establishmentId === null || establishmentId === undefined) {\n            throw new Error('Required parameter establishmentId was null or undefined when calling createAccessor.');\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        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 = `/establishment-accessors/create-accessor/${this.configuration.encodeParam({name: \"establishmentId\", value: establishmentId, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<EstablishmentAccessorDTO>('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     * Supprimer un accès\n     * @param id \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 deleteAccessor(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;\n    public deleteAccessor(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;\n    public deleteAccessor(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;\n    public deleteAccessor(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling deleteAccessor.');\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 = `/establishment-accessors/delete-accessor/${this.configuration.encodeParam({name: \"id\", value: id, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<any>('delete', `${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     * Récupérer un accès par ID\n     * @param id \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 getAccessorById(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<EstablishmentAccessorDTO>;\n    public getAccessorById(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<EstablishmentAccessorDTO>>;\n    public getAccessorById(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<EstablishmentAccessorDTO>>;\n    public getAccessorById(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling getAccessorById.');\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        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 = `/establishment-accessors/retrieve-accessor/${this.configuration.encodeParam({name: \"id\", value: id, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<EstablishmentAccessorDTO>('get', `${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     * Récupérer tous les accès aux établissements\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 getAllAccessors(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<EstablishmentAccessorDTO>>;\n    public getAllAccessors(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<EstablishmentAccessorDTO>>>;\n    public getAllAccessors(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<EstablishmentAccessorDTO>>>;\n    public getAllAccessors(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\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        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 = `/establishment-accessors/retrieve-accessors`;\n        return this.httpClient.request<Array<EstablishmentAccessorDTO>>('get', `${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     * Récupérer un établissement par identifiants d\\&#39;accès\n     * @param loginAccessorRequestDTO \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 getEstablishmentByCredentials(loginAccessorRequestDTO: LoginAccessorRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<EstablishmentAccessorResponseDTO>;\n    public getEstablishmentByCredentials(loginAccessorRequestDTO: LoginAccessorRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<EstablishmentAccessorResponseDTO>>;\n    public getEstablishmentByCredentials(loginAccessorRequestDTO: LoginAccessorRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<EstablishmentAccessorResponseDTO>>;\n    public getEstablishmentByCredentials(loginAccessorRequestDTO: LoginAccessorRequestDTO, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (loginAccessorRequestDTO === null || loginAccessorRequestDTO === undefined) {\n            throw new Error('Required parameter loginAccessorRequestDTO was null or undefined when calling getEstablishmentByCredentials.');\n        }\n\n        let localVarQueryParameters = new HttpParams({encoder: this.encoder});\n        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n          <any>loginAccessorRequestDTO, 'loginAccessorRequestDTO');\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        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 = `/establishment-accessors/get-establishment`;\n        return this.httpClient.request<EstablishmentAccessorResponseDTO>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\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     * Enregistrer un accès\n     * @param id \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 logAccess(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;\n    public logAccess(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;\n    public logAccess(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;\n    public logAccess(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling logAccess.');\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 = `/establishment-accessors/log-access/${this.configuration.encodeParam({name: \"id\", value: id, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<any>('put', `${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     * Mettre à jour le statut d\\&#39;un accès\n     * @param id \n     * @param status \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 updateAccessorStatus(id: number, status: string, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<EstablishmentAccessorDTO>;\n    public updateAccessorStatus(id: number, status: string, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<EstablishmentAccessorDTO>>;\n    public updateAccessorStatus(id: number, status: string, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<EstablishmentAccessorDTO>>;\n    public updateAccessorStatus(id: number, status: string, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling updateAccessorStatus.');\n        }\n        if (status === null || status === undefined) {\n            throw new Error('Required parameter status was null or undefined when calling updateAccessorStatus.');\n        }\n\n        let localVarQueryParameters = new HttpParams({encoder: this.encoder});\n        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n          <any>status, 'status');\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        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 = `/establishment-accessors/update-status/${this.configuration.encodeParam({name: \"id\", value: id, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<EstablishmentAccessorDTO>('put', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"establishmentAccessor.service.js","sourceRoot":"","sources":["../../../api/establishmentAccessor.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 { EstablishmentAccessorDTO } from '../model/establishmentAccessorDTO';\n// @ts-ignore\nimport { EstablishmentAccessorResponseDTO } from '../model/establishmentAccessorResponseDTO';\n// @ts-ignore\nimport { LoginAccessorRequestDTO } from '../model/loginAccessorRequestDTO';\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 EstablishmentAccessorService 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     * Créer un nouvel accès pour un établissement\n     * @param establishmentId \n     * @param name \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 createAccessor(establishmentId: number, name: string, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<EstablishmentAccessorDTO>;\n    public createAccessor(establishmentId: number, name: string, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<EstablishmentAccessorDTO>>;\n    public createAccessor(establishmentId: number, name: string, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<EstablishmentAccessorDTO>>;\n    public createAccessor(establishmentId: number, name: string, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (establishmentId === null || establishmentId === undefined) {\n            throw new Error('Required parameter establishmentId was null or undefined when calling createAccessor.');\n        }\n        if (name === null || name === undefined) {\n            throw new Error('Required parameter name was null or undefined when calling createAccessor.');\n        }\n\n        let localVarQueryParameters = new HttpParams({encoder: this.encoder});\n        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n          <any>name, 'name');\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        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 = `/establishment-accessors/create-accessor/${this.configuration.encodeParam({name: \"establishmentId\", value: establishmentId, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<EstablishmentAccessorDTO>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\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     * Supprimer un accès\n     * @param id \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 deleteAccessor(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;\n    public deleteAccessor(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;\n    public deleteAccessor(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;\n    public deleteAccessor(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling deleteAccessor.');\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 = `/establishment-accessors/delete-accessor/${this.configuration.encodeParam({name: \"id\", value: id, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<any>('delete', `${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     * Récupérer un accès par ID d\\&#39;établissement\n     * @param id \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 getAccessorByEstablishmentId(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<EstablishmentAccessorDTO>;\n    public getAccessorByEstablishmentId(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<EstablishmentAccessorDTO>>;\n    public getAccessorByEstablishmentId(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<EstablishmentAccessorDTO>>;\n    public getAccessorByEstablishmentId(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling getAccessorByEstablishmentId.');\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        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 = `/establishment-accessors/get-accessor-by-establishment/${this.configuration.encodeParam({name: \"id\", value: id, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<EstablishmentAccessorDTO>('get', `${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     * Récupérer un accès par ID\n     * @param id \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 getAccessorById(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<EstablishmentAccessorDTO>;\n    public getAccessorById(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<EstablishmentAccessorDTO>>;\n    public getAccessorById(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<EstablishmentAccessorDTO>>;\n    public getAccessorById(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling getAccessorById.');\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        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 = `/establishment-accessors/retrieve-accessor/${this.configuration.encodeParam({name: \"id\", value: id, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<EstablishmentAccessorDTO>('get', `${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     * Récupérer tous les accès aux établissements\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 getAllAccessors(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<EstablishmentAccessorDTO>>;\n    public getAllAccessors(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<EstablishmentAccessorDTO>>>;\n    public getAllAccessors(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<EstablishmentAccessorDTO>>>;\n    public getAllAccessors(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\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        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 = `/establishment-accessors/retrieve-accessors`;\n        return this.httpClient.request<Array<EstablishmentAccessorDTO>>('get', `${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     * Récupérer un établissement par identifiants d\\&#39;accès\n     * @param loginAccessorRequestDTO \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 getEstablishmentByCredentials(loginAccessorRequestDTO: LoginAccessorRequestDTO, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<EstablishmentAccessorResponseDTO>;\n    public getEstablishmentByCredentials(loginAccessorRequestDTO: LoginAccessorRequestDTO, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<EstablishmentAccessorResponseDTO>>;\n    public getEstablishmentByCredentials(loginAccessorRequestDTO: LoginAccessorRequestDTO, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<EstablishmentAccessorResponseDTO>>;\n    public getEstablishmentByCredentials(loginAccessorRequestDTO: LoginAccessorRequestDTO, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (loginAccessorRequestDTO === null || loginAccessorRequestDTO === undefined) {\n            throw new Error('Required parameter loginAccessorRequestDTO was null or undefined when calling getEstablishmentByCredentials.');\n        }\n\n        let localVarQueryParameters = new HttpParams({encoder: this.encoder});\n        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n          <any>loginAccessorRequestDTO, 'loginAccessorRequestDTO');\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        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 = `/establishment-accessors/get-establishment`;\n        return this.httpClient.request<EstablishmentAccessorResponseDTO>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\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     * Enregistrer un accès\n     * @param id \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 logAccess(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any>;\n    public logAccess(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;\n    public logAccess(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;\n    public logAccess(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling logAccess.');\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 = `/establishment-accessors/log-access/${this.configuration.encodeParam({name: \"id\", value: id, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<any>('put', `${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     * Mettre à jour le statut d\\&#39;un accès\n     * @param id \n     * @param status \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 updateAccessorStatus(id: number, status: string, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<EstablishmentAccessorDTO>;\n    public updateAccessorStatus(id: number, status: string, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<EstablishmentAccessorDTO>>;\n    public updateAccessorStatus(id: number, status: string, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<EstablishmentAccessorDTO>>;\n    public updateAccessorStatus(id: number, status: string, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling updateAccessorStatus.');\n        }\n        if (status === null || status === undefined) {\n            throw new Error('Required parameter status was null or undefined when calling updateAccessorStatus.');\n        }\n\n        let localVarQueryParameters = new HttpParams({encoder: this.encoder});\n        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n          <any>status, 'status');\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        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 = `/establishment-accessors/update-status/${this.configuration.encodeParam({name: \"id\", value: id, in: \"path\", style: \"simple\", explode: false, dataType: \"number\", dataFormat: \"int64\"})}`;\n        return this.httpClient.request<EstablishmentAccessorDTO>('put', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\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"]}

package/esm2022/model/board.mjs

@@ -5,4 +5,4 @@ export var Board;
         Closed: 'CLOSED'
     };
 })(Board || (Board = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9hcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9tb2RlbC9ib2FyZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF5QkEsTUFBTSxLQUFXLEtBQUssQ0FNckI7QUFORCxXQUFpQixLQUFLO0lBRUwsZ0JBQVUsR0FBRztRQUN0QixJQUFJLEVBQUUsTUFBb0I7UUFDMUIsTUFBTSxFQUFFLFFBQXNCO0tBQ2pDLENBQUM7QUFDTixDQUFDLEVBTmdCLEtBQUssS0FBTCxLQUFLLFFBTXJCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBrYXJpYnUgQVBJXG4gKlxuICogQ29udGFjdDogc3VwcG9ydEBrYXJpYnUuZ2FcbiAqXG4gKiBOT1RFOiBUaGlzIGNsYXNzIGlzIGF1dG8gZ2VuZXJhdGVkIGJ5IE9wZW5BUEkgR2VuZXJhdG9yIChodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2gpLlxuICogaHR0cHM6Ly9vcGVuYXBpLWdlbmVyYXRvci50ZWNoXG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXG4gKi9cbmltcG9ydCB7IE9yZGVyIH0gZnJvbSAnLi9vcmRlcic7XG5pbXBvcnQgeyBFc3RhYmxpc2htZW50IH0gZnJvbSAnLi9lc3RhYmxpc2htZW50JztcblxuXG5leHBvcnQgaW50ZXJmYWNlIEJvYXJkIHsgXG4gICAgaWQ/OiBudW1iZXI7XG4gICAgbnVtYmVyPzogbnVtYmVyO1xuICAgIHN0YXR1cz86IEJvYXJkLlN0YXR1c0VudW07XG4gICAgZXN0YWJsaXNobWVudD86IEVzdGFibGlzaG1lbnQ7XG4gICAgY3VycmVudE9yZGVyPzogT3JkZXI7XG4gICAgY2FwYWNpdHk/OiBudW1iZXI7XG4gICAgbG9jYXRpb24/OiBzdHJpbmc7XG4gICAgcmVzZXJ2ZWQ/OiBib29sZWFuO1xuICAgIGNyZWF0aW9uRGF0ZT86IHN0cmluZztcbiAgICBsYXN0VXBkYXRlRGF0ZT86IHN0cmluZztcbn1cbmV4cG9ydCBuYW1lc3BhY2UgQm9hcmQge1xuICAgIGV4cG9ydCB0eXBlIFN0YXR1c0VudW0gPSAnT1BFTicgfCAnQ0xPU0VEJztcbiAgICBleHBvcnQgY29uc3QgU3RhdHVzRW51bSA9IHtcbiAgICAgICAgT3BlbjogJ09QRU4nIGFzIFN0YXR1c0VudW0sXG4gICAgICAgIENsb3NlZDogJ0NMT1NFRCcgYXMgU3RhdHVzRW51bVxuICAgIH07XG59XG5cblxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9hcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9tb2RlbC9ib2FyZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF5QkEsTUFBTSxLQUFXLEtBQUssQ0FNckI7QUFORCxXQUFpQixLQUFLO0lBRUwsZ0JBQVUsR0FBRztRQUN0QixJQUFJLEVBQUUsTUFBb0I7UUFDMUIsTUFBTSxFQUFFLFFBQXNCO0tBQ2pDLENBQUM7QUFDTixDQUFDLEVBTmdCLEtBQUssS0FBTCxLQUFLLFFBTXJCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBrYXJpYnUgQVBJXG4gKlxuICogQ29udGFjdDogc3VwcG9ydEBrYXJpYnUuZ2FcbiAqXG4gKiBOT1RFOiBUaGlzIGNsYXNzIGlzIGF1dG8gZ2VuZXJhdGVkIGJ5IE9wZW5BUEkgR2VuZXJhdG9yIChodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2gpLlxuICogaHR0cHM6Ly9vcGVuYXBpLWdlbmVyYXRvci50ZWNoXG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXG4gKi9cbmltcG9ydCB7IE9yZGVyIH0gZnJvbSAnLi9vcmRlcic7XG5pbXBvcnQgeyBFc3RhYmxpc2htZW50IH0gZnJvbSAnLi9lc3RhYmxpc2htZW50JztcblxuXG5leHBvcnQgaW50ZXJmYWNlIEJvYXJkIHsgXG4gICAgaWQ/OiBudW1iZXI7XG4gICAgbnVtYmVyPzogbnVtYmVyO1xuICAgIHN0YXR1cz86IEJvYXJkLlN0YXR1c0VudW07XG4gICAgZXN0YWJsaXNobWVudD86IEVzdGFibGlzaG1lbnQ7XG4gICAgY3VycmVudE9yZGVycz86IEFycmF5PE9yZGVyPjtcbiAgICBjYXBhY2l0eT86IG51bWJlcjtcbiAgICBsb2NhdGlvbj86IHN0cmluZztcbiAgICByZXNlcnZlZD86IGJvb2xlYW47XG4gICAgY3JlYXRpb25EYXRlPzogc3RyaW5nO1xuICAgIGxhc3RVcGRhdGVEYXRlPzogc3RyaW5nO1xufVxuZXhwb3J0IG5hbWVzcGFjZSBCb2FyZCB7XG4gICAgZXhwb3J0IHR5cGUgU3RhdHVzRW51bSA9ICdPUEVOJyB8ICdDTE9TRUQnO1xuICAgIGV4cG9ydCBjb25zdCBTdGF0dXNFbnVtID0ge1xuICAgICAgICBPcGVuOiAnT1BFTicgYXMgU3RhdHVzRW51bSxcbiAgICAgICAgQ2xvc2VkOiAnQ0xPU0VEJyBhcyBTdGF0dXNFbnVtXG4gICAgfTtcbn1cblxuXG4iXX0=

package/esm2022/model/boardResponseDTO.mjs

@@ -5,4 +5,4 @@ export var BoardResponseDTO;
         Closed: 'CLOSED'
     };
 })(BoardResponseDTO || (BoardResponseDTO = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9hcmRSZXNwb25zZURUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL2JvYXJkUmVzcG9uc2VEVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBdUJBLE1BQU0sS0FBVyxnQkFBZ0IsQ0FNaEM7QUFORCxXQUFpQixnQkFBZ0I7SUFFaEIsMkJBQVUsR0FBRztRQUN0QixJQUFJLEVBQUUsTUFBb0I7UUFDMUIsTUFBTSxFQUFFLFFBQXNCO0tBQ2pDLENBQUM7QUFDTixDQUFDLEVBTmdCLGdCQUFnQixLQUFoQixnQkFBZ0IsUUFNaEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGthcmlidSBBUElcbiAqXG4gKiBDb250YWN0OiBzdXBwb3J0QGthcmlidS5nYVxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgT3JkZXJSZXNwb25zZURUTyB9IGZyb20gJy4vb3JkZXJSZXNwb25zZURUTyc7XG5pbXBvcnQgeyBFc3RhYmxpc2htZW50UmVzcG9uc2VEVE8gfSBmcm9tICcuL2VzdGFibGlzaG1lbnRSZXNwb25zZURUTyc7XG5cblxuZXhwb3J0IGludGVyZmFjZSBCb2FyZFJlc3BvbnNlRFRPIHsgXG4gICAgaWQ/OiBudW1iZXI7XG4gICAgbnVtYmVyPzogbnVtYmVyO1xuICAgIHN0YXR1cz86IEJvYXJkUmVzcG9uc2VEVE8uU3RhdHVzRW51bTtcbiAgICBjdXJyZW50T3JkZXI/OiBPcmRlclJlc3BvbnNlRFRPO1xuICAgIGNhcGFjaXR5PzogbnVtYmVyO1xuICAgIGxvY2F0aW9uPzogc3RyaW5nO1xuICAgIHJlc2VydmVkPzogYm9vbGVhbjtcbiAgICBlc3RhYmxpc2htZW50UmVzcG9uc2VEVE8/OiBFc3RhYmxpc2htZW50UmVzcG9uc2VEVE87XG59XG5leHBvcnQgbmFtZXNwYWNlIEJvYXJkUmVzcG9uc2VEVE8ge1xuICAgIGV4cG9ydCB0eXBlIFN0YXR1c0VudW0gPSAnT1BFTicgfCAnQ0xPU0VEJztcbiAgICBleHBvcnQgY29uc3QgU3RhdHVzRW51bSA9IHtcbiAgICAgICAgT3BlbjogJ09QRU4nIGFzIFN0YXR1c0VudW0sXG4gICAgICAgIENsb3NlZDogJ0NMT1NFRCcgYXMgU3RhdHVzRW51bVxuICAgIH07XG59XG5cblxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9hcmRSZXNwb25zZURUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL2JvYXJkUmVzcG9uc2VEVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBdUJBLE1BQU0sS0FBVyxnQkFBZ0IsQ0FNaEM7QUFORCxXQUFpQixnQkFBZ0I7SUFFaEIsMkJBQVUsR0FBRztRQUN0QixJQUFJLEVBQUUsTUFBb0I7UUFDMUIsTUFBTSxFQUFFLFFBQXNCO0tBQ2pDLENBQUM7QUFDTixDQUFDLEVBTmdCLGdCQUFnQixLQUFoQixnQkFBZ0IsUUFNaEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGthcmlidSBBUElcbiAqXG4gKiBDb250YWN0OiBzdXBwb3J0QGthcmlidS5nYVxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgT3JkZXJSZXNwb25zZURUTyB9IGZyb20gJy4vb3JkZXJSZXNwb25zZURUTyc7XG5pbXBvcnQgeyBFc3RhYmxpc2htZW50UmVzcG9uc2VEVE8gfSBmcm9tICcuL2VzdGFibGlzaG1lbnRSZXNwb25zZURUTyc7XG5cblxuZXhwb3J0IGludGVyZmFjZSBCb2FyZFJlc3BvbnNlRFRPIHsgXG4gICAgaWQ/OiBudW1iZXI7XG4gICAgbnVtYmVyPzogbnVtYmVyO1xuICAgIHN0YXR1cz86IEJvYXJkUmVzcG9uc2VEVE8uU3RhdHVzRW51bTtcbiAgICBjdXJyZW50T3JkZXJzPzogQXJyYXk8T3JkZXJSZXNwb25zZURUTz47XG4gICAgY2FwYWNpdHk/OiBudW1iZXI7XG4gICAgbG9jYXRpb24/OiBzdHJpbmc7XG4gICAgcmVzZXJ2ZWQ/OiBib29sZWFuO1xuICAgIGVzdGFibGlzaG1lbnRSZXNwb25zZURUTz86IEVzdGFibGlzaG1lbnRSZXNwb25zZURUTztcbn1cbmV4cG9ydCBuYW1lc3BhY2UgQm9hcmRSZXNwb25zZURUTyB7XG4gICAgZXhwb3J0IHR5cGUgU3RhdHVzRW51bSA9ICdPUEVOJyB8ICdDTE9TRUQnO1xuICAgIGV4cG9ydCBjb25zdCBTdGF0dXNFbnVtID0ge1xuICAgICAgICBPcGVuOiAnT1BFTicgYXMgU3RhdHVzRW51bSxcbiAgICAgICAgQ2xvc2VkOiAnQ0xPU0VEJyBhcyBTdGF0dXNFbnVtXG4gICAgfTtcbn1cblxuXG4iXX0=

package/esm2022/model/categoryResponseDTO.mjs

@@ -8,4 +8,4 @@
  * Do not edit the class manually.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2F0ZWdvcnlSZXNwb25zZURUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL2NhdGVnb3J5UmVzcG9uc2VEVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGthcmlidSBBUElcbiAqXG4gKiBDb250YWN0OiBzdXBwb3J0QGthcmlidS5nYVxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuXG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2F0ZWdvcnlSZXNwb25zZURUTyB7IFxuICAgIGlkPzogbnVtYmVyO1xuICAgIG5hbWU/OiBzdHJpbmc7XG4gICAgY29kZT86IHN0cmluZztcbiAgICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgICBpbWFnZT86IHN0cmluZztcbiAgICBhY3RpdmU/OiBib29sZWFuO1xuICAgIGNyZWF0aW9uRGF0ZT86IHN0cmluZztcbiAgICBsYXN0VXBkYXRlRGF0ZT86IHN0cmluZztcbn1cblxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2F0ZWdvcnlSZXNwb25zZURUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL2NhdGVnb3J5UmVzcG9uc2VEVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGthcmlidSBBUElcbiAqXG4gKiBDb250YWN0OiBzdXBwb3J0QGthcmlidS5nYVxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuXG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2F0ZWdvcnlSZXNwb25zZURUTyB7IFxuICAgIGlkPzogbnVtYmVyO1xuICAgIG5hbWU/OiBzdHJpbmc7XG4gICAgY29kZT86IHN0cmluZztcbiAgICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgICBpbWFnZT86IHN0cmluZztcbiAgICBhY3RpdmU/OiBib29sZWFuO1xufVxuXG4iXX0=

package/esm2022/model/establishment.mjs

@@ -31,4 +31,4 @@ export var Establishment;
         Other: 'OTHER'
     };
 })(Establishment || (Establishment = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXN0YWJsaXNobWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL2VzdGFibGlzaG1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBNENBLE1BQU0sS0FBVyxhQUFhLENBZ0M3QjtBQWhDRCxXQUFpQixhQUFhO0lBRWIsc0JBQVEsR0FBRztRQUNwQixVQUFVLEVBQUUsWUFBd0I7UUFDcEMsR0FBRyxFQUFFLEtBQWlCO1FBQ3RCLElBQUksRUFBRSxNQUFrQjtRQUN4QixHQUFHLEVBQUUsS0FBaUI7UUFDdEIsTUFBTSxFQUFFLFFBQW9CO1FBQzVCLFVBQVUsRUFBRSxhQUF5QjtRQUNyQyxlQUFlLEVBQUUsbUJBQStCO1FBQ2hELFNBQVMsRUFBRSxZQUF3QjtRQUNuQyxTQUFTLEVBQUUsWUFBd0I7UUFDbkMsU0FBUyxFQUFFLFlBQXdCO1FBQ25DLFFBQVEsRUFBRSxVQUFzQjtRQUNoQyxTQUFTLEVBQUUsV0FBdUI7UUFDbEMsTUFBTSxFQUFFLFFBQW9CO1FBQzVCLFNBQVMsRUFBRSxZQUF3QjtRQUNuQyxhQUFhLEVBQUUsZUFBMkI7UUFDMUMsYUFBYSxFQUFFLGdCQUE0QjtRQUMzQyxVQUFVLEVBQUUsYUFBeUI7UUFDckMsTUFBTSxFQUFFLFFBQW9CO1FBQzVCLFNBQVMsRUFBRSxXQUF1QjtRQUNsQyxHQUFHLEVBQUUsS0FBaUI7UUFDdEIsS0FBSyxFQUFFLE9BQW1CO1FBQzFCLEtBQUssRUFBRSxPQUFtQjtRQUMxQixNQUFNLEVBQUUsUUFBb0I7UUFDNUIsVUFBVSxFQUFFLGFBQXlCO1FBQ3JDLGVBQWUsRUFBRSxtQkFBK0I7UUFDaEQsTUFBTSxFQUFFLFFBQW9CO1FBQzVCLEdBQUcsRUFBRSxLQUFpQjtRQUN0QixLQUFLLEVBQUUsT0FBbUI7S0FDN0IsQ0FBQztBQUNOLENBQUMsRUFoQ2dCLGFBQWEsS0FBYixhQUFhLFFBZ0M3QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICoga2FyaWJ1IEFQSVxuICpcbiAqIENvbnRhY3Q6IHN1cHBvcnRAa2FyaWJ1LmdhXG4gKlxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSBPcGVuQVBJIEdlbmVyYXRvciAoaHR0cHM6Ly9vcGVuYXBpLWdlbmVyYXRvci50ZWNoKS5cbiAqIGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaFxuICogRG8gbm90IGVkaXQgdGhlIGNsYXNzIG1hbnVhbGx5LlxuICovXG5pbXBvcnQgeyBCb2FyZCB9IGZyb20gJy4vYm9hcmQnO1xuaW1wb3J0IHsgQ2F0ZWdvcnkgfSBmcm9tICcuL2NhdGVnb3J5JztcbmltcG9ydCB7IEVzdGFibGlzaG1lbnRBY2Nlc3NvciB9IGZyb20gJy4vZXN0YWJsaXNobWVudEFjY2Vzc29yJztcbmltcG9ydCB7IFVzZXIgfSBmcm9tICcuL3VzZXInO1xuaW1wb3J0IHsgRGFzaGJvYXJkIH0gZnJvbSAnLi9kYXNoYm9hcmQnO1xuaW1wb3J0IHsgUHJvZHVjdCB9IGZyb20gJy4vcHJvZHVjdCc7XG5cblxuZXhwb3J0IGludGVyZmFjZSBFc3RhYmxpc2htZW50IHsgXG4gICAgaWQ/OiBudW1iZXI7XG4gICAgYWNjZXNzSWQ/OiBzdHJpbmc7XG4gICAgbmFtZT86IHN0cmluZztcbiAgICBhZGRyZXNzPzogc3RyaW5nO1xuICAgIGNpdHk/OiBzdHJpbmc7XG4gICAgY291bnRyeT86IHN0cmluZztcbiAgICBlbWFpbD86IHN0cmluZztcbiAgICB3ZWJzaXRlPzogc3RyaW5nO1xuICAgIGZhY2Vib29rPzogc3RyaW5nO1xuICAgIGluc3RhZ3JhbT86IHN0cmluZztcbiAgICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgICBpbWFnZT86IHN0cmluZztcbiAgICBsb2dvPzogc3RyaW5nO1xuICAgIGxvbmdpdHVkZT86IHN0cmluZztcbiAgICBsYXRpdHVkZT86IHN0cmluZztcbiAgICB0ZWw/OiBzdHJpbmc7XG4gICAgdHlwZT86IEVzdGFibGlzaG1lbnQuVHlwZUVudW07XG4gICAgYm9hcmRzPzogQXJyYXk8Qm9hcmQ+O1xuICAgIHVzZXJzPzogQXJyYXk8VXNlcj47XG4gICAgcHJvZHVjdD86IEFycmF5PFByb2R1Y3Q+O1xuICAgIGRhc2hib2FyZD86IERhc2hib2FyZDtcbiAgICBhY2Nlc3Nvcj86IEFycmF5PEVzdGFibGlzaG1lbnRBY2Nlc3Nvcj47XG4gICAgY3JlYXRpb25EYXRlPzogc3RyaW5nO1xuICAgIGxhc3RVcGRhdGVEYXRlPzogc3RyaW5nO1xuICAgIGNhdGVnb3J5PzogQ2F0ZWdvcnk7XG59XG5leHBvcnQgbmFtZXNwYWNlIEVzdGFibGlzaG1lbnQge1xuICAgIGV4cG9ydCB0eXBlIFR5cGVFbnVtID0gJ1JFU1RBVVJBTlQnIHwgJ0JBUicgfCAnQ0FGRScgfCAnUFVCJyB8ICdCQUtFUlknIHwgJ1BBU1RSWV9TSE9QJyB8ICdJQ0VfQ1JFQU1fUEFSTE9VUicgfCAnRk9PRF9UUlVDSycgfCAnRk9PRF9TVEFORCcgfCAnRk9PRF9DT1VSVCcgfCAnQ0FURVJJTkcnIHwgJ0NBRkVURVJJQScgfCAnQlVGRkVUJyB8ICdTV0VFVF9TSE9QJyB8ICdDT05GRUNUSU9ORVJZJyB8ICdDSE9DT0xBVEVfU0hPUCcgfCAnQ0FORFlfU1RPUkUnIHwgJ0JJU1RSTycgfCAnQlJBU1NFUklFJyB8ICdJTk4nIHwgJ0hPVEVMJyB8ICdNT1RFTCcgfCAnSE9TVEVMJyB8ICdHVUVTVF9IT1VTRScgfCAnQkVEX0FORF9CUkVBS0ZBU1QnIHwgJ1JFU09SVCcgfCAnU1BBJyB8ICdPVEhFUic7XG4gICAgZXhwb3J0IGNvbnN0IFR5cGVFbnVtID0ge1xuICAgICAgICBSZXN0YXVyYW50OiAnUkVTVEFVUkFOVCcgYXMgVHlwZUVudW0sXG4gICAgICAgIEJhcjogJ0JBUicgYXMgVHlwZUVudW0sXG4gICAgICAgIENhZmU6ICdDQUZFJyBhcyBUeXBlRW51bSxcbiAgICAgICAgUHViOiAnUFVCJyBhcyBUeXBlRW51bSxcbiAgICAgICAgQmFrZXJ5OiAnQkFLRVJZJyBhcyBUeXBlRW51bSxcbiAgICAgICAgUGFzdHJ5U2hvcDogJ1BBU1RSWV9TSE9QJyBhcyBUeXBlRW51bSxcbiAgICAgICAgSWNlQ3JlYW1QYXJsb3VyOiAnSUNFX0NSRUFNX1BBUkxPVVInIGFzIFR5cGVFbnVtLFxuICAgICAgICBGb29kVHJ1Y2s6ICdGT09EX1RSVUNLJyBhcyBUeXBlRW51bSxcbiAgICAgICAgRm9vZFN0YW5kOiAnRk9PRF9TVEFORCcgYXMgVHlwZUVudW0sXG4gICAgICAgIEZvb2RDb3VydDogJ0ZPT0RfQ09VUlQnIGFzIFR5cGVFbnVtLFxuICAgICAgICBDYXRlcmluZzogJ0NBVEVSSU5HJyBhcyBUeXBlRW51bSxcbiAgICAgICAgQ2FmZXRlcmlhOiAnQ0FGRVRFUklBJyBhcyBUeXBlRW51bSxcbiAgICAgICAgQnVmZmV0OiAnQlVGRkVUJyBhcyBUeXBlRW51bSxcbiAgICAgICAgU3dlZXRTaG9wOiAnU1dFRVRfU0hPUCcgYXMgVHlwZUVudW0sXG4gICAgICAgIENvbmZlY3Rpb25lcnk6ICdDT05GRUNUSU9ORVJZJyBhcyBUeXBlRW51bSxcbiAgICAgICAgQ2hvY29sYXRlU2hvcDogJ0NIT0NPTEFURV9TSE9QJyBhcyBUeXBlRW51bSxcbiAgICAgICAgQ2FuZHlTdG9yZTogJ0NBTkRZX1NUT1JFJyBhcyBUeXBlRW51bSxcbiAgICAgICAgQmlzdHJvOiAnQklTVFJPJyBhcyBUeXBlRW51bSxcbiAgICAgICAgQnJhc3NlcmllOiAnQlJBU1NFUklFJyBhcyBUeXBlRW51bSxcbiAgICAgICAgSW5uOiAnSU5OJyBhcyBUeXBlRW51bSxcbiAgICAgICAgSG90ZWw6ICdIT1RFTCcgYXMgVHlwZUVudW0sXG4gICAgICAgIE1vdGVsOiAnTU9URUwnIGFzIFR5cGVFbnVtLFxuICAgICAgICBIb3N0ZWw6ICdIT1NURUwnIGFzIFR5cGVFbnVtLFxuICAgICAgICBHdWVzdEhvdXNlOiAnR1VFU1RfSE9VU0UnIGFzIFR5cGVFbnVtLFxuICAgICAgICBCZWRBbmRCcmVha2Zhc3Q6ICdCRURfQU5EX0JSRUFLRkFTVCcgYXMgVHlwZUVudW0sXG4gICAgICAgIFJlc29ydDogJ1JFU09SVCcgYXMgVHlwZUVudW0sXG4gICAgICAgIFNwYTogJ1NQQScgYXMgVHlwZUVudW0sXG4gICAgICAgIE90aGVyOiAnT1RIRVInIGFzIFR5cGVFbnVtXG4gICAgfTtcbn1cblxuXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/model/order.mjs

@@ -5,4 +5,4 @@ export var Order;
         Paid: 'PAID'
     };
 })(Order || (Order = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9tb2RlbC9vcmRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEyQkEsTUFBTSxLQUFXLEtBQUssQ0FNckI7QUFORCxXQUFpQixLQUFLO0lBRUwsZ0JBQVUsR0FBRztRQUN0QixVQUFVLEVBQUUsYUFBMkI7UUFDdkMsSUFBSSxFQUFFLE1BQW9CO0tBQzdCLENBQUM7QUFDTixDQUFDLEVBTmdCLEtBQUssS0FBTCxLQUFLLFFBTXJCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBrYXJpYnUgQVBJXG4gKlxuICogQ29udGFjdDogc3VwcG9ydEBrYXJpYnUuZ2FcbiAqXG4gKiBOT1RFOiBUaGlzIGNsYXNzIGlzIGF1dG8gZ2VuZXJhdGVkIGJ5IE9wZW5BUEkgR2VuZXJhdG9yIChodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2gpLlxuICogaHR0cHM6Ly9vcGVuYXBpLWdlbmVyYXRvci50ZWNoXG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXG4gKi9cbmltcG9ydCB7IFBheW1lbnQgfSBmcm9tICcuL3BheW1lbnQnO1xuaW1wb3J0IHsgQm9hcmQgfSBmcm9tICcuL2JvYXJkJztcbmltcG9ydCB7IEludm9pY2UgfSBmcm9tICcuL2ludm9pY2UnO1xuaW1wb3J0IHsgT3JkZXJJdGVtIH0gZnJvbSAnLi9vcmRlckl0ZW0nO1xuXG5cbmV4cG9ydCBpbnRlcmZhY2UgT3JkZXIgeyBcbiAgICBpZD86IG51bWJlcjtcbiAgICBzdGF0dXM/OiBPcmRlci5TdGF0dXNFbnVtO1xuICAgIGRhdGU/OiBzdHJpbmc7XG4gICAgdG90YWw/OiBudW1iZXI7XG4gICAgaXRlbXM/OiBBcnJheTxPcmRlckl0ZW0+O1xuICAgIHBheW1lbnRzPzogQXJyYXk8UGF5bWVudD47XG4gICAgaW52b2ljZT86IEludm9pY2U7XG4gICAgYm9hcmQ/OiBCb2FyZDtcbiAgICBjcmVhdGlvbkRhdGU/OiBzdHJpbmc7XG4gICAgbGFzdFVwZGF0ZURhdGU/OiBzdHJpbmc7XG59XG5leHBvcnQgbmFtZXNwYWNlIE9yZGVyIHtcbiAgICBleHBvcnQgdHlwZSBTdGF0dXNFbnVtID0gJ0lOX1BST0dSRVNTJyB8ICdQQUlEJztcbiAgICBleHBvcnQgY29uc3QgU3RhdHVzRW51bSA9IHtcbiAgICAgICAgSW5Qcm9ncmVzczogJ0lOX1BST0dSRVNTJyBhcyBTdGF0dXNFbnVtLFxuICAgICAgICBQYWlkOiAnUEFJRCcgYXMgU3RhdHVzRW51bVxuICAgIH07XG59XG5cblxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9tb2RlbC9vcmRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE0QkEsTUFBTSxLQUFXLEtBQUssQ0FNckI7QUFORCxXQUFpQixLQUFLO0lBRUwsZ0JBQVUsR0FBRztRQUN0QixVQUFVLEVBQUUsYUFBMkI7UUFDdkMsSUFBSSxFQUFFLE1BQW9CO0tBQzdCLENBQUM7QUFDTixDQUFDLEVBTmdCLEtBQUssS0FBTCxLQUFLLFFBTXJCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBrYXJpYnUgQVBJXG4gKlxuICogQ29udGFjdDogc3VwcG9ydEBrYXJpYnUuZ2FcbiAqXG4gKiBOT1RFOiBUaGlzIGNsYXNzIGlzIGF1dG8gZ2VuZXJhdGVkIGJ5IE9wZW5BUEkgR2VuZXJhdG9yIChodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2gpLlxuICogaHR0cHM6Ly9vcGVuYXBpLWdlbmVyYXRvci50ZWNoXG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXG4gKi9cbmltcG9ydCB7IFBheW1lbnQgfSBmcm9tICcuL3BheW1lbnQnO1xuaW1wb3J0IHsgQm9hcmQgfSBmcm9tICcuL2JvYXJkJztcbmltcG9ydCB7IEludm9pY2UgfSBmcm9tICcuL2ludm9pY2UnO1xuaW1wb3J0IHsgT3JkZXJJdGVtIH0gZnJvbSAnLi9vcmRlckl0ZW0nO1xuXG5cbmV4cG9ydCBpbnRlcmZhY2UgT3JkZXIgeyBcbiAgICBpZD86IG51bWJlcjtcbiAgICBjb2RlPzogc3RyaW5nO1xuICAgIHN0YXR1cz86IE9yZGVyLlN0YXR1c0VudW07XG4gICAgZGF0ZT86IHN0cmluZztcbiAgICB0b3RhbD86IG51bWJlcjtcbiAgICBpdGVtcz86IEFycmF5PE9yZGVySXRlbT47XG4gICAgcGF5bWVudHM/OiBBcnJheTxQYXltZW50PjtcbiAgICBpbnZvaWNlPzogSW52b2ljZTtcbiAgICBib2FyZD86IEJvYXJkO1xuICAgIGNyZWF0aW9uRGF0ZT86IHN0cmluZztcbiAgICBsYXN0VXBkYXRlRGF0ZT86IHN0cmluZztcbn1cbmV4cG9ydCBuYW1lc3BhY2UgT3JkZXIge1xuICAgIGV4cG9ydCB0eXBlIFN0YXR1c0VudW0gPSAnSU5fUFJPR1JFU1MnIHwgJ1BBSUQnO1xuICAgIGV4cG9ydCBjb25zdCBTdGF0dXNFbnVtID0ge1xuICAgICAgICBJblByb2dyZXNzOiAnSU5fUFJPR1JFU1MnIGFzIFN0YXR1c0VudW0sXG4gICAgICAgIFBhaWQ6ICdQQUlEJyBhcyBTdGF0dXNFbnVtXG4gICAgfTtcbn1cblxuXG4iXX0=

package/esm2022/model/orderResponseDTO.mjs

@@ -5,4 +5,4 @@ export var OrderResponseDTO;
         Paid: 'PAID'
     };
 })(OrderResponseDTO || (OrderResponseDTO = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXJSZXNwb25zZURUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL29yZGVyUmVzcG9uc2VEVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBMEJBLE1BQU0sS0FBVyxnQkFBZ0IsQ0FNaEM7QUFORCxXQUFpQixnQkFBZ0I7SUFFaEIsMkJBQVUsR0FBRztRQUN0QixVQUFVLEVBQUUsYUFBMkI7UUFDdkMsSUFBSSxFQUFFLE1BQW9CO0tBQzdCLENBQUM7QUFDTixDQUFDLEVBTmdCLGdCQUFnQixLQUFoQixnQkFBZ0IsUUFNaEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGthcmlidSBBUElcbiAqXG4gKiBDb250YWN0OiBzdXBwb3J0QGthcmlidS5nYVxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgSW52b2ljZURUTyB9IGZyb20gJy4vaW52b2ljZURUTyc7XG5pbXBvcnQgeyBCb2FyZFJlc3BvbnNlRFRPIH0gZnJvbSAnLi9ib2FyZFJlc3BvbnNlRFRPJztcbmltcG9ydCB7IE9yZGVySXRlbVJlc3BvbnNlRFRPIH0gZnJvbSAnLi9vcmRlckl0ZW1SZXNwb25zZURUTyc7XG5pbXBvcnQgeyBQYXltZW50RFRPIH0gZnJvbSAnLi9wYXltZW50RFRPJztcblxuXG5leHBvcnQgaW50ZXJmYWNlIE9yZGVyUmVzcG9uc2VEVE8geyBcbiAgICBpZD86IG51bWJlcjtcbiAgICBkYXRlPzogc3RyaW5nO1xuICAgIHVwZGF0ZWRBdD86IHN0cmluZztcbiAgICBzdGF0dXM/OiBPcmRlclJlc3BvbnNlRFRPLlN0YXR1c0VudW07XG4gICAgdG90YWw/OiBudW1iZXI7XG4gICAgYm9hcmRSZXNwb25zZURUTz86IEJvYXJkUmVzcG9uc2VEVE87XG4gICAgaXRlbXM/OiBBcnJheTxPcmRlckl0ZW1SZXNwb25zZURUTz47XG4gICAgcGF5bWVudHM/OiBBcnJheTxQYXltZW50RFRPPjtcbiAgICBpbnZvaWNlPzogSW52b2ljZURUTztcbn1cbmV4cG9ydCBuYW1lc3BhY2UgT3JkZXJSZXNwb25zZURUTyB7XG4gICAgZXhwb3J0IHR5cGUgU3RhdHVzRW51bSA9ICdJTl9QUk9HUkVTUycgfCAnUEFJRCc7XG4gICAgZXhwb3J0IGNvbnN0IFN0YXR1c0VudW0gPSB7XG4gICAgICAgIEluUHJvZ3Jlc3M6ICdJTl9QUk9HUkVTUycgYXMgU3RhdHVzRW51bSxcbiAgICAgICAgUGFpZDogJ1BBSUQnIGFzIFN0YXR1c0VudW1cbiAgICB9O1xufVxuXG5cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXJSZXNwb25zZURUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL29yZGVyUmVzcG9uc2VEVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBMkJBLE1BQU0sS0FBVyxnQkFBZ0IsQ0FNaEM7QUFORCxXQUFpQixnQkFBZ0I7SUFFaEIsMkJBQVUsR0FBRztRQUN0QixVQUFVLEVBQUUsYUFBMkI7UUFDdkMsSUFBSSxFQUFFLE1BQW9CO0tBQzdCLENBQUM7QUFDTixDQUFDLEVBTmdCLGdCQUFnQixLQUFoQixnQkFBZ0IsUUFNaEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGthcmlidSBBUElcbiAqXG4gKiBDb250YWN0OiBzdXBwb3J0QGthcmlidS5nYVxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgSW52b2ljZURUTyB9IGZyb20gJy4vaW52b2ljZURUTyc7XG5pbXBvcnQgeyBCb2FyZFJlc3BvbnNlRFRPIH0gZnJvbSAnLi9ib2FyZFJlc3BvbnNlRFRPJztcbmltcG9ydCB7IE9yZGVySXRlbVJlc3BvbnNlRFRPIH0gZnJvbSAnLi9vcmRlckl0ZW1SZXNwb25zZURUTyc7XG5pbXBvcnQgeyBQYXltZW50RFRPIH0gZnJvbSAnLi9wYXltZW50RFRPJztcblxuXG5leHBvcnQgaW50ZXJmYWNlIE9yZGVyUmVzcG9uc2VEVE8geyBcbiAgICBpZD86IG51bWJlcjtcbiAgICBkYXRlPzogc3RyaW5nO1xuICAgIGNvZGU/OiBzdHJpbmc7XG4gICAgdXBkYXRlZEF0Pzogc3RyaW5nO1xuICAgIHN0YXR1cz86IE9yZGVyUmVzcG9uc2VEVE8uU3RhdHVzRW51bTtcbiAgICB0b3RhbD86IG51bWJlcjtcbiAgICBib2FyZFJlc3BvbnNlRFRPPzogQm9hcmRSZXNwb25zZURUTztcbiAgICBpdGVtcz86IEFycmF5PE9yZGVySXRlbVJlc3BvbnNlRFRPPjtcbiAgICBwYXltZW50cz86IEFycmF5PFBheW1lbnREVE8+O1xuICAgIGludm9pY2U/OiBJbnZvaWNlRFRPO1xufVxuZXhwb3J0IG5hbWVzcGFjZSBPcmRlclJlc3BvbnNlRFRPIHtcbiAgICBleHBvcnQgdHlwZSBTdGF0dXNFbnVtID0gJ0lOX1BST0dSRVNTJyB8ICdQQUlEJztcbiAgICBleHBvcnQgY29uc3QgU3RhdHVzRW51bSA9IHtcbiAgICAgICAgSW5Qcm9ncmVzczogJ0lOX1BST0dSRVNTJyBhcyBTdGF0dXNFbnVtLFxuICAgICAgICBQYWlkOiAnUEFJRCcgYXMgU3RhdHVzRW51bVxuICAgIH07XG59XG5cblxuIl19

package/esm2022/model/productRequestDTO.mjs

@@ -7,13 +7,5 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-export var ProductRequestDTO;
-(function (ProductRequestDTO) {
-    ProductRequestDTO.CategoryEnum = {
-        Drink: 'DRINK',
-        Meal: 'MEAL',
-        Dessert: 'DESSERT',
-        Snack: 'SNACK'
-    };
-})(ProductRequestDTO || (ProductRequestDTO = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdFJlcXVlc3REVE8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9tb2RlbC9wcm9kdWN0UmVxdWVzdERUTy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7R0FRRztBQWtCSCxNQUFNLEtBQVcsaUJBQWlCLENBUWpDO0FBUkQsV0FBaUIsaUJBQWlCO0lBRWpCLDhCQUFZLEdBQUc7UUFDeEIsS0FBSyxFQUFFLE9BQXVCO1FBQzlCLElBQUksRUFBRSxNQUFzQjtRQUM1QixPQUFPLEVBQUUsU0FBeUI7UUFDbEMsS0FBSyxFQUFFLE9BQXVCO0tBQ2pDLENBQUM7QUFDTixDQUFDLEVBUmdCLGlCQUFpQixLQUFqQixpQkFBaUIsUUFRakMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGthcmlidSBBUElcbiAqXG4gKiBDb250YWN0OiBzdXBwb3J0QGthcmlidS5nYVxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuXG5cbmV4cG9ydCBpbnRlcmZhY2UgUHJvZHVjdFJlcXVlc3REVE8geyBcbiAgICBpZD86IG51bWJlcjtcbiAgICBuYW1lPzogc3RyaW5nO1xuICAgIHByaWNlPzogbnVtYmVyO1xuICAgIGNhdGVnb3J5PzogUHJvZHVjdFJlcXVlc3REVE8uQ2F0ZWdvcnlFbnVtO1xuICAgIGNhdGVnb3J5SWQ/OiBudW1iZXI7XG4gICAgc3RvY2s/OiBudW1iZXI7XG4gICAgZGVzY3JpcHRpb24/OiBzdHJpbmc7XG4gICAgaW1hZ2U/OiBzdHJpbmc7XG4gICAgYnJhbmQ/OiBzdHJpbmc7XG4gICAgYWN0aXZlPzogYm9vbGVhbjtcbiAgICBkaXNjb3VudFBlcmNlbnRhZ2U/OiBudW1iZXI7XG4gICAgcmF0aW5nPzogbnVtYmVyO1xuICAgIGVzdGFibGlzaG1lbnRJZD86IG51bWJlcjtcbn1cbmV4cG9ydCBuYW1lc3BhY2UgUHJvZHVjdFJlcXVlc3REVE8ge1xuICAgIGV4cG9ydCB0eXBlIENhdGVnb3J5RW51bSA9ICdEUklOSycgfCAnTUVBTCcgfCAnREVTU0VSVCcgfCAnU05BQ0snO1xuICAgIGV4cG9ydCBjb25zdCBDYXRlZ29yeUVudW0gPSB7XG4gICAgICAgIERyaW5rOiAnRFJJTksnIGFzIENhdGVnb3J5RW51bSxcbiAgICAgICAgTWVhbDogJ01FQUwnIGFzIENhdGVnb3J5RW51bSxcbiAgICAgICAgRGVzc2VydDogJ0RFU1NFUlQnIGFzIENhdGVnb3J5RW51bSxcbiAgICAgICAgU25hY2s6ICdTTkFDSycgYXMgQ2F0ZWdvcnlFbnVtXG4gICAgfTtcbn1cblxuXG4iXX0=
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdFJlcXVlc3REVE8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9tb2RlbC9wcm9kdWN0UmVxdWVzdERUTy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7R0FRRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICoga2FyaWJ1IEFQSVxuICpcbiAqIENvbnRhY3Q6IHN1cHBvcnRAa2FyaWJ1LmdhXG4gKlxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSBPcGVuQVBJIEdlbmVyYXRvciAoaHR0cHM6Ly9vcGVuYXBpLWdlbmVyYXRvci50ZWNoKS5cbiAqIGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaFxuICogRG8gbm90IGVkaXQgdGhlIGNsYXNzIG1hbnVhbGx5LlxuICovXG5cblxuZXhwb3J0IGludGVyZmFjZSBQcm9kdWN0UmVxdWVzdERUTyB7IFxuICAgIGlkPzogbnVtYmVyO1xuICAgIG5hbWU/OiBzdHJpbmc7XG4gICAgcHJpY2U/OiBudW1iZXI7XG4gICAgY2F0ZWdvcnlJZD86IG51bWJlcjtcbiAgICBzdG9jaz86IG51bWJlcjtcbiAgICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgICBpbWFnZT86IHN0cmluZztcbiAgICBicmFuZD86IHN0cmluZztcbiAgICBhY3RpdmU/OiBib29sZWFuO1xuICAgIGRpc2NvdW50UGVyY2VudGFnZT86IG51bWJlcjtcbiAgICByYXRpbmc/OiBudW1iZXI7XG4gICAgZXN0YWJsaXNobWVudElkPzogbnVtYmVyO1xufVxuXG4iXX0=

package/esm2022/model/productResponseDTO.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdFJlc3BvbnNlRFRPLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vbW9kZWwvcHJvZHVjdFJlc3BvbnNlRFRPLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGthcmlidSBBUElcbiAqXG4gKiBDb250YWN0OiBzdXBwb3J0QGthcmlidS5nYVxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgRXN0YWJsaXNobWVudFJlc3BvbnNlRFRPIH0gZnJvbSAnLi9lc3RhYmxpc2htZW50UmVzcG9uc2VEVE8nO1xuaW1wb3J0IHsgQ2F0ZWdvcnlSZXNwb25zZURUTyB9IGZyb20gJy4vY2F0ZWdvcnlSZXNwb25zZURUTyc7XG5cblxuZXhwb3J0IGludGVyZmFjZSBQcm9kdWN0UmVzcG9uc2VEVE8geyBcbiAgICBpZD86IG51bWJlcjtcbiAgICBuYW1lPzogc3RyaW5nO1xuICAgIHByaWNlPzogbnVtYmVyO1xuICAgIGNhdGVnb3J5PzogQ2F0ZWdvcnlSZXNwb25zZURUTztcbiAgICBzdG9jaz86IG51bWJlcjtcbiAgICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgICBpbWFnZT86IHN0cmluZztcbiAgICBicmFuZD86IHN0cmluZztcbiAgICBhY3RpdmU/OiBib29sZWFuO1xuICAgIGRpc2NvdW50UGVyY2VudGFnZT86IG51bWJlcjtcbiAgICByYXRpbmc/OiBudW1iZXI7XG4gICAgZXN0YWJsaXNobWVudD86IEVzdGFibGlzaG1lbnRSZXNwb25zZURUTztcbiAgICBjcmVhdGlvbkRhdGU/OiBzdHJpbmc7XG4gICAgbGFzdFVwZGF0ZURhdGU/OiBzdHJpbmc7XG59XG5cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdFJlc3BvbnNlRFRPLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vbW9kZWwvcHJvZHVjdFJlc3BvbnNlRFRPLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGthcmlidSBBUElcbiAqXG4gKiBDb250YWN0OiBzdXBwb3J0QGthcmlidS5nYVxuICpcbiAqIE5PVEU6IFRoaXMgY2xhc3MgaXMgYXV0byBnZW5lcmF0ZWQgYnkgT3BlbkFQSSBHZW5lcmF0b3IgKGh0dHBzOi8vb3BlbmFwaS1nZW5lcmF0b3IudGVjaCkuXG4gKiBodHRwczovL29wZW5hcGktZ2VuZXJhdG9yLnRlY2hcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgRXN0YWJsaXNobWVudFJlc3BvbnNlRFRPIH0gZnJvbSAnLi9lc3RhYmxpc2htZW50UmVzcG9uc2VEVE8nO1xuaW1wb3J0IHsgQ2F0ZWdvcnlSZXNwb25zZURUTyB9IGZyb20gJy4vY2F0ZWdvcnlSZXNwb25zZURUTyc7XG5cblxuZXhwb3J0IGludGVyZmFjZSBQcm9kdWN0UmVzcG9uc2VEVE8geyBcbiAgICBpZD86IG51bWJlcjtcbiAgICBuYW1lPzogc3RyaW5nO1xuICAgIHByaWNlPzogbnVtYmVyO1xuICAgIGNhdGVnb3J5PzogQ2F0ZWdvcnlSZXNwb25zZURUTztcbiAgICBzdG9jaz86IG51bWJlcjtcbiAgICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgICBpbWFnZT86IHN0cmluZztcbiAgICBhY3RpdmU/OiBib29sZWFuO1xuICAgIHJhdGluZz86IG51bWJlcjtcbiAgICBlc3RhYmxpc2htZW50PzogRXN0YWJsaXNobWVudFJlc3BvbnNlRFRPO1xuICAgIGxhc3RVcGRhdGVEYXRlPzogc3RyaW5nO1xufVxuXG4iXX0=

package/fesm2022/karibu-layer.mjs

@@ -1824,10 +1824,15 @@ class EstablishmentAccessorService extends BaseService {
         super(basePath, configuration);
         this.httpClient = httpClient;
     }
-    createAccessor(establishmentId, observe = 'body', reportProgress = false, options) {
+    createAccessor(establishmentId, name, observe = 'body', reportProgress = false, options) {
         if (establishmentId === null || establishmentId === undefined) {
             throw new Error('Required parameter establishmentId was null or undefined when calling createAccessor.');
         }
+        if (name === null || name === undefined) {
+            throw new Error('Required parameter name was null or undefined when calling createAccessor.');
+        }
+        let localVarQueryParameters = new HttpParams({ encoder: this.encoder });
+        localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, name, 'name');
         let localVarHeaders = this.defaultHeaders;
         const localVarHttpHeaderAcceptSelected = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
             'application/json'
@@ -1852,6 +1857,7 @@ class EstablishmentAccessorService extends BaseService {
         let localVarPath = `/establishment-accessors/create-accessor/${this.configuration.encodeParam({ name: "establishmentId", value: establishmentId, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int64" })}`;
         return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
             context: localVarHttpContext,
+            params: localVarQueryParameters,
             responseType: responseType_,
             withCredentials: this.configuration.withCredentials,
             headers: localVarHeaders,
@@ -1894,6 +1900,42 @@ class EstablishmentAccessorService extends BaseService {
             reportProgress: reportProgress
         });
     }
+    getAccessorByEstablishmentId(id, observe = 'body', reportProgress = false, options) {
+        if (id === null || id === undefined) {
+            throw new Error('Required parameter id was null or undefined when calling getAccessorByEstablishmentId.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        const localVarHttpHeaderAcceptSelected = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([
+            'application/json'
+        ]);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        const localVarHttpContext = options?.context ?? new HttpContext();
+        const localVarTransferCache = options?.transferCache ?? true;
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/establishment-accessors/get-accessor-by-establishment/${this.configuration.encodeParam({ name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int64" })}`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            transferCache: localVarTransferCache,
+            reportProgress: reportProgress
+        });
+    }
     getAccessorById(id, observe = 'body', reportProgress = false, options) {
         if (id === null || id === undefined) {
             throw new Error('Required parameter id was null or undefined when calling getAccessorById.');
@@ -4941,15 +4983,6 @@ var PaymentDTO;
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-var ProductRequestDTO;
-(function (ProductRequestDTO) {
-    ProductRequestDTO.CategoryEnum = {
-        Drink: 'DRINK',
-        Meal: 'MEAL',
-        Dessert: 'DESSERT',
-        Snack: 'SNACK'
-    };
-})(ProductRequestDTO || (ProductRequestDTO = {}));
 
 var Role;
 (function (Role) {
@@ -5064,5 +5097,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { APIS, ApiModule, AuthenticationService, BASE_PATH, Board, BoardRequestDTO, BoardResponseDTO, BoardService, COLLECTION_FORMATS, CategoryService, Configuration, Establishment, EstablishmentAccessorResponseDTO, EstablishmentAccessorService, EstablishmentRequestDTO, EstablishmentResponseDTO, EstablishmentService, InvoiceService, Order, OrderItemService, OrderRequestDTO, OrderResponseDTO, OrderService, Payment, PaymentDTO, PaymentService, ProductRequestDTO, ProductService, Role, RoleDTO, RoleService, User, UserResponseDTO, UserService };
+export { APIS, ApiModule, AuthenticationService, BASE_PATH, Board, BoardRequestDTO, BoardResponseDTO, BoardService, COLLECTION_FORMATS, CategoryService, Configuration, Establishment, EstablishmentAccessorResponseDTO, EstablishmentAccessorService, EstablishmentRequestDTO, EstablishmentResponseDTO, EstablishmentService, InvoiceService, Order, OrderItemService, OrderRequestDTO, OrderResponseDTO, OrderService, Payment, PaymentDTO, PaymentService, ProductService, Role, RoleDTO, RoleService, User, UserResponseDTO, UserService };
 //# sourceMappingURL=karibu-layer.mjs.map