@tennac-booking/sdk 1.0.192 → 1.0.194

package/api.ts

@@ -867,6 +867,30 @@ export interface BookingPopulated {
      * @memberof BookingPopulated
      */
     'cancellationReason'?: string;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof BookingPopulated
+     */
+    'isOpen': boolean;
+    /**
+     * 
+     * @type {string}
+     * @memberof BookingPopulated
+     */
+    'description'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof BookingPopulated
+     */
+    'minLevel'?: string;
+    /**
+     * 
+     * @type {number}
+     * @memberof BookingPopulated
+     */
+    'maxPlayers'?: number;
 }
 
 
@@ -6677,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
@@ -7398,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
@@ -14083,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
@@ -14102,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
@@ -28619,6 +28839,479 @@ export class ImagesApi extends BaseAPI {
 
 
 
+/**
+ * JobsApi - axios parameter creator
+ * @export
+ */
+export const JobsApiAxiosParamCreator = function (configuration?: 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: 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;
+            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: 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: 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;
+            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: 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: 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;
+            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: 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: 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,
+            };
+        },
+        /**
+         * 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: 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,
+            };
+        },
+        /**
+         * 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: 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
@@ -35045,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};
@@ -35211,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 
@@ -35284,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.
@@ -35356,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
@@ -35438,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.