@tennac-booking/sdk 1.0.193 → 1.0.194

package/api.ts

@@ -6701,6 +6701,25 @@ export interface GoogleAuthResponseUser {
      */
     'id': string;
 }
+/**
+ * 
+ * @export
+ * @interface Health200Response
+ */
+export interface Health200Response {
+    /**
+     * 
+     * @type {string}
+     * @memberof Health200Response
+     */
+    'timestamp': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof Health200Response
+     */
+    'status': string;
+}
 /**
  * 
  * @export
@@ -7422,6 +7441,33 @@ export const InvoiceStatusSETUPSUCCESS = {
 export type InvoiceStatusSETUPSUCCESS = typeof InvoiceStatusSETUPSUCCESS[keyof typeof InvoiceStatusSETUPSUCCESS];
 
 
+/**
+ * 
+ * @export
+ * @interface JobResult
+ */
+export interface JobResult {
+    [key: string]: any;
+
+    /**
+     * 
+     * @type {boolean}
+     * @memberof JobResult
+     */
+    'success': boolean;
+    /**
+     * 
+     * @type {string}
+     * @memberof JobResult
+     */
+    'job': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof JobResult
+     */
+    'timestamp': string;
+}
 /**
  * 
  * @export
@@ -14107,6 +14153,100 @@ export const VisibilityType = {
 export type VisibilityType = typeof VisibilityType[keyof typeof VisibilityType];
 
 
+/**
+ * 
+ * @export
+ * @interface WaitListEntryWithPlayer
+ */
+export interface WaitListEntryWithPlayer {
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'id': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'userId': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'clubId': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'targetType': WaitListEntryWithPlayerTargetTypeEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'targetId': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'status': string;
+    /**
+     * 
+     * @type {number}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'position': number;
+    /**
+     * 
+     * @type {number}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'priceInCents': number;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'joinedAt': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'notifiedAt'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'paymentExpiresAt'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'confirmedAt'?: string;
+    /**
+     * 
+     * @type {WaitListPlayer}
+     * @memberof WaitListEntryWithPlayer
+     */
+    'player': WaitListPlayer;
+}
+
+export const WaitListEntryWithPlayerTargetTypeEnum = {
+    Event: 'event',
+    Booking: 'booking',
+    EventBooking: 'event_booking'
+} as const;
+
+export type WaitListEntryWithPlayerTargetTypeEnum = typeof WaitListEntryWithPlayerTargetTypeEnum[keyof typeof WaitListEntryWithPlayerTargetTypeEnum];
+
 /**
  * 
  * @export
@@ -14126,6 +14266,62 @@ export interface WaitListListResponse {
      */
     'total': number;
 }
+/**
+ * 
+ * @export
+ * @interface WaitListPlayer
+ */
+export interface WaitListPlayer {
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListPlayer
+     */
+    'id': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListPlayer
+     */
+    'firstName': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListPlayer
+     */
+    'lastName': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListPlayer
+     */
+    'username'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListPlayer
+     */
+    'profilePicture'?: string;
+}
+/**
+ * 
+ * @export
+ * @interface WaitListPlayersListResponse
+ */
+export interface WaitListPlayersListResponse {
+    /**
+     * 
+     * @type {Array<WaitListEntryWithPlayer>}
+     * @memberof WaitListPlayersListResponse
+     */
+    'waitList': Array<WaitListEntryWithPlayer>;
+    /**
+     * 
+     * @type {number}
+     * @memberof WaitListPlayersListResponse
+     */
+    'total': number;
+}
 /**
  * 
  * @export
@@ -28644,21 +28840,19 @@ export class ImagesApi extends BaseAPI {
 
 
 /**
- * PublicEmailApi - axios parameter creator
+ * JobsApi - axios parameter creator
  * @export
  */
-export const PublicEmailApiAxiosParamCreator = function (configuration?: Configuration) {
+export const JobsApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * 
-         * @param {EmailExistsRequestBody} emailExistsRequestBody 
+         * Job: Capturer les autorisations de paiement qui expirent bientôt Fréquence recommandée: Toutes les 30 minutes
+         * @summary Capture les autorisations Stripe qui expirent dans moins de 4h
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        authEmailExists: async (emailExistsRequestBody: EmailExistsRequestBody, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'emailExistsRequestBody' is not null or undefined
-            assertParamExists('authEmailExists', 'emailExistsRequestBody', emailExistsRequestBody)
-            const localVarPath = `/api/public-email/auth-email-exists`;
+        captureExpiringAuthorizations: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/jobs/capture-expiring-authorizations`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -28666,18 +28860,15 @@ export const PublicEmailApiAxiosParamCreator = function (configuration?: Configu
                 baseOptions = configuration.baseOptions;
             }
 
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
             const localVarHeaderParameter = {} as any;
             const localVarQueryParameter = {} as any;
 
 
     
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(emailExistsRequestBody, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -28685,15 +28876,13 @@ export const PublicEmailApiAxiosParamCreator = function (configuration?: Configu
             };
         },
         /**
-         * 
-         * @param {RequestEmailCodeBody} requestEmailCodeBody 
+         * Job: Capturer les paiements pour les réservations passées Fréquence recommandée: Toutes les heures
+         * @summary Capture les paiements autorisés pour les réservations passées
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        requestPublicEmailVerificationCode: async (requestEmailCodeBody: RequestEmailCodeBody, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'requestEmailCodeBody' is not null or undefined
-            assertParamExists('requestPublicEmailVerificationCode', 'requestEmailCodeBody', requestEmailCodeBody)
-            const localVarPath = `/api/public-email/request-verification-code`;
+        capturePastReservations: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/jobs/capture-past-reservations`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -28701,18 +28890,15 @@ export const PublicEmailApiAxiosParamCreator = function (configuration?: Configu
                 baseOptions = configuration.baseOptions;
             }
 
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
             const localVarHeaderParameter = {} as any;
             const localVarQueryParameter = {} as any;
 
 
     
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(requestEmailCodeBody, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -28720,15 +28906,13 @@ export const PublicEmailApiAxiosParamCreator = function (configuration?: Configu
             };
         },
         /**
-         * 
-         * @param {VerifyEmailCodeBody} verifyEmailCodeBody 
+         * Job: Expirer les réservations en attente de paiement Fréquence recommandée: Toutes les minutes
+         * @summary Expire les réservations en attente de paiement
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        verifyCode: async (verifyEmailCodeBody: VerifyEmailCodeBody, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'verifyEmailCodeBody' is not null or undefined
-            assertParamExists('verifyCode', 'verifyEmailCodeBody', verifyEmailCodeBody)
-            const localVarPath = `/api/public-email/verify-code`;
+        expireBookingWaitingPayments: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/jobs/expire-booking-waiting-payments`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -28736,67 +28920,552 @@ export const PublicEmailApiAxiosParamCreator = function (configuration?: Configu
                 baseOptions = configuration.baseOptions;
             }
 
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
             const localVarHeaderParameter = {} as any;
             const localVarQueryParameter = {} as any;
 
 
     
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(verifyEmailCodeBody, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
-    }
-};
-
-/**
- * PublicEmailApi - functional programming interface
- * @export
- */
-export const PublicEmailApiFp = function(configuration?: Configuration) {
-    const localVarAxiosParamCreator = PublicEmailApiAxiosParamCreator(configuration)
-    return {
         /**
-         * 
-         * @param {EmailExistsRequestBody} emailExistsRequestBody 
+         * Job: Expirer les paiements en attente sur la waitlist Fréquence recommandée: Toutes les minutes
+         * @summary Expire les paiements en attente sur la waitlist
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async authEmailExists(emailExistsRequestBody: EmailExistsRequestBody, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<EmailExistsResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.authEmailExists(emailExistsRequestBody, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['PublicEmailApi.authEmailExists']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        expireWaitlistPayments: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/jobs/expire-waitlist-payments`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
         /**
-         * 
-         * @param {RequestEmailCodeBody} requestEmailCodeBody 
+         * Route de santé pour vérifier que le service jobs est opérationnel
+         * @summary Health check pour les jobs
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async requestPublicEmailVerificationCode(requestEmailCodeBody: RequestEmailCodeBody, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RequestEmailCodeResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.requestPublicEmailVerificationCode(requestEmailCodeBody, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['PublicEmailApi.requestPublicEmailVerificationCode']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        health: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/jobs/health`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
         /**
-         * 
-         * @param {VerifyEmailCodeBody} verifyEmailCodeBody 
+         * Job: Maintenir les créneaux (slots) Fréquence recommandée: Une fois par jour (2h du matin)
+         * @summary Génère les créneaux futurs et nettoie les anciens
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async verifyCode(verifyEmailCodeBody: VerifyEmailCodeBody, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VerifyEmailCodeResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.verifyCode(verifyEmailCodeBody, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+        maintainSlots: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/jobs/maintain-slots`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Job: Libérer les anciennes réservations Fréquence recommandée: Toutes les minutes
+         * @summary Libère les anciennes réservations terminées
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        releaseOldBookings: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/jobs/release-old-bookings`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * JobsApi - functional programming interface
+ * @export
+ */
+export const JobsApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = JobsApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * Job: Capturer les autorisations de paiement qui expirent bientôt Fréquence recommandée: Toutes les 30 minutes
+         * @summary Capture les autorisations Stripe qui expirent dans moins de 4h
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async captureExpiringAuthorizations(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<JobResult>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.captureExpiringAuthorizations(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['JobsApi.captureExpiringAuthorizations']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Job: Capturer les paiements pour les réservations passées Fréquence recommandée: Toutes les heures
+         * @summary Capture les paiements autorisés pour les réservations passées
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async capturePastReservations(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<JobResult>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.capturePastReservations(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['JobsApi.capturePastReservations']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Job: Expirer les réservations en attente de paiement Fréquence recommandée: Toutes les minutes
+         * @summary Expire les réservations en attente de paiement
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async expireBookingWaitingPayments(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<JobResult>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.expireBookingWaitingPayments(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['JobsApi.expireBookingWaitingPayments']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Job: Expirer les paiements en attente sur la waitlist Fréquence recommandée: Toutes les minutes
+         * @summary Expire les paiements en attente sur la waitlist
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async expireWaitlistPayments(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<JobResult>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.expireWaitlistPayments(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['JobsApi.expireWaitlistPayments']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Route de santé pour vérifier que le service jobs est opérationnel
+         * @summary Health check pour les jobs
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async health(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Health200Response>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.health(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['JobsApi.health']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Job: Maintenir les créneaux (slots) Fréquence recommandée: Une fois par jour (2h du matin)
+         * @summary Génère les créneaux futurs et nettoie les anciens
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async maintainSlots(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<JobResult>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.maintainSlots(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['JobsApi.maintainSlots']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Job: Libérer les anciennes réservations Fréquence recommandée: Toutes les minutes
+         * @summary Libère les anciennes réservations terminées
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async releaseOldBookings(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<JobResult>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.releaseOldBookings(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['JobsApi.releaseOldBookings']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    }
+};
+
+/**
+ * JobsApi - factory interface
+ * @export
+ */
+export const JobsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = JobsApiFp(configuration)
+    return {
+        /**
+         * Job: Capturer les autorisations de paiement qui expirent bientôt Fréquence recommandée: Toutes les 30 minutes
+         * @summary Capture les autorisations Stripe qui expirent dans moins de 4h
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        captureExpiringAuthorizations(options?: RawAxiosRequestConfig): AxiosPromise<JobResult> {
+            return localVarFp.captureExpiringAuthorizations(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Job: Capturer les paiements pour les réservations passées Fréquence recommandée: Toutes les heures
+         * @summary Capture les paiements autorisés pour les réservations passées
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        capturePastReservations(options?: RawAxiosRequestConfig): AxiosPromise<JobResult> {
+            return localVarFp.capturePastReservations(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Job: Expirer les réservations en attente de paiement Fréquence recommandée: Toutes les minutes
+         * @summary Expire les réservations en attente de paiement
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        expireBookingWaitingPayments(options?: RawAxiosRequestConfig): AxiosPromise<JobResult> {
+            return localVarFp.expireBookingWaitingPayments(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Job: Expirer les paiements en attente sur la waitlist Fréquence recommandée: Toutes les minutes
+         * @summary Expire les paiements en attente sur la waitlist
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        expireWaitlistPayments(options?: RawAxiosRequestConfig): AxiosPromise<JobResult> {
+            return localVarFp.expireWaitlistPayments(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Route de santé pour vérifier que le service jobs est opérationnel
+         * @summary Health check pour les jobs
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        health(options?: RawAxiosRequestConfig): AxiosPromise<Health200Response> {
+            return localVarFp.health(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Job: Maintenir les créneaux (slots) Fréquence recommandée: Une fois par jour (2h du matin)
+         * @summary Génère les créneaux futurs et nettoie les anciens
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        maintainSlots(options?: RawAxiosRequestConfig): AxiosPromise<JobResult> {
+            return localVarFp.maintainSlots(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Job: Libérer les anciennes réservations Fréquence recommandée: Toutes les minutes
+         * @summary Libère les anciennes réservations terminées
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        releaseOldBookings(options?: RawAxiosRequestConfig): AxiosPromise<JobResult> {
+            return localVarFp.releaseOldBookings(options).then((request) => request(axios, basePath));
+        },
+    };
+};
+
+/**
+ * JobsApi - object-oriented interface
+ * @export
+ * @class JobsApi
+ * @extends {BaseAPI}
+ */
+export class JobsApi extends BaseAPI {
+    /**
+     * Job: Capturer les autorisations de paiement qui expirent bientôt Fréquence recommandée: Toutes les 30 minutes
+     * @summary Capture les autorisations Stripe qui expirent dans moins de 4h
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof JobsApi
+     */
+    public captureExpiringAuthorizations(options?: RawAxiosRequestConfig) {
+        return JobsApiFp(this.configuration).captureExpiringAuthorizations(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Job: Capturer les paiements pour les réservations passées Fréquence recommandée: Toutes les heures
+     * @summary Capture les paiements autorisés pour les réservations passées
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof JobsApi
+     */
+    public capturePastReservations(options?: RawAxiosRequestConfig) {
+        return JobsApiFp(this.configuration).capturePastReservations(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Job: Expirer les réservations en attente de paiement Fréquence recommandée: Toutes les minutes
+     * @summary Expire les réservations en attente de paiement
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof JobsApi
+     */
+    public expireBookingWaitingPayments(options?: RawAxiosRequestConfig) {
+        return JobsApiFp(this.configuration).expireBookingWaitingPayments(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Job: Expirer les paiements en attente sur la waitlist Fréquence recommandée: Toutes les minutes
+     * @summary Expire les paiements en attente sur la waitlist
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof JobsApi
+     */
+    public expireWaitlistPayments(options?: RawAxiosRequestConfig) {
+        return JobsApiFp(this.configuration).expireWaitlistPayments(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Route de santé pour vérifier que le service jobs est opérationnel
+     * @summary Health check pour les jobs
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof JobsApi
+     */
+    public health(options?: RawAxiosRequestConfig) {
+        return JobsApiFp(this.configuration).health(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Job: Maintenir les créneaux (slots) Fréquence recommandée: Une fois par jour (2h du matin)
+     * @summary Génère les créneaux futurs et nettoie les anciens
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof JobsApi
+     */
+    public maintainSlots(options?: RawAxiosRequestConfig) {
+        return JobsApiFp(this.configuration).maintainSlots(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Job: Libérer les anciennes réservations Fréquence recommandée: Toutes les minutes
+     * @summary Libère les anciennes réservations terminées
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof JobsApi
+     */
+    public releaseOldBookings(options?: RawAxiosRequestConfig) {
+        return JobsApiFp(this.configuration).releaseOldBookings(options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+
+
+/**
+ * PublicEmailApi - axios parameter creator
+ * @export
+ */
+export const PublicEmailApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * 
+         * @param {EmailExistsRequestBody} emailExistsRequestBody 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authEmailExists: async (emailExistsRequestBody: EmailExistsRequestBody, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'emailExistsRequestBody' is not null or undefined
+            assertParamExists('authEmailExists', 'emailExistsRequestBody', emailExistsRequestBody)
+            const localVarPath = `/api/public-email/auth-email-exists`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(emailExistsRequestBody, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {RequestEmailCodeBody} requestEmailCodeBody 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        requestPublicEmailVerificationCode: async (requestEmailCodeBody: RequestEmailCodeBody, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'requestEmailCodeBody' is not null or undefined
+            assertParamExists('requestPublicEmailVerificationCode', 'requestEmailCodeBody', requestEmailCodeBody)
+            const localVarPath = `/api/public-email/request-verification-code`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(requestEmailCodeBody, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {VerifyEmailCodeBody} verifyEmailCodeBody 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        verifyCode: async (verifyEmailCodeBody: VerifyEmailCodeBody, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'verifyEmailCodeBody' is not null or undefined
+            assertParamExists('verifyCode', 'verifyEmailCodeBody', verifyEmailCodeBody)
+            const localVarPath = `/api/public-email/verify-code`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(verifyEmailCodeBody, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * PublicEmailApi - functional programming interface
+ * @export
+ */
+export const PublicEmailApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = PublicEmailApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * 
+         * @param {EmailExistsRequestBody} emailExistsRequestBody 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async authEmailExists(emailExistsRequestBody: EmailExistsRequestBody, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<EmailExistsResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.authEmailExists(emailExistsRequestBody, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['PublicEmailApi.authEmailExists']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 
+         * @param {RequestEmailCodeBody} requestEmailCodeBody 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async requestPublicEmailVerificationCode(requestEmailCodeBody: RequestEmailCodeBody, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RequestEmailCodeResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.requestPublicEmailVerificationCode(requestEmailCodeBody, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['PublicEmailApi.requestPublicEmailVerificationCode']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 
+         * @param {VerifyEmailCodeBody} verifyEmailCodeBody 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async verifyCode(verifyEmailCodeBody: VerifyEmailCodeBody, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VerifyEmailCodeResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.verifyCode(verifyEmailCodeBody, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['PublicEmailApi.verifyCode']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
@@ -35069,6 +35738,43 @@ export const WaitListStaffApiAxiosParamCreator = function (configuration?: Confi
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Obtenir la liste des joueurs dans la file d\'attente pour un event (staff only)
+         * @param {string} eventId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getEventWaitListPlayers: async (eventId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'eventId' is not null or undefined
+            assertParamExists('getEventWaitListPlayers', 'eventId', eventId)
+            const localVarPath = `/api/waitlist/event/{eventId}/players`
+                .replace(`{${"eventId"}}`, encodeURIComponent(String(eventId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication bearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -35235,6 +35941,18 @@ export const WaitListStaffApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['WaitListStaffApi.getEventWaitList']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Obtenir la liste des joueurs dans la file d\'attente pour un event (staff only)
+         * @param {string} eventId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getEventWaitListPlayers(eventId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<WaitListPlayersListResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getEventWaitListPlayers(eventId, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['WaitListStaffApi.getEventWaitListPlayers']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Forcer le traitement de la waitlist pour un booking (staff only)
          * @param {string} bookingId 
@@ -35308,6 +36026,15 @@ export const WaitListStaffApiFactory = function (configuration?: Configuration,
         getEventWaitList(requestParameters: WaitListStaffApiGetEventWaitListRequest, options?: RawAxiosRequestConfig): AxiosPromise<WaitListListResponse> {
             return localVarFp.getEventWaitList(requestParameters.eventId, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Obtenir la liste des joueurs dans la file d\'attente pour un event (staff only)
+         * @param {WaitListStaffApiGetEventWaitListPlayersRequest} requestParameters Request parameters.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getEventWaitListPlayers(requestParameters: WaitListStaffApiGetEventWaitListPlayersRequest, options?: RawAxiosRequestConfig): AxiosPromise<WaitListPlayersListResponse> {
+            return localVarFp.getEventWaitListPlayers(requestParameters.eventId, options).then((request) => request(axios, basePath));
+        },
         /**
          * Forcer le traitement de la waitlist pour un booking (staff only)
          * @param {WaitListStaffApiProcessBookingWaitListRequest} requestParameters Request parameters.
@@ -35380,6 +36107,20 @@ export interface WaitListStaffApiGetEventWaitListRequest {
     readonly eventId: string
 }
 
+/**
+ * Request parameters for getEventWaitListPlayers operation in WaitListStaffApi.
+ * @export
+ * @interface WaitListStaffApiGetEventWaitListPlayersRequest
+ */
+export interface WaitListStaffApiGetEventWaitListPlayersRequest {
+    /**
+     * 
+     * @type {string}
+     * @memberof WaitListStaffApiGetEventWaitListPlayers
+     */
+    readonly eventId: string
+}
+
 /**
  * Request parameters for processBookingWaitList operation in WaitListStaffApi.
  * @export
@@ -35462,6 +36203,17 @@ export class WaitListStaffApi extends BaseAPI {
         return WaitListStaffApiFp(this.configuration).getEventWaitList(requestParameters.eventId, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Obtenir la liste des joueurs dans la file d\'attente pour un event (staff only)
+     * @param {WaitListStaffApiGetEventWaitListPlayersRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof WaitListStaffApi
+     */
+    public getEventWaitListPlayers(requestParameters: WaitListStaffApiGetEventWaitListPlayersRequest, options?: RawAxiosRequestConfig) {
+        return WaitListStaffApiFp(this.configuration).getEventWaitListPlayers(requestParameters.eventId, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Forcer le traitement de la waitlist pour un booking (staff only)
      * @param {WaitListStaffApiProcessBookingWaitListRequest} requestParameters Request parameters.