@munchi_oy/core 1.9.73 → 1.9.75

package/generated/api.ts

@@ -3668,10 +3668,10 @@ export interface CreateManualSessionDto {
     'tipAmount'?: number;
     /**
      * 
-     * @type {InitiateVivaSessionDtoSplitContext}
+     * @type {CreateManualSessionDtoSplitContext}
      * @memberof CreateManualSessionDto
      */
-    'splitContext'?: InitiateVivaSessionDtoSplitContext;
+    'splitContext'?: CreateManualSessionDtoSplitContext;
     /**
      * Arbitrary client metadata persisted on the session (e.g. voucher code, gift card id, employee id, external reference, notes). Surfaced to reconciliation when building the order paymentEvent.
      * @type {object}
@@ -3930,6 +3930,33 @@ export interface CreateManualSessionDtoOrder {
 }
 
 
+/**
+ * Split context. Omit for a full-cart payment, or send { mode, partId|seatId } for a split. Must match the order\'s checkoutModel.
+ * @export
+ * @interface CreateManualSessionDtoSplitContext
+ */
+export interface CreateManualSessionDtoSplitContext {
+    /**
+     * 
+     * @type {CheckoutModelEnum}
+     * @memberof CreateManualSessionDtoSplitContext
+     */
+    'mode': CheckoutModelEnum;
+    /**
+     * Equal-split part id. Required when mode=EQUAL_SPLIT; ignored otherwise.
+     * @type {string}
+     * @memberof CreateManualSessionDtoSplitContext
+     */
+    'partId'?: string;
+    /**
+     * Item-split seat id. Required when mode=ITEM_SPLIT; ignored otherwise.
+     * @type {string}
+     * @memberof CreateManualSessionDtoSplitContext
+     */
+    'seatId'?: string;
+}
+
+
 /**
  * 
  * @export
@@ -6677,6 +6704,56 @@ export interface ImageBackgroundConfig {
 }
 
 
+/**
+ * 
+ * @export
+ * @interface InitiateNetsSessionDto
+ */
+export interface InitiateNetsSessionDto {
+    /**
+     * The internal business ID.
+     * @type {number}
+     * @memberof InitiateNetsSessionDto
+     */
+    'businessId': number;
+    /**
+     * The POS order ID this payment session is for.
+     * @type {string}
+     * @memberof InitiateNetsSessionDto
+     */
+    'orderId': string;
+    /**
+     * Amount to charge in smallest currency unit (cents).
+     * @type {number}
+     * @memberof InitiateNetsSessionDto
+     */
+    'amount': number;
+    /**
+     * 
+     * @type {CreateManualSessionDtoSplitContext}
+     * @memberof InitiateNetsSessionDto
+     */
+    'splitContext'?: CreateManualSessionDtoSplitContext;
+}
+/**
+ * 
+ * @export
+ * @interface InitiateNetsSessionResponseDto
+ */
+export interface InitiateNetsSessionResponseDto {
+    /**
+     * Opaque token returned to the client. Used by the client to poll/sync the session. Never sent to Nets.
+     * @type {string}
+     * @memberof InitiateNetsSessionResponseDto
+     */
+    'clientToken': string;
+    /**
+     * Internal session ID — the Nets ConnectCloud request id the webhook resolves against.
+     * @type {string}
+     * @memberof InitiateNetsSessionResponseDto
+     */
+    'sessionId': string;
+}
 /**
  * 
  * @export
@@ -6746,10 +6823,10 @@ export interface InitiateVivaA2aSessionDto {
     'showTransactionResult'?: boolean;
     /**
      * 
-     * @type {InitiateVivaSessionDtoSplitContext}
+     * @type {CreateManualSessionDtoSplitContext}
      * @memberof InitiateVivaA2aSessionDto
      */
-    'splitContext'?: InitiateVivaSessionDtoSplitContext;
+    'splitContext'?: CreateManualSessionDtoSplitContext;
 }
 
 
@@ -6890,38 +6967,11 @@ export interface InitiateVivaSessionDto {
     'amount': number;
     /**
      * 
-     * @type {InitiateVivaSessionDtoSplitContext}
+     * @type {CreateManualSessionDtoSplitContext}
      * @memberof InitiateVivaSessionDto
      */
-    'splitContext'?: InitiateVivaSessionDtoSplitContext;
-}
-/**
- * Split context. Omit for a full-cart payment, or send { mode, partId|seatId } for a split. Must match the order\'s checkoutModel.
- * @export
- * @interface InitiateVivaSessionDtoSplitContext
- */
-export interface InitiateVivaSessionDtoSplitContext {
-    /**
-     * 
-     * @type {CheckoutModelEnum}
-     * @memberof InitiateVivaSessionDtoSplitContext
-     */
-    'mode': CheckoutModelEnum;
-    /**
-     * Equal-split part id. Required when mode=EQUAL_SPLIT; ignored otherwise.
-     * @type {string}
-     * @memberof InitiateVivaSessionDtoSplitContext
-     */
-    'partId'?: string;
-    /**
-     * Item-split seat id. Required when mode=ITEM_SPLIT; ignored otherwise.
-     * @type {string}
-     * @memberof InitiateVivaSessionDtoSplitContext
-     */
-    'seatId'?: string;
+    'splitContext'?: CreateManualSessionDtoSplitContext;
 }
-
-
 /**
  * 
  * @export
@@ -7034,6 +7084,74 @@ export interface InitiateVivaSessionResponseDtoVivaIntent {
 }
 
 
+/**
+ * 
+ * @export
+ * @interface InitiateWorldlineSessionDto
+ */
+export interface InitiateWorldlineSessionDto {
+    /**
+     * The internal business ID.
+     * @type {number}
+     * @memberof InitiateWorldlineSessionDto
+     */
+    'businessId': number;
+    /**
+     * The POS order ID this payment session is for.
+     * @type {string}
+     * @memberof InitiateWorldlineSessionDto
+     */
+    'orderId': string;
+    /**
+     * Amount to charge in smallest currency unit (cents).
+     * @type {number}
+     * @memberof InitiateWorldlineSessionDto
+     */
+    'amount': number;
+    /**
+     * Optional tip amount in the smallest currency unit (cents).
+     * @type {number}
+     * @memberof InitiateWorldlineSessionDto
+     */
+    'tipAmount'?: number;
+    /**
+     * Whether the terminal should print the customer receipt.
+     * @type {boolean}
+     * @memberof InitiateWorldlineSessionDto
+     */
+    'showReceipt'?: boolean;
+    /**
+     * 
+     * @type {CreateManualSessionDtoSplitContext}
+     * @memberof InitiateWorldlineSessionDto
+     */
+    'splitContext'?: CreateManualSessionDtoSplitContext;
+}
+/**
+ * 
+ * @export
+ * @interface InitiateWorldlineSessionResponseDto
+ */
+export interface InitiateWorldlineSessionResponseDto {
+    /**
+     * Opaque token returned to the client. Used by the client to poll/sync the session via GET /payment-session/:clientToken.
+     * @type {string}
+     * @memberof InitiateWorldlineSessionResponseDto
+     */
+    'clientToken': string;
+    /**
+     * Internal session ID — equal to the Worldline operationId the webhook resolves against.
+     * @type {string}
+     * @memberof InitiateWorldlineSessionResponseDto
+     */
+    'sessionId': string;
+    /**
+     * The Worldline operationId. Same value as sessionId; exposed so the client can correlate terminal/Ably updates during the transition.
+     * @type {string}
+     * @memberof InitiateWorldlineSessionResponseDto
+     */
+    'operationId': string;
+}
 /**
  * 
  * @export
@@ -10147,6 +10265,65 @@ export interface NetsPaymentMessageDtoData {
      */
     'storeboxToken'?: string;
 }
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+
+export const NetsRevertMethod = {
+    Reversal: 'REVERSAL',
+    Refund: 'REFUND'
+} as const;
+
+export type NetsRevertMethod = typeof NetsRevertMethod[keyof typeof NetsRevertMethod];
+
+
+/**
+ * 
+ * @export
+ * @interface NetsRevertResponseDto
+ */
+export interface NetsRevertResponseDto {
+    /**
+     * 
+     * @type {NetsRevertMethod}
+     * @memberof NetsRevertResponseDto
+     */
+    'method': NetsRevertMethod;
+    /**
+     * True when the customer must tap their card to complete (REFUND); false for a REVERSAL, which settles without a tap.
+     * @type {boolean}
+     * @memberof NetsRevertResponseDto
+     */
+    'requiresCardTap': boolean;
+    /**
+     * Opaque token to poll GET /payment-session/:clientToken for the final outcome.
+     * @type {string}
+     * @memberof NetsRevertResponseDto
+     */
+    'clientToken': string;
+    /**
+     * Internal session id — the Nets connectcloud-request-id the webhook resolves against.
+     * @type {string}
+     * @memberof NetsRevertResponseDto
+     */
+    'sessionId': string;
+    /**
+     * Amount being reverted, in the smallest currency unit (cents).
+     * @type {number}
+     * @memberof NetsRevertResponseDto
+     */
+    'amount': number;
+    /**
+     * 
+     * @type {PaymentSessionStatus}
+     * @memberof NetsRevertResponseDto
+     */
+    'status': PaymentSessionStatus;
+}
+
+
 /**
  * 
  * @export
@@ -14015,6 +14192,19 @@ export interface PollVivaSessionDto {
      */
     'sessionId': string;
 }
+/**
+ * 
+ * @export
+ * @interface PollWorldlineSessionDto
+ */
+export interface PollWorldlineSessionDto {
+    /**
+     * The Worldline session id (= operationId) to poll.
+     * @type {string}
+     * @memberof PollWorldlineSessionDto
+     */
+    'sessionId': string;
+}
 /**
  * 
  * @export
@@ -25256,6 +25446,12 @@ export interface WorldlineRefundRequestDataDto {
      * @memberof WorldlineRefundRequestDataDto
      */
     'amounts': WorldlineRefundRequestDataDtoAmounts;
+    /**
+     * Receipt number of the original payment (from PaymentCompleted.receiptNumber). Required for a REVERSAL — it identifies which transaction on the terminal to void. Omit for a ReturnOfGoods refund.
+     * @type {string}
+     * @memberof WorldlineRefundRequestDataDto
+     */
+    'receiptNumber'?: string;
     /**
      * Cashier identifier
      * @type {string}
@@ -25312,6 +25508,65 @@ export interface WorldlineRefundRequestDataDtoAmounts {
      */
     'tip'?: number;
 }
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+
+export const WorldlineRevertMethod = {
+    Reversal: 'REVERSAL',
+    Refund: 'REFUND'
+} as const;
+
+export type WorldlineRevertMethod = typeof WorldlineRevertMethod[keyof typeof WorldlineRevertMethod];
+
+
+/**
+ * 
+ * @export
+ * @interface WorldlineRevertResponseDto
+ */
+export interface WorldlineRevertResponseDto {
+    /**
+     * 
+     * @type {WorldlineRevertMethod}
+     * @memberof WorldlineRevertResponseDto
+     */
+    'method': WorldlineRevertMethod;
+    /**
+     * True when the customer must tap their card to complete (REFUND); false for a REVERSAL, which settles without a tap.
+     * @type {boolean}
+     * @memberof WorldlineRevertResponseDto
+     */
+    'requiresCardTap': boolean;
+    /**
+     * Opaque token to poll GET /payment-session/:clientToken for the final outcome.
+     * @type {string}
+     * @memberof WorldlineRevertResponseDto
+     */
+    'clientToken': string;
+    /**
+     * Internal session id — the Worldline operationId the webhook resolves against.
+     * @type {string}
+     * @memberof WorldlineRevertResponseDto
+     */
+    'sessionId': string;
+    /**
+     * Amount being reverted, in the smallest currency unit (cents).
+     * @type {number}
+     * @memberof WorldlineRevertResponseDto
+     */
+    'amount': number;
+    /**
+     * 
+     * @type {PaymentSessionStatus}
+     * @memberof WorldlineRevertResponseDto
+     */
+    'status': PaymentSessionStatus;
+}
+
+
 
 /**
  * AblyApi - axios parameter creator
@@ -40769,15 +41024,15 @@ export class PaymentMethodsApi extends BaseAPI implements PaymentMethodsApiInter
 export const PaymentSessionApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Arms cancelRequestedAt + aborts the Viva terminal session. Does not flip status — the webhook/sweep resolves the real outcome, and a late success is auto-voided. Viva card only.
-         * @summary Cancel an in-flight Viva payment session
+         * Arms cancelRequestedAt + aborts at the gateway (Viva session abort / Nets terminal cancelAction, dispatched on the session\'s provider). Does not flip status — the webhook/sweep resolves the real outcome; a late success parks at VOID_PENDING with a dev alert. Card sessions only.
+         * @summary Cancel an in-flight card payment session (Viva or Nets)
          * @param {string} clientToken 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        cancelVivaSession: async (clientToken: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+        cancelSession: async (clientToken: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'clientToken' is not null or undefined
-            assertParamExists('cancelVivaSession', 'clientToken', clientToken)
+            assertParamExists('cancelSession', 'clientToken', clientToken)
             const localVarPath = `/api/v1/payment-session/{clientToken}/cancel`
                 .replace(`{${"clientToken"}}`, encodeURIComponent(String(clientToken)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -40837,53 +41092,94 @@ export const PaymentSessionApiAxiosParamCreator = function (configuration?: Conf
             };
         },
         /**
-         * Builds the Viva app-to-app launch params (same as the legacy viva/a2a/create-payment) and persists a PaymentSession keyed by the Viva clientTransactionId, so the webhook + reconciliation own the order mutation. Returns the launch params plus a clientToken to poll the session.
-         * @summary Initiate a Viva app-to-app payment session
-         * @param {InitiateVivaA2aSessionDto} initiateVivaA2aSessionDto 
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        initiateVivaA2aSession: async (initiateVivaA2aSessionDto: InitiateVivaA2aSessionDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'initiateVivaA2aSessionDto' is not null or undefined
-            assertParamExists('initiateVivaA2aSession', 'initiateVivaA2aSessionDto', initiateVivaA2aSessionDto)
-            const localVarPath = `/api/v1/payment-session/viva/a2a`;
-            // 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(initiateVivaA2aSessionDto, localVarRequestOptions, configuration)
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Creates a PaymentSession row, calls Viva createTransaction, returns a client-facing token and the Viva payment intent. Idempotent via X-Idempotency-Key header.
-         * @summary Initiate a Viva payment session
-         * @param {InitiateVivaSessionDto} initiateVivaSessionDto 
+         * Creates a PaymentSession row, pushes the transaction to the station\'s Nets terminal (async — the result arrives via the Nets webhook), returns a client-facing token to poll. Idempotent via X-Idempotency-Key header.
+         * @summary Initiate a Nets terminal payment session
+         * @param {InitiateNetsSessionDto} initiateNetsSessionDto 
          * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        initiateVivaSession: async (initiateVivaSessionDto: InitiateVivaSessionDto, xIdempotencyKey?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'initiateVivaSessionDto' is not null or undefined
-            assertParamExists('initiateVivaSession', 'initiateVivaSessionDto', initiateVivaSessionDto)
-            const localVarPath = `/api/v1/payment-session/viva/initiate`;
+        initiateNetsSession: async (initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'initiateNetsSessionDto' is not null or undefined
+            assertParamExists('initiateNetsSession', 'initiateNetsSessionDto', initiateNetsSessionDto)
+            const localVarPath = `/api/v1/payment-session/nets/initiate`;
+            // 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;
+
+            if (xIdempotencyKey != null) {
+                localVarHeaderParameter['X-Idempotency-Key'] = String(xIdempotencyKey);
+            }
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(initiateNetsSessionDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Builds the Viva app-to-app launch params (same as the legacy viva/a2a/create-payment) and persists a PaymentSession keyed by the Viva clientTransactionId, so the webhook + reconciliation own the order mutation. Returns the launch params plus a clientToken to poll the session.
+         * @summary Initiate a Viva app-to-app payment session
+         * @param {InitiateVivaA2aSessionDto} initiateVivaA2aSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        initiateVivaA2aSession: async (initiateVivaA2aSessionDto: InitiateVivaA2aSessionDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'initiateVivaA2aSessionDto' is not null or undefined
+            assertParamExists('initiateVivaA2aSession', 'initiateVivaA2aSessionDto', initiateVivaA2aSessionDto)
+            const localVarPath = `/api/v1/payment-session/viva/a2a`;
+            // 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(initiateVivaA2aSessionDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Creates a PaymentSession row, calls Viva createTransaction, returns a client-facing token and the Viva payment intent. Idempotent via X-Idempotency-Key header.
+         * @summary Initiate a Viva payment session
+         * @param {InitiateVivaSessionDto} initiateVivaSessionDto 
+         * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        initiateVivaSession: async (initiateVivaSessionDto: InitiateVivaSessionDto, xIdempotencyKey?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'initiateVivaSessionDto' is not null or undefined
+            assertParamExists('initiateVivaSession', 'initiateVivaSessionDto', initiateVivaSessionDto)
+            const localVarPath = `/api/v1/payment-session/viva/initiate`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -40913,6 +41209,47 @@ export const PaymentSessionApiAxiosParamCreator = function (configuration?: Conf
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Creates a PaymentSession row and pushes the transaction to the station\'s Worldline terminal via the Worldline microservice (async — the result arrives via the Worldline webhook). Returns a client-facing token to poll. The backend owns the order mutation (webhook → reconciliation), replacing the legacy FE-writes-from-Ably flow. Idempotent via X-Idempotency-Key header.
+         * @summary Initiate a Worldline terminal payment session
+         * @param {InitiateWorldlineSessionDto} initiateWorldlineSessionDto 
+         * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        initiateWorldlineSession: async (initiateWorldlineSessionDto: InitiateWorldlineSessionDto, xIdempotencyKey?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'initiateWorldlineSessionDto' is not null or undefined
+            assertParamExists('initiateWorldlineSession', 'initiateWorldlineSessionDto', initiateWorldlineSessionDto)
+            const localVarPath = `/api/v1/payment-session/worldline/initiate`;
+            // 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;
+
+            if (xIdempotencyKey != null) {
+                localVarHeaderParameter['X-Idempotency-Key'] = String(xIdempotencyKey);
+            }
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(initiateWorldlineSessionDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Called by a Cloud Task (not the client). Holds the request open and long-polls Viva by sessionId for up to ~45s. As soon as the transaction is terminal it updates the session status and, on success, triggers order reconciliation — guarded by a CAS claim (tryClose) so a late webhook never double-writes the paymentEvent — so the order closes even if the webhook never arrives.
          * @summary Internal: long-poll Viva for a stuck payment session (Cloud Task callback)
@@ -40949,6 +41286,42 @@ export const PaymentSessionApiAxiosParamCreator = function (configuration?: Conf
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Called by a Cloud Task (not the client). Polls the Worldline microservice by operationId for up to ~45s; as soon as the operation is terminal it finalizes the PaymentSession through the same sweep the webhook uses (CAS-guarded, so a webhook + poll never double-write). Ensures the session resolves even if the webhook is slow or never arrives.
+         * @summary Internal: poll Worldline for a stuck payment session (Cloud Task callback)
+         * @param {PollWorldlineSessionDto} pollWorldlineSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        pollWorldlineSession: async (pollWorldlineSessionDto: PollWorldlineSessionDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'pollWorldlineSessionDto' is not null or undefined
+            assertParamExists('pollWorldlineSession', 'pollWorldlineSessionDto', pollWorldlineSessionDto)
+            const localVarPath = `/api/v1/payment-session/worldline/poll`;
+            // 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(pollWorldlineSessionDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Records a non-gateway payment (cash / voucher / CardManual / gift card / …) through PaymentSession so every device sees it. Card paymethods (Card/Debit/Credit/Edenred) use a gateway initiate. Resolves to SUCCESS immediately; reconciliation writes the paymentEvent.
          * @summary Record a manual payment session
@@ -40985,6 +41358,42 @@ export const PaymentSessionApiAxiosParamCreator = function (configuration?: Conf
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Starts a terminal-present ReturnOfGoods on the station\'s Nets terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session (status INITIATED) — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+         * @summary Refund a settled Nets payment session (gateway only, async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refundNetsSession: async (reverseSessionDto: ReverseSessionDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'reverseSessionDto' is not null or undefined
+            assertParamExists('refundNetsSession', 'reverseSessionDto', reverseSessionDto)
+            const localVarPath = `/api/v1/payment-session/nets/refund`;
+            // 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(reverseSessionDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Refunds a Viva card payment at the gateway by its sessionId, optionally a partial `amount` (item / cluster refund). Validates the remaining refundable balance and supports multiple partial refunds. Does NOT write a reversal paymentEvent to the order — order-side accounting is handled by the refund plan. For a full reversal that writes the order paymentEvent, use /revert.
          * @summary Refund a settled Viva payment session (gateway only)
@@ -41009,6 +41418,78 @@ export const PaymentSessionApiAxiosParamCreator = function (configuration?: Conf
 
 
     
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(reverseSessionDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Starts a terminal-present ReturnOfGoods on the station\'s Worldline terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+         * @summary Refund a settled Worldline payment session (gateway only, async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refundWorldlineSession: async (reverseSessionDto: ReverseSessionDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'reverseSessionDto' is not null or undefined
+            assertParamExists('refundWorldlineSession', 'reverseSessionDto', reverseSessionDto)
+            const localVarPath = `/api/v1/payment-session/worldline/refund`;
+            // 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(reverseSessionDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Starts a terminal-present ReturnOfGoods for the full remaining amount AND writes a reversal paymentEvent to the order once the refund settles (via reconciliation). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED.
+         * @summary Revert (fully reverse) a settled Nets payment session (async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        revertNetsSession: async (reverseSessionDto: ReverseSessionDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'reverseSessionDto' is not null or undefined
+            assertParamExists('revertNetsSession', 'reverseSessionDto', reverseSessionDto)
+            const localVarPath = `/api/v1/payment-session/nets/revert`;
+            // 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);
@@ -41045,6 +41526,42 @@ export const PaymentSessionApiAxiosParamCreator = function (configuration?: Conf
 
 
     
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(reverseSessionDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Starts a terminal reversal for the full remaining amount AND writes a reversal paymentEvent to the order once the reversal settles (via reconciliation). Returns a PENDING refund session — poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. A reversal typically settles without a card tap; if the payment is already batched/settled the reversal fails and the client should fall back to /worldline/refund.
+         * @summary Revert (fully reverse) a settled Worldline payment session (async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        revertWorldlineSession: async (reverseSessionDto: ReverseSessionDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'reverseSessionDto' is not null or undefined
+            assertParamExists('revertWorldlineSession', 'reverseSessionDto', reverseSessionDto)
+            const localVarPath = `/api/v1/payment-session/worldline/revert`;
+            // 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);
@@ -41104,14 +41621,14 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = PaymentSessionApiAxiosParamCreator(configuration)
     return {
         /**
-         * Arms cancelRequestedAt + aborts the Viva terminal session. Does not flip status — the webhook/sweep resolves the real outcome, and a late success is auto-voided. Viva card only.
-         * @summary Cancel an in-flight Viva payment session
+         * Arms cancelRequestedAt + aborts at the gateway (Viva session abort / Nets terminal cancelAction, dispatched on the session\'s provider). Does not flip status — the webhook/sweep resolves the real outcome; a late success parks at VOID_PENDING with a dev alert. Card sessions only.
+         * @summary Cancel an in-flight card payment session (Viva or Nets)
          * @param {string} clientToken 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async cancelVivaSession(clientToken: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PaymentSessionViewDto>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.cancelVivaSession(clientToken, options);
+        async cancelSession(clientToken: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PaymentSessionViewDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.cancelSession(clientToken, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
         /**
@@ -41125,6 +41642,18 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.getPaymentSession(clientToken, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Creates a PaymentSession row, pushes the transaction to the station\'s Nets terminal (async — the result arrives via the Nets webhook), returns a client-facing token to poll. Idempotent via X-Idempotency-Key header.
+         * @summary Initiate a Nets terminal payment session
+         * @param {InitiateNetsSessionDto} initiateNetsSessionDto 
+         * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InitiateNetsSessionResponseDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.initiateNetsSession(initiateNetsSessionDto, xIdempotencyKey, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Builds the Viva app-to-app launch params (same as the legacy viva/a2a/create-payment) and persists a PaymentSession keyed by the Viva clientTransactionId, so the webhook + reconciliation own the order mutation. Returns the launch params plus a clientToken to poll the session.
          * @summary Initiate a Viva app-to-app payment session
@@ -41148,6 +41677,18 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.initiateVivaSession(initiateVivaSessionDto, xIdempotencyKey, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Creates a PaymentSession row and pushes the transaction to the station\'s Worldline terminal via the Worldline microservice (async — the result arrives via the Worldline webhook). Returns a client-facing token to poll. The backend owns the order mutation (webhook → reconciliation), replacing the legacy FE-writes-from-Ably flow. Idempotent via X-Idempotency-Key header.
+         * @summary Initiate a Worldline terminal payment session
+         * @param {InitiateWorldlineSessionDto} initiateWorldlineSessionDto 
+         * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async initiateWorldlineSession(initiateWorldlineSessionDto: InitiateWorldlineSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InitiateWorldlineSessionResponseDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.initiateWorldlineSession(initiateWorldlineSessionDto, xIdempotencyKey, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Called by a Cloud Task (not the client). Holds the request open and long-polls Viva by sessionId for up to ~45s. As soon as the transaction is terminal it updates the session status and, on success, triggers order reconciliation — guarded by a CAS claim (tryClose) so a late webhook never double-writes the paymentEvent — so the order closes even if the webhook never arrives.
          * @summary Internal: long-poll Viva for a stuck payment session (Cloud Task callback)
@@ -41159,6 +41700,17 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.pollVivaSession(pollVivaSessionDto, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Called by a Cloud Task (not the client). Polls the Worldline microservice by operationId for up to ~45s; as soon as the operation is terminal it finalizes the PaymentSession through the same sweep the webhook uses (CAS-guarded, so a webhook + poll never double-write). Ensures the session resolves even if the webhook is slow or never arrives.
+         * @summary Internal: poll Worldline for a stuck payment session (Cloud Task callback)
+         * @param {PollWorldlineSessionDto} pollWorldlineSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async pollWorldlineSession(pollWorldlineSessionDto: PollWorldlineSessionDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.pollWorldlineSession(pollWorldlineSessionDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Records a non-gateway payment (cash / voucher / CardManual / gift card / …) through PaymentSession so every device sees it. Card paymethods (Card/Debit/Credit/Edenred) use a gateway initiate. Resolves to SUCCESS immediately; reconciliation writes the paymentEvent.
          * @summary Record a manual payment session
@@ -41170,6 +41722,17 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.recordManualPayment(createManualSessionDto, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Starts a terminal-present ReturnOfGoods on the station\'s Nets terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session (status INITIATED) — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+         * @summary Refund a settled Nets payment session (gateway only, async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async refundNetsSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PaymentSessionViewDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.refundNetsSession(reverseSessionDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Refunds a Viva card payment at the gateway by its sessionId, optionally a partial `amount` (item / cluster refund). Validates the remaining refundable balance and supports multiple partial refunds. Does NOT write a reversal paymentEvent to the order — order-side accounting is handled by the refund plan. For a full reversal that writes the order paymentEvent, use /revert.
          * @summary Refund a settled Viva payment session (gateway only)
@@ -41181,6 +41744,28 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.refundVivaSession(reverseSessionDto, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Starts a terminal-present ReturnOfGoods on the station\'s Worldline terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+         * @summary Refund a settled Worldline payment session (gateway only, async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async refundWorldlineSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PaymentSessionViewDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.refundWorldlineSession(reverseSessionDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Starts a terminal-present ReturnOfGoods for the full remaining amount AND writes a reversal paymentEvent to the order once the refund settles (via reconciliation). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED.
+         * @summary Revert (fully reverse) a settled Nets payment session (async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async revertNetsSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<NetsRevertResponseDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.revertNetsSession(reverseSessionDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Fully reverses a completed Viva card payment (SUCCESS / CLOSED) by its sessionId: refunds the full amount at the gateway AND writes a reversal paymentEvent to the order via the settlement engine. Idempotent: re-calling a reverted session is a no-op.
          * @summary Revert (fully reverse) a settled Viva payment session
@@ -41192,6 +41777,17 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.revertVivaSession(reverseSessionDto, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Starts a terminal reversal for the full remaining amount AND writes a reversal paymentEvent to the order once the reversal settles (via reconciliation). Returns a PENDING refund session — poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. A reversal typically settles without a card tap; if the payment is already batched/settled the reversal fails and the client should fall back to /worldline/refund.
+         * @summary Revert (fully reverse) a settled Worldline payment session (async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async revertWorldlineSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<WorldlineRevertResponseDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.revertWorldlineSession(reverseSessionDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Reverses a manually-recorded payment (cash / voucher / CardManual / gift card / …) by its sessionId (the order paymentEvent referenceId). Not for card paymethods (Card/Debit/Credit/Edenred) — those use cancel/refund. Idempotent: re-calling a voided session is a no-op.
          * @summary Void a manual payment session
@@ -41214,14 +41810,14 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
     const localVarFp = PaymentSessionApiFp(configuration)
     return {
         /**
-         * Arms cancelRequestedAt + aborts the Viva terminal session. Does not flip status — the webhook/sweep resolves the real outcome, and a late success is auto-voided. Viva card only.
-         * @summary Cancel an in-flight Viva payment session
+         * Arms cancelRequestedAt + aborts at the gateway (Viva session abort / Nets terminal cancelAction, dispatched on the session\'s provider). Does not flip status — the webhook/sweep resolves the real outcome; a late success parks at VOID_PENDING with a dev alert. Card sessions only.
+         * @summary Cancel an in-flight card payment session (Viva or Nets)
          * @param {string} clientToken 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        cancelVivaSession(clientToken: string, options?: any): AxiosPromise<PaymentSessionViewDto> {
-            return localVarFp.cancelVivaSession(clientToken, options).then((request) => request(axios, basePath));
+        cancelSession(clientToken: string, options?: any): AxiosPromise<PaymentSessionViewDto> {
+            return localVarFp.cancelSession(clientToken, options).then((request) => request(axios, basePath));
         },
         /**
          * Reads PaymentSession from Postgres. Use this to poll session lifecycle without hitting the Viva API.
@@ -41233,6 +41829,17 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         getPaymentSession(clientToken: string, options?: any): AxiosPromise<PaymentSessionViewDto> {
             return localVarFp.getPaymentSession(clientToken, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Creates a PaymentSession row, pushes the transaction to the station\'s Nets terminal (async — the result arrives via the Nets webhook), returns a client-facing token to poll. Idempotent via X-Idempotency-Key header.
+         * @summary Initiate a Nets terminal payment session
+         * @param {InitiateNetsSessionDto} initiateNetsSessionDto 
+         * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: any): AxiosPromise<InitiateNetsSessionResponseDto> {
+            return localVarFp.initiateNetsSession(initiateNetsSessionDto, xIdempotencyKey, options).then((request) => request(axios, basePath));
+        },
         /**
          * Builds the Viva app-to-app launch params (same as the legacy viva/a2a/create-payment) and persists a PaymentSession keyed by the Viva clientTransactionId, so the webhook + reconciliation own the order mutation. Returns the launch params plus a clientToken to poll the session.
          * @summary Initiate a Viva app-to-app payment session
@@ -41254,6 +41861,17 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         initiateVivaSession(initiateVivaSessionDto: InitiateVivaSessionDto, xIdempotencyKey?: string, options?: any): AxiosPromise<InitiateVivaSessionResponseDto> {
             return localVarFp.initiateVivaSession(initiateVivaSessionDto, xIdempotencyKey, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Creates a PaymentSession row and pushes the transaction to the station\'s Worldline terminal via the Worldline microservice (async — the result arrives via the Worldline webhook). Returns a client-facing token to poll. The backend owns the order mutation (webhook → reconciliation), replacing the legacy FE-writes-from-Ably flow. Idempotent via X-Idempotency-Key header.
+         * @summary Initiate a Worldline terminal payment session
+         * @param {InitiateWorldlineSessionDto} initiateWorldlineSessionDto 
+         * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        initiateWorldlineSession(initiateWorldlineSessionDto: InitiateWorldlineSessionDto, xIdempotencyKey?: string, options?: any): AxiosPromise<InitiateWorldlineSessionResponseDto> {
+            return localVarFp.initiateWorldlineSession(initiateWorldlineSessionDto, xIdempotencyKey, options).then((request) => request(axios, basePath));
+        },
         /**
          * Called by a Cloud Task (not the client). Holds the request open and long-polls Viva by sessionId for up to ~45s. As soon as the transaction is terminal it updates the session status and, on success, triggers order reconciliation — guarded by a CAS claim (tryClose) so a late webhook never double-writes the paymentEvent — so the order closes even if the webhook never arrives.
          * @summary Internal: long-poll Viva for a stuck payment session (Cloud Task callback)
@@ -41264,6 +41882,16 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         pollVivaSession(pollVivaSessionDto: PollVivaSessionDto, options?: any): AxiosPromise<void> {
             return localVarFp.pollVivaSession(pollVivaSessionDto, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Called by a Cloud Task (not the client). Polls the Worldline microservice by operationId for up to ~45s; as soon as the operation is terminal it finalizes the PaymentSession through the same sweep the webhook uses (CAS-guarded, so a webhook + poll never double-write). Ensures the session resolves even if the webhook is slow or never arrives.
+         * @summary Internal: poll Worldline for a stuck payment session (Cloud Task callback)
+         * @param {PollWorldlineSessionDto} pollWorldlineSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        pollWorldlineSession(pollWorldlineSessionDto: PollWorldlineSessionDto, options?: any): AxiosPromise<void> {
+            return localVarFp.pollWorldlineSession(pollWorldlineSessionDto, options).then((request) => request(axios, basePath));
+        },
         /**
          * Records a non-gateway payment (cash / voucher / CardManual / gift card / …) through PaymentSession so every device sees it. Card paymethods (Card/Debit/Credit/Edenred) use a gateway initiate. Resolves to SUCCESS immediately; reconciliation writes the paymentEvent.
          * @summary Record a manual payment session
@@ -41274,6 +41902,16 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         recordManualPayment(createManualSessionDto: CreateManualSessionDto, options?: any): AxiosPromise<RecordManualPaymentResultDto> {
             return localVarFp.recordManualPayment(createManualSessionDto, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Starts a terminal-present ReturnOfGoods on the station\'s Nets terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session (status INITIATED) — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+         * @summary Refund a settled Nets payment session (gateway only, async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refundNetsSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<PaymentSessionViewDto> {
+            return localVarFp.refundNetsSession(reverseSessionDto, options).then((request) => request(axios, basePath));
+        },
         /**
          * Refunds a Viva card payment at the gateway by its sessionId, optionally a partial `amount` (item / cluster refund). Validates the remaining refundable balance and supports multiple partial refunds. Does NOT write a reversal paymentEvent to the order — order-side accounting is handled by the refund plan. For a full reversal that writes the order paymentEvent, use /revert.
          * @summary Refund a settled Viva payment session (gateway only)
@@ -41284,6 +41922,26 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         refundVivaSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<PaymentSessionViewDto> {
             return localVarFp.refundVivaSession(reverseSessionDto, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Starts a terminal-present ReturnOfGoods on the station\'s Worldline terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+         * @summary Refund a settled Worldline payment session (gateway only, async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refundWorldlineSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<PaymentSessionViewDto> {
+            return localVarFp.refundWorldlineSession(reverseSessionDto, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Starts a terminal-present ReturnOfGoods for the full remaining amount AND writes a reversal paymentEvent to the order once the refund settles (via reconciliation). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED.
+         * @summary Revert (fully reverse) a settled Nets payment session (async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        revertNetsSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<NetsRevertResponseDto> {
+            return localVarFp.revertNetsSession(reverseSessionDto, options).then((request) => request(axios, basePath));
+        },
         /**
          * Fully reverses a completed Viva card payment (SUCCESS / CLOSED) by its sessionId: refunds the full amount at the gateway AND writes a reversal paymentEvent to the order via the settlement engine. Idempotent: re-calling a reverted session is a no-op.
          * @summary Revert (fully reverse) a settled Viva payment session
@@ -41294,6 +41952,16 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         revertVivaSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<PaymentSessionViewDto> {
             return localVarFp.revertVivaSession(reverseSessionDto, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Starts a terminal reversal for the full remaining amount AND writes a reversal paymentEvent to the order once the reversal settles (via reconciliation). Returns a PENDING refund session — poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. A reversal typically settles without a card tap; if the payment is already batched/settled the reversal fails and the client should fall back to /worldline/refund.
+         * @summary Revert (fully reverse) a settled Worldline payment session (async)
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        revertWorldlineSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<WorldlineRevertResponseDto> {
+            return localVarFp.revertWorldlineSession(reverseSessionDto, options).then((request) => request(axios, basePath));
+        },
         /**
          * Reverses a manually-recorded payment (cash / voucher / CardManual / gift card / …) by its sessionId (the order paymentEvent referenceId). Not for card paymethods (Card/Debit/Credit/Edenred) — those use cancel/refund. Idempotent: re-calling a voided session is a no-op.
          * @summary Void a manual payment session
@@ -41314,14 +41982,14 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
  */
 export interface PaymentSessionApiInterface {
     /**
-     * Arms cancelRequestedAt + aborts the Viva terminal session. Does not flip status — the webhook/sweep resolves the real outcome, and a late success is auto-voided. Viva card only.
-     * @summary Cancel an in-flight Viva payment session
+     * Arms cancelRequestedAt + aborts at the gateway (Viva session abort / Nets terminal cancelAction, dispatched on the session\'s provider). Does not flip status — the webhook/sweep resolves the real outcome; a late success parks at VOID_PENDING with a dev alert. Card sessions only.
+     * @summary Cancel an in-flight card payment session (Viva or Nets)
      * @param {string} clientToken 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof PaymentSessionApiInterface
      */
-    cancelVivaSession(clientToken: string, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
+    cancelSession(clientToken: string, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
 
     /**
      * Reads PaymentSession from Postgres. Use this to poll session lifecycle without hitting the Viva API.
@@ -41333,6 +42001,17 @@ export interface PaymentSessionApiInterface {
      */
     getPaymentSession(clientToken: string, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
 
+    /**
+     * Creates a PaymentSession row, pushes the transaction to the station\'s Nets terminal (async — the result arrives via the Nets webhook), returns a client-facing token to poll. Idempotent via X-Idempotency-Key header.
+     * @summary Initiate a Nets terminal payment session
+     * @param {InitiateNetsSessionDto} initiateNetsSessionDto 
+     * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): AxiosPromise<InitiateNetsSessionResponseDto>;
+
     /**
      * Builds the Viva app-to-app launch params (same as the legacy viva/a2a/create-payment) and persists a PaymentSession keyed by the Viva clientTransactionId, so the webhook + reconciliation own the order mutation. Returns the launch params plus a clientToken to poll the session.
      * @summary Initiate a Viva app-to-app payment session
@@ -41354,6 +42033,17 @@ export interface PaymentSessionApiInterface {
      */
     initiateVivaSession(initiateVivaSessionDto: InitiateVivaSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): AxiosPromise<InitiateVivaSessionResponseDto>;
 
+    /**
+     * Creates a PaymentSession row and pushes the transaction to the station\'s Worldline terminal via the Worldline microservice (async — the result arrives via the Worldline webhook). Returns a client-facing token to poll. The backend owns the order mutation (webhook → reconciliation), replacing the legacy FE-writes-from-Ably flow. Idempotent via X-Idempotency-Key header.
+     * @summary Initiate a Worldline terminal payment session
+     * @param {InitiateWorldlineSessionDto} initiateWorldlineSessionDto 
+     * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    initiateWorldlineSession(initiateWorldlineSessionDto: InitiateWorldlineSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): AxiosPromise<InitiateWorldlineSessionResponseDto>;
+
     /**
      * Called by a Cloud Task (not the client). Holds the request open and long-polls Viva by sessionId for up to ~45s. As soon as the transaction is terminal it updates the session status and, on success, triggers order reconciliation — guarded by a CAS claim (tryClose) so a late webhook never double-writes the paymentEvent — so the order closes even if the webhook never arrives.
      * @summary Internal: long-poll Viva for a stuck payment session (Cloud Task callback)
@@ -41364,6 +42054,16 @@ export interface PaymentSessionApiInterface {
      */
     pollVivaSession(pollVivaSessionDto: PollVivaSessionDto, options?: AxiosRequestConfig): AxiosPromise<void>;
 
+    /**
+     * Called by a Cloud Task (not the client). Polls the Worldline microservice by operationId for up to ~45s; as soon as the operation is terminal it finalizes the PaymentSession through the same sweep the webhook uses (CAS-guarded, so a webhook + poll never double-write). Ensures the session resolves even if the webhook is slow or never arrives.
+     * @summary Internal: poll Worldline for a stuck payment session (Cloud Task callback)
+     * @param {PollWorldlineSessionDto} pollWorldlineSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    pollWorldlineSession(pollWorldlineSessionDto: PollWorldlineSessionDto, options?: AxiosRequestConfig): AxiosPromise<void>;
+
     /**
      * Records a non-gateway payment (cash / voucher / CardManual / gift card / …) through PaymentSession so every device sees it. Card paymethods (Card/Debit/Credit/Edenred) use a gateway initiate. Resolves to SUCCESS immediately; reconciliation writes the paymentEvent.
      * @summary Record a manual payment session
@@ -41374,6 +42074,16 @@ export interface PaymentSessionApiInterface {
      */
     recordManualPayment(createManualSessionDto: CreateManualSessionDto, options?: AxiosRequestConfig): AxiosPromise<RecordManualPaymentResultDto>;
 
+    /**
+     * Starts a terminal-present ReturnOfGoods on the station\'s Nets terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session (status INITIATED) — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+     * @summary Refund a settled Nets payment session (gateway only, async)
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    refundNetsSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
+
     /**
      * Refunds a Viva card payment at the gateway by its sessionId, optionally a partial `amount` (item / cluster refund). Validates the remaining refundable balance and supports multiple partial refunds. Does NOT write a reversal paymentEvent to the order — order-side accounting is handled by the refund plan. For a full reversal that writes the order paymentEvent, use /revert.
      * @summary Refund a settled Viva payment session (gateway only)
@@ -41384,6 +42094,26 @@ export interface PaymentSessionApiInterface {
      */
     refundVivaSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
 
+    /**
+     * Starts a terminal-present ReturnOfGoods on the station\'s Worldline terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+     * @summary Refund a settled Worldline payment session (gateway only, async)
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    refundWorldlineSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
+
+    /**
+     * Starts a terminal-present ReturnOfGoods for the full remaining amount AND writes a reversal paymentEvent to the order once the refund settles (via reconciliation). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED.
+     * @summary Revert (fully reverse) a settled Nets payment session (async)
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    revertNetsSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<NetsRevertResponseDto>;
+
     /**
      * Fully reverses a completed Viva card payment (SUCCESS / CLOSED) by its sessionId: refunds the full amount at the gateway AND writes a reversal paymentEvent to the order via the settlement engine. Idempotent: re-calling a reverted session is a no-op.
      * @summary Revert (fully reverse) a settled Viva payment session
@@ -41394,6 +42124,16 @@ export interface PaymentSessionApiInterface {
      */
     revertVivaSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
 
+    /**
+     * Starts a terminal reversal for the full remaining amount AND writes a reversal paymentEvent to the order once the reversal settles (via reconciliation). Returns a PENDING refund session — poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. A reversal typically settles without a card tap; if the payment is already batched/settled the reversal fails and the client should fall back to /worldline/refund.
+     * @summary Revert (fully reverse) a settled Worldline payment session (async)
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    revertWorldlineSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<WorldlineRevertResponseDto>;
+
     /**
      * Reverses a manually-recorded payment (cash / voucher / CardManual / gift card / …) by its sessionId (the order paymentEvent referenceId). Not for card paymethods (Card/Debit/Credit/Edenred) — those use cancel/refund. Idempotent: re-calling a voided session is a no-op.
      * @summary Void a manual payment session
@@ -41414,15 +42154,15 @@ export interface PaymentSessionApiInterface {
  */
 export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInterface {
     /**
-     * Arms cancelRequestedAt + aborts the Viva terminal session. Does not flip status — the webhook/sweep resolves the real outcome, and a late success is auto-voided. Viva card only.
-     * @summary Cancel an in-flight Viva payment session
+     * Arms cancelRequestedAt + aborts at the gateway (Viva session abort / Nets terminal cancelAction, dispatched on the session\'s provider). Does not flip status — the webhook/sweep resolves the real outcome; a late success parks at VOID_PENDING with a dev alert. Card sessions only.
+     * @summary Cancel an in-flight card payment session (Viva or Nets)
      * @param {string} clientToken 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof PaymentSessionApi
      */
-    public cancelVivaSession(clientToken: string, options?: AxiosRequestConfig) {
-        return PaymentSessionApiFp(this.configuration).cancelVivaSession(clientToken, options).then((request) => request(this.axios, this.basePath));
+    public cancelSession(clientToken: string, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).cancelSession(clientToken, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -41437,6 +42177,19 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).getPaymentSession(clientToken, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Creates a PaymentSession row, pushes the transaction to the station\'s Nets terminal (async — the result arrives via the Nets webhook), returns a client-facing token to poll. Idempotent via X-Idempotency-Key header.
+     * @summary Initiate a Nets terminal payment session
+     * @param {InitiateNetsSessionDto} initiateNetsSessionDto 
+     * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).initiateNetsSession(initiateNetsSessionDto, xIdempotencyKey, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Builds the Viva app-to-app launch params (same as the legacy viva/a2a/create-payment) and persists a PaymentSession keyed by the Viva clientTransactionId, so the webhook + reconciliation own the order mutation. Returns the launch params plus a clientToken to poll the session.
      * @summary Initiate a Viva app-to-app payment session
@@ -41462,6 +42215,19 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).initiateVivaSession(initiateVivaSessionDto, xIdempotencyKey, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Creates a PaymentSession row and pushes the transaction to the station\'s Worldline terminal via the Worldline microservice (async — the result arrives via the Worldline webhook). Returns a client-facing token to poll. The backend owns the order mutation (webhook → reconciliation), replacing the legacy FE-writes-from-Ably flow. Idempotent via X-Idempotency-Key header.
+     * @summary Initiate a Worldline terminal payment session
+     * @param {InitiateWorldlineSessionDto} initiateWorldlineSessionDto 
+     * @param {string} [xIdempotencyKey] Client-generated UUID. If a session already exists for this key, the existing session is returned.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public initiateWorldlineSession(initiateWorldlineSessionDto: InitiateWorldlineSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).initiateWorldlineSession(initiateWorldlineSessionDto, xIdempotencyKey, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Called by a Cloud Task (not the client). Holds the request open and long-polls Viva by sessionId for up to ~45s. As soon as the transaction is terminal it updates the session status and, on success, triggers order reconciliation — guarded by a CAS claim (tryClose) so a late webhook never double-writes the paymentEvent — so the order closes even if the webhook never arrives.
      * @summary Internal: long-poll Viva for a stuck payment session (Cloud Task callback)
@@ -41474,6 +42240,18 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).pollVivaSession(pollVivaSessionDto, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Called by a Cloud Task (not the client). Polls the Worldline microservice by operationId for up to ~45s; as soon as the operation is terminal it finalizes the PaymentSession through the same sweep the webhook uses (CAS-guarded, so a webhook + poll never double-write). Ensures the session resolves even if the webhook is slow or never arrives.
+     * @summary Internal: poll Worldline for a stuck payment session (Cloud Task callback)
+     * @param {PollWorldlineSessionDto} pollWorldlineSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public pollWorldlineSession(pollWorldlineSessionDto: PollWorldlineSessionDto, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).pollWorldlineSession(pollWorldlineSessionDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Records a non-gateway payment (cash / voucher / CardManual / gift card / …) through PaymentSession so every device sees it. Card paymethods (Card/Debit/Credit/Edenred) use a gateway initiate. Resolves to SUCCESS immediately; reconciliation writes the paymentEvent.
      * @summary Record a manual payment session
@@ -41486,6 +42264,18 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).recordManualPayment(createManualSessionDto, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Starts a terminal-present ReturnOfGoods on the station\'s Nets terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session (status INITIATED) — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+     * @summary Refund a settled Nets payment session (gateway only, async)
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public refundNetsSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).refundNetsSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Refunds a Viva card payment at the gateway by its sessionId, optionally a partial `amount` (item / cluster refund). Validates the remaining refundable balance and supports multiple partial refunds. Does NOT write a reversal paymentEvent to the order — order-side accounting is handled by the refund plan. For a full reversal that writes the order paymentEvent, use /revert.
      * @summary Refund a settled Viva payment session (gateway only)
@@ -41498,6 +42288,30 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).refundVivaSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Starts a terminal-present ReturnOfGoods on the station\'s Worldline terminal for the given sessionId, refunding the payload `amount` (defaults to the full session amount). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. Does NOT write a reversal paymentEvent to the order.
+     * @summary Refund a settled Worldline payment session (gateway only, async)
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public refundWorldlineSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).refundWorldlineSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Starts a terminal-present ReturnOfGoods for the full remaining amount AND writes a reversal paymentEvent to the order once the refund settles (via reconciliation). Returns a PENDING refund session — the customer must tap their card; poll GET /:clientToken until REFUNDED/FAILED/CANCELLED.
+     * @summary Revert (fully reverse) a settled Nets payment session (async)
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public revertNetsSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).revertNetsSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Fully reverses a completed Viva card payment (SUCCESS / CLOSED) by its sessionId: refunds the full amount at the gateway AND writes a reversal paymentEvent to the order via the settlement engine. Idempotent: re-calling a reverted session is a no-op.
      * @summary Revert (fully reverse) a settled Viva payment session
@@ -41510,6 +42324,18 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).revertVivaSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Starts a terminal reversal for the full remaining amount AND writes a reversal paymentEvent to the order once the reversal settles (via reconciliation). Returns a PENDING refund session — poll GET /:clientToken until REFUNDED/FAILED/CANCELLED. A reversal typically settles without a card tap; if the payment is already batched/settled the reversal fails and the client should fall back to /worldline/refund.
+     * @summary Revert (fully reverse) a settled Worldline payment session (async)
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public revertWorldlineSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).revertWorldlineSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Reverses a manually-recorded payment (cash / voucher / CardManual / gift card / …) by its sessionId (the order paymentEvent referenceId). Not for card paymethods (Card/Debit/Credit/Edenred) — those use cancel/refund. Idempotent: re-calling a voided session is a no-op.
      * @summary Void a manual payment session
@@ -46666,6 +47492,260 @@ export const WebhookApiAxiosParamCreator = function (configuration?: Configurati
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Per-transaction callback registered at initiate (ConnectCloud-Webhook-Address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. Legacy /nets and /v2/nets stay untouched.
+         * @summary Handle Nets webhook events for the payment-session flow
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handleNetsSessionEvents: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/webhook/nets/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: 'POST', ...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,
+            };
+        },
+        /**
+         * 
+         * @summary Handle preorder reminder (triggered by scheduler)
+         * @param {PreOrderReminderDto} preOrderReminderDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handlePreorderReminder: async (preOrderReminderDto: PreOrderReminderDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'preOrderReminderDto' is not null or undefined
+            assertParamExists('handlePreorderReminder', 'preOrderReminderDto', preOrderReminderDto)
+            const localVarPath = `/api/webhook/preorder-reminder`;
+            // 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(preOrderReminderDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handleRoleWebhook: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/webhook/add-roles`;
+            // 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;
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handleShiftWebhook: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/webhook/add-employee-shifts`;
+            // 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;
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @summary Handle Viva payment webhook events
+         * @param {VivaWebhookPayloadDto} vivaWebhookPayloadDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handleVivaEvents: async (vivaWebhookPayloadDto: VivaWebhookPayloadDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'vivaWebhookPayloadDto' is not null or undefined
+            assertParamExists('handleVivaEvents', 'vivaWebhookPayloadDto', vivaWebhookPayloadDto)
+            const localVarPath = `/api/webhook/viva/verification`;
+            // 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(vivaWebhookPayloadDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Shared dispatcher: session-backed Viva events -> PaymentSession update + reconciliation, others -> legacy flow. Both /viva/verification and /viva/payments resolve to the same dispatcher so Viva may deliver to either URL.
+         * @summary Handle Viva webhook events for the payment-session flow
+         * @param {VivaWebhookPayloadDto} vivaWebhookPayloadDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handleVivaSessionEvents: async (vivaWebhookPayloadDto: VivaWebhookPayloadDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'vivaWebhookPayloadDto' is not null or undefined
+            assertParamExists('handleVivaSessionEvents', 'vivaWebhookPayloadDto', vivaWebhookPayloadDto)
+            const localVarPath = `/api/webhook/viva/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: '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(vivaWebhookPayloadDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handleWebhook: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/webhook/ship-day`;
+            // 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;
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handleWoltDriveEvent: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/webhook/wolt-drive/event`;
+            // 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;
+
+
+    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -46677,206 +47757,15 @@ export const WebhookApiAxiosParamCreator = function (configuration?: Configurati
         },
         /**
          * 
-         * @summary Handle preorder reminder (triggered by scheduler)
-         * @param {PreOrderReminderDto} preOrderReminderDto 
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        handlePreorderReminder: async (preOrderReminderDto: PreOrderReminderDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'preOrderReminderDto' is not null or undefined
-            assertParamExists('handlePreorderReminder', 'preOrderReminderDto', preOrderReminderDto)
-            const localVarPath = `/api/webhook/preorder-reminder`;
-            // 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(preOrderReminderDto, localVarRequestOptions, configuration)
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * 
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        handleRoleWebhook: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/api/webhook/add-roles`;
-            // 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;
-
-
-    
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * 
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        handleShiftWebhook: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/api/webhook/add-employee-shifts`;
-            // 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;
-
-
-    
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * 
-         * @summary Handle Viva payment webhook events
-         * @param {VivaWebhookPayloadDto} vivaWebhookPayloadDto 
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        handleVivaEvents: async (vivaWebhookPayloadDto: VivaWebhookPayloadDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'vivaWebhookPayloadDto' is not null or undefined
-            assertParamExists('handleVivaEvents', 'vivaWebhookPayloadDto', vivaWebhookPayloadDto)
-            const localVarPath = `/api/webhook/viva/verification`;
-            // 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(vivaWebhookPayloadDto, localVarRequestOptions, configuration)
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * Routes Viva ECR events to PaymentSession update + reconciliation. Does not touch the legacy /viva/verification path.
-         * @summary Handle Viva webhook events for the payment-session flow
-         * @param {VivaWebhookPayloadDto} vivaWebhookPayloadDto 
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        handleVivaSessionEvents: async (vivaWebhookPayloadDto: VivaWebhookPayloadDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'vivaWebhookPayloadDto' is not null or undefined
-            assertParamExists('handleVivaSessionEvents', 'vivaWebhookPayloadDto', vivaWebhookPayloadDto)
-            const localVarPath = `/api/webhook/viva/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: '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(vivaWebhookPayloadDto, localVarRequestOptions, configuration)
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * 
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        handleWebhook: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/api/webhook/ship-day`;
-            // 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;
-
-
-    
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        /**
-         * 
+         * @param {string} country 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        handleWoltDriveEvent: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/api/webhook/wolt-drive/event`;
+        handleWoltDriveEventByCountry: async (country: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'country' is not null or undefined
+            assertParamExists('handleWoltDriveEventByCountry', 'country', country)
+            const localVarPath = `/api/webhook/wolt-drive/{country}/event`
+                .replace(`{${"country"}}`, encodeURIComponent(String(country)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -46901,15 +47790,11 @@ export const WebhookApiAxiosParamCreator = function (configuration?: Configurati
         },
         /**
          * 
-         * @param {string} country 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        handleWoltDriveEventByCountry: async (country: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'country' is not null or undefined
-            assertParamExists('handleWoltDriveEventByCountry', 'country', country)
-            const localVarPath = `/api/webhook/wolt-drive/{country}/event`
-                .replace(`{${"country"}}`, encodeURIComponent(String(country)));
+        handleWorldlineEvents: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/webhook/worldline/events`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -46933,12 +47818,13 @@ export const WebhookApiAxiosParamCreator = function (configuration?: Configurati
             };
         },
         /**
-         * 
+         * Per-operation callback registered at initiate (x-munchi-webhook-address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. The legacy /worldline/events (FE-writes-from-Ably) stays untouched.
+         * @summary Handle Worldline webhook events for the payment-session flow
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        handleWorldlineEvents: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/api/webhook/worldline/events`;
+        handleWorldlineSessionEvents: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/webhook/worldline/payments`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -47151,6 +48037,16 @@ export const WebhookApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.handleNetsEventsV2(options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Per-transaction callback registered at initiate (ConnectCloud-Webhook-Address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. Legacy /nets and /v2/nets stay untouched.
+         * @summary Handle Nets webhook events for the payment-session flow
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async handleNetsSessionEvents(options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.handleNetsSessionEvents(options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * 
          * @summary Handle preorder reminder (triggered by scheduler)
@@ -47192,7 +48088,7 @@ export const WebhookApiFp = function(configuration?: Configuration) {
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
         /**
-         * Routes Viva ECR events to PaymentSession update + reconciliation. Does not touch the legacy /viva/verification path.
+         * Shared dispatcher: session-backed Viva events -> PaymentSession update + reconciliation, others -> legacy flow. Both /viva/verification and /viva/payments resolve to the same dispatcher so Viva may deliver to either URL.
          * @summary Handle Viva webhook events for the payment-session flow
          * @param {VivaWebhookPayloadDto} vivaWebhookPayloadDto 
          * @param {*} [options] Override http request option.
@@ -47239,6 +48135,16 @@ export const WebhookApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.handleWorldlineEvents(options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Per-operation callback registered at initiate (x-munchi-webhook-address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. The legacy /worldline/events (FE-writes-from-Ably) stays untouched.
+         * @summary Handle Worldline webhook events for the payment-session flow
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async handleWorldlineSessionEvents(options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.handleWorldlineSessionEvents(options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * 
          * @summary Process a queued POS order-actions job (triggered by Cloud Tasks)
@@ -47338,6 +48244,15 @@ export const WebhookApiFactory = function (configuration?: Configuration, basePa
         handleNetsEventsV2(options?: any): AxiosPromise<void> {
             return localVarFp.handleNetsEventsV2(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Per-transaction callback registered at initiate (ConnectCloud-Webhook-Address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. Legacy /nets and /v2/nets stay untouched.
+         * @summary Handle Nets webhook events for the payment-session flow
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handleNetsSessionEvents(options?: any): AxiosPromise<void> {
+            return localVarFp.handleNetsSessionEvents(options).then((request) => request(axios, basePath));
+        },
         /**
          * 
          * @summary Handle preorder reminder (triggered by scheduler)
@@ -47375,7 +48290,7 @@ export const WebhookApiFactory = function (configuration?: Configuration, basePa
             return localVarFp.handleVivaEvents(vivaWebhookPayloadDto, options).then((request) => request(axios, basePath));
         },
         /**
-         * Routes Viva ECR events to PaymentSession update + reconciliation. Does not touch the legacy /viva/verification path.
+         * Shared dispatcher: session-backed Viva events -> PaymentSession update + reconciliation, others -> legacy flow. Both /viva/verification and /viva/payments resolve to the same dispatcher so Viva may deliver to either URL.
          * @summary Handle Viva webhook events for the payment-session flow
          * @param {VivaWebhookPayloadDto} vivaWebhookPayloadDto 
          * @param {*} [options] Override http request option.
@@ -47417,6 +48332,15 @@ export const WebhookApiFactory = function (configuration?: Configuration, basePa
         handleWorldlineEvents(options?: any): AxiosPromise<void> {
             return localVarFp.handleWorldlineEvents(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Per-operation callback registered at initiate (x-munchi-webhook-address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. The legacy /worldline/events (FE-writes-from-Ably) stays untouched.
+         * @summary Handle Worldline webhook events for the payment-session flow
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        handleWorldlineSessionEvents(options?: any): AxiosPromise<void> {
+            return localVarFp.handleWorldlineSessionEvents(options).then((request) => request(axios, basePath));
+        },
         /**
          * 
          * @summary Process a queued POS order-actions job (triggered by Cloud Tasks)
@@ -47511,6 +48435,15 @@ export interface WebhookApiInterface {
      */
     handleNetsEventsV2(options?: AxiosRequestConfig): AxiosPromise<void>;
 
+    /**
+     * Per-transaction callback registered at initiate (ConnectCloud-Webhook-Address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. Legacy /nets and /v2/nets stay untouched.
+     * @summary Handle Nets webhook events for the payment-session flow
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof WebhookApiInterface
+     */
+    handleNetsSessionEvents(options?: AxiosRequestConfig): AxiosPromise<void>;
+
     /**
      * 
      * @summary Handle preorder reminder (triggered by scheduler)
@@ -47548,7 +48481,7 @@ export interface WebhookApiInterface {
     handleVivaEvents(vivaWebhookPayloadDto: VivaWebhookPayloadDto, options?: AxiosRequestConfig): AxiosPromise<void>;
 
     /**
-     * Routes Viva ECR events to PaymentSession update + reconciliation. Does not touch the legacy /viva/verification path.
+     * Shared dispatcher: session-backed Viva events -> PaymentSession update + reconciliation, others -> legacy flow. Both /viva/verification and /viva/payments resolve to the same dispatcher so Viva may deliver to either URL.
      * @summary Handle Viva webhook events for the payment-session flow
      * @param {VivaWebhookPayloadDto} vivaWebhookPayloadDto 
      * @param {*} [options] Override http request option.
@@ -47590,6 +48523,15 @@ export interface WebhookApiInterface {
      */
     handleWorldlineEvents(options?: AxiosRequestConfig): AxiosPromise<void>;
 
+    /**
+     * Per-operation callback registered at initiate (x-munchi-webhook-address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. The legacy /worldline/events (FE-writes-from-Ably) stays untouched.
+     * @summary Handle Worldline webhook events for the payment-session flow
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof WebhookApiInterface
+     */
+    handleWorldlineSessionEvents(options?: AxiosRequestConfig): AxiosPromise<void>;
+
     /**
      * 
      * @summary Process a queued POS order-actions job (triggered by Cloud Tasks)
@@ -47696,6 +48638,17 @@ export class WebhookApi extends BaseAPI implements WebhookApiInterface {
         return WebhookApiFp(this.configuration).handleNetsEventsV2(options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Per-transaction callback registered at initiate (ConnectCloud-Webhook-Address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. Legacy /nets and /v2/nets stay untouched.
+     * @summary Handle Nets webhook events for the payment-session flow
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof WebhookApi
+     */
+    public handleNetsSessionEvents(options?: AxiosRequestConfig) {
+        return WebhookApiFp(this.configuration).handleNetsSessionEvents(options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * 
      * @summary Handle preorder reminder (triggered by scheduler)
@@ -47741,7 +48694,7 @@ export class WebhookApi extends BaseAPI implements WebhookApiInterface {
     }
 
     /**
-     * Routes Viva ECR events to PaymentSession update + reconciliation. Does not touch the legacy /viva/verification path.
+     * Shared dispatcher: session-backed Viva events -> PaymentSession update + reconciliation, others -> legacy flow. Both /viva/verification and /viva/payments resolve to the same dispatcher so Viva may deliver to either URL.
      * @summary Handle Viva webhook events for the payment-session flow
      * @param {VivaWebhookPayloadDto} vivaWebhookPayloadDto 
      * @param {*} [options] Override http request option.
@@ -47793,6 +48746,17 @@ export class WebhookApi extends BaseAPI implements WebhookApiInterface {
         return WebhookApiFp(this.configuration).handleWorldlineEvents(options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Per-operation callback registered at initiate (x-munchi-webhook-address). Finalizes the PaymentSession to SUCCESS/FAILED/CANCELLED and triggers order reconciliation. The legacy /worldline/events (FE-writes-from-Ably) stays untouched.
+     * @summary Handle Worldline webhook events for the payment-session flow
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof WebhookApi
+     */
+    public handleWorldlineSessionEvents(options?: AxiosRequestConfig) {
+        return WebhookApiFp(this.configuration).handleWorldlineSessionEvents(options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * 
      * @summary Process a queued POS order-actions job (triggered by Cloud Tasks)