@munchi_oy/core 1.9.74 → 1.9.76

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
@@ -6703,10 +6730,10 @@ export interface InitiateNetsSessionDto {
     'amount': number;
     /**
      * 
-     * @type {InitiateVivaSessionDtoSplitContext}
+     * @type {CreateManualSessionDtoSplitContext}
      * @memberof InitiateNetsSessionDto
      */
-    'splitContext'?: InitiateVivaSessionDtoSplitContext;
+    'splitContext'?: CreateManualSessionDtoSplitContext;
 }
 /**
  * 
@@ -6796,10 +6823,10 @@ export interface InitiateVivaA2aSessionDto {
     'showTransactionResult'?: boolean;
     /**
      * 
-     * @type {InitiateVivaSessionDtoSplitContext}
+     * @type {CreateManualSessionDtoSplitContext}
      * @memberof InitiateVivaA2aSessionDto
      */
-    'splitContext'?: InitiateVivaSessionDtoSplitContext;
+    'splitContext'?: CreateManualSessionDtoSplitContext;
 }
 
 
@@ -6940,38 +6967,11 @@ export interface InitiateVivaSessionDto {
     'amount': number;
     /**
      * 
-     * @type {InitiateVivaSessionDtoSplitContext}
+     * @type {CreateManualSessionDtoSplitContext}
      * @memberof InitiateVivaSessionDto
      */
-    'splitContext'?: InitiateVivaSessionDtoSplitContext;
+    'splitContext'?: CreateManualSessionDtoSplitContext;
 }
-/**
- * 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;
-}
-
-
 /**
  * 
  * @export
@@ -7084,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
@@ -11564,6 +11632,172 @@ export interface OrderResponseDtoPriceSummary {
      */
     'totalNet': number;
 }
+/**
+ * 
+ * @export
+ * @interface OrderSettlementStatusDto
+ */
+export interface OrderSettlementStatusDto {
+    /**
+     * The internal business ID.
+     * @type {number}
+     * @memberof OrderSettlementStatusDto
+     */
+    'businessId': number;
+    /**
+     * The order ID the settlement is computed for.
+     * @type {string}
+     * @memberof OrderSettlementStatusDto
+     */
+    'orderId': string;
+    /**
+     * The order\'s checkout model (FULL / EQUAL_SPLIT / ITEM_SPLIT).
+     * @type {string}
+     * @memberof OrderSettlementStatusDto
+     */
+    'checkoutModel': string;
+    /**
+     * Overall settlement status: \'underpaid\' | \'settled\' | \'overpaid\'.
+     * @type {string}
+     * @memberof OrderSettlementStatusDto
+     */
+    'status': string;
+    /**
+     * True once the order is fully paid (settled or overpaid). The FE\'s stop condition.
+     * @type {boolean}
+     * @memberof OrderSettlementStatusDto
+     */
+    'isFullyPaid': boolean;
+    /**
+     * Order total in the smallest currency unit (cents).
+     * @type {number}
+     * @memberof OrderSettlementStatusDto
+     */
+    'cartTotal': number;
+    /**
+     * Sum of settled payments in cents.
+     * @type {number}
+     * @memberof OrderSettlementStatusDto
+     */
+    'paidAmount': number;
+    /**
+     * Outstanding balance in cents (0 when settled/overpaid).
+     * @type {number}
+     * @memberof OrderSettlementStatusDto
+     */
+    'remainingAmount': number;
+    /**
+     * Amount still payable in cents (never negative).
+     * @type {number}
+     * @memberof OrderSettlementStatusDto
+     */
+    'amountLeftToPay': number;
+    /**
+     * Number of paymentEvents currently on the order.
+     * @type {number}
+     * @memberof OrderSettlementStatusDto
+     */
+    'paymentEventCount': number;
+}
+/**
+ * 
+ * @export
+ * @interface OrderSettlementStatusRequestDto
+ */
+export interface OrderSettlementStatusRequestDto {
+    /**
+     * Cash change handed back to the customer (cents), netted out of the paid amount so an over-tender does not read as overpaid. Omit or 0 for no adjustment.
+     * @type {number}
+     * @memberof OrderSettlementStatusRequestDto
+     */
+    'cashChange'?: number;
+    /**
+     * Override the cart total (cents) instead of the persisted order total. For FULL-cart callers whose total differs from the snapshot (e.g. cash-rounded).
+     * @type {number}
+     * @memberof OrderSettlementStatusRequestDto
+     */
+    'cartTotalAmount'?: number;
+}
+/**
+ * 
+ * @export
+ * @interface OrderSettlementStatusResponseDto
+ */
+export interface OrderSettlementStatusResponseDto {
+    /**
+     * 
+     * @type {OrderSettlementStatusResponseDtoSettlement}
+     * @memberof OrderSettlementStatusResponseDto
+     */
+    'settlement': OrderSettlementStatusResponseDtoSettlement | null;
+}
+/**
+ * The settlement status, or null when the order is unavailable / not computable.
+ * @export
+ * @interface OrderSettlementStatusResponseDtoSettlement
+ */
+export interface OrderSettlementStatusResponseDtoSettlement {
+    /**
+     * The internal business ID.
+     * @type {number}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'businessId': number;
+    /**
+     * The order ID the settlement is computed for.
+     * @type {string}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'orderId': string;
+    /**
+     * The order\'s checkout model (FULL / EQUAL_SPLIT / ITEM_SPLIT).
+     * @type {string}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'checkoutModel': string;
+    /**
+     * Overall settlement status: \'underpaid\' | \'settled\' | \'overpaid\'.
+     * @type {string}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'status': string;
+    /**
+     * True once the order is fully paid (settled or overpaid). The FE\'s stop condition.
+     * @type {boolean}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'isFullyPaid': boolean;
+    /**
+     * Order total in the smallest currency unit (cents).
+     * @type {number}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'cartTotal': number;
+    /**
+     * Sum of settled payments in cents.
+     * @type {number}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'paidAmount': number;
+    /**
+     * Outstanding balance in cents (0 when settled/overpaid).
+     * @type {number}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'remainingAmount': number;
+    /**
+     * Amount still payable in cents (never negative).
+     * @type {number}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'amountLeftToPay': number;
+    /**
+     * Number of paymentEvents currently on the order.
+     * @type {number}
+     * @memberof OrderSettlementStatusResponseDtoSettlement
+     */
+    'paymentEventCount': number;
+}
 /**
  * 
  * @export
@@ -14124,6 +14358,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
@@ -19846,6 +20093,275 @@ export interface SupportedChannelDto {
 }
 
 
+/**
+ * 
+ * @export
+ * @interface SyncKioskOrderDto
+ */
+export interface SyncKioskOrderDto {
+    /**
+     * 
+     * @type {SyncKioskOrderDtoOrder}
+     * @memberof SyncKioskOrderDto
+     */
+    'order': SyncKioskOrderDtoOrder;
+}
+/**
+ * Kiosk order snapshot to persist (same shape as PosOrderDto). Transitional: paymentEvents are still client-owned and persisted as sent.
+ * @export
+ * @interface SyncKioskOrderDtoOrder
+ */
+export interface SyncKioskOrderDtoOrder {
+    /**
+     * 
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'id': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'businessId': string;
+    /**
+     * 
+     * @type {ProviderEnum}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'provider': ProviderEnum;
+    /**
+     * 
+     * @type {CurrencyCode}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'currency': CurrencyCode;
+    /**
+     * 
+     * @type {PosBusinessDto}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'business': PosBusinessDto;
+    /**
+     * 
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'createdAt': string;
+    /**
+     * 
+     * @type {OrderStatusEnum}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'status': OrderStatusEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'updatedAt': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'completedAt'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'orderNumber': string;
+    /**
+     * 
+     * @type {CheckoutModelEnum}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'checkoutModel': CheckoutModelEnum;
+    /**
+     * 
+     * @type {OrderTypePOS}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'orderType': OrderTypePOS;
+    /**
+     * 
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'spotNumber': string | null;
+    /**
+     * ID of the floor plan dining table linked to this order
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'tableId'?: string | null;
+    /**
+     * 
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'comments': string | null;
+    /**
+     * 
+     * @type {PosOrderDtoTableService}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'tableService'?: PosOrderDtoTableService | null;
+    /**
+     * 
+     * @type {PosOrderDtoEqualSplitState}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'equalSplitState'?: PosOrderDtoEqualSplitState | null;
+    /**
+     * Id of the staff in shift
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'staffId': string | null;
+    /**
+     * Id of the shift
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'shiftId': string | null;
+    /**
+     * 
+     * @type {OrderRefundStatus}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'orderRefundStatus': OrderRefundStatus;
+    /**
+     * 
+     * @type {LocatorType}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'locatorType': LocatorType;
+    /**
+     * 
+     * @type {PosOrderPriceDto}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'basketPrice': PosOrderPriceDto;
+    /**
+     * 
+     * @type {Array<PosOrderItemDto>}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'items': Array<PosOrderItemDto>;
+    /**
+     * 
+     * @type {Array<PosDiscountDto>}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'discounts': Array<PosDiscountDto>;
+    /**
+     * 
+     * @type {PosCustomerDto}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'customer': PosCustomerDto | null;
+    /**
+     * 
+     * @type {Array<TransactionDto>}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'paymentEvents': Array<TransactionDto>;
+    /**
+     * 
+     * @type {Array<PaymentRefundDto>}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'refunds'?: Array<PaymentRefundDto>;
+    /**
+     * Data version code
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'version': string;
+    /**
+     * 
+     * @type {OrderFormat}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'orderFormat'?: OrderFormat;
+    /**
+     * The ID of the loyalty program active during this order.
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'loyaltyProgramId': string | null;
+    /**
+     * An array of loyalty transaction IDs related to this order.
+     * @type {Array<string>}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'loyaltyTransactionIds': Array<string>;
+    /**
+     * 
+     * @type {PosOrderDtoTaxSummary}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'taxSummary'?: PosOrderDtoTaxSummary;
+    /**
+     * Name of staff member who created the order
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'staffName'?: string | null;
+    /**
+     * 
+     * @type {PosOrderDtoInvoiceCompany}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'invoiceCompany'?: PosOrderDtoInvoiceCompany | null;
+    /**
+     * 
+     * @type {object}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'lastPaymentError'?: object;
+    /**
+     * 
+     * @type {Array<OrderFeeDto>}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'fees'?: Array<OrderFeeDto> | null;
+    /**
+     * Loyalty user ID associated with this order
+     * @type {number}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'targetUserId'?: number;
+    /**
+     * ID of the table group this order belongs to
+     * @type {string}
+     * @memberof SyncKioskOrderDtoOrder
+     */
+    'tableGroupId'?: string | null;
+}
+
+
+/**
+ * 
+ * @export
+ * @interface SyncKioskOrderResponseDto
+ */
+export interface SyncKioskOrderResponseDto {
+    /**
+     * Whether the order snapshot was persisted.
+     * @type {boolean}
+     * @memberof SyncKioskOrderResponseDto
+     */
+    'synced': boolean;
+    /**
+     * Id of the synced order.
+     * @type {string}
+     * @memberof SyncKioskOrderResponseDto
+     */
+    'orderId': string;
+}
 /**
  * 
  * @export
@@ -25365,6 +25881,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}
@@ -25421,6 +25943,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
@@ -34618,6 +35199,44 @@ export class KDSApi extends BaseAPI implements KDSApiInterface {
  */
 export const KiosksApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
+        /**
+         * Fresh read of the persisted kiosk order (same PosOrderDto shape as POS): basketPrice, paymentEvents, targetUserId, etc. 404 when the order snapshot does not exist. Replaces the client\'s direct Firestore reads for the receipt screen and the recovery paid-status gate.
+         * @summary Get the full kiosk order snapshot by id
+         * @param {string} orderId The unique ID of the order.
+         * @param {string} businessId The unique ID of the business.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getKioskOrder: async (orderId: string, businessId: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'orderId' is not null or undefined
+            assertParamExists('getKioskOrder', 'orderId', orderId)
+            // verify required parameter 'businessId' is not null or undefined
+            assertParamExists('getKioskOrder', 'businessId', businessId)
+            const localVarPath = `/api/v1/kiosk/orders/{orderId}/{businessId}`
+                .replace(`{${"orderId"}}`, encodeURIComponent(String(orderId)))
+                .replace(`{${"businessId"}}`, encodeURIComponent(String(businessId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * 
          * @param {string} orderId The unique ID of the order to validate against the system.
@@ -34692,6 +35311,42 @@ export const KiosksApiAxiosParamCreator = function (configuration?: Configuratio
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * 
+         * @summary Sync a kiosk order snapshot
+         * @param {SyncKioskOrderDto} syncKioskOrderDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        syncKioskOrder: async (syncKioskOrderDto: SyncKioskOrderDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'syncKioskOrderDto' is not null or undefined
+            assertParamExists('syncKioskOrder', 'syncKioskOrderDto', syncKioskOrderDto)
+            const localVarPath = `/api/v1/kiosk/orders/sync`;
+            // 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(syncKioskOrderDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * 
          * @param {string} terminalId The unique ID of the terminal to validate against the system.
@@ -34745,6 +35400,18 @@ export const KiosksApiAxiosParamCreator = function (configuration?: Configuratio
 export const KiosksApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = KiosksApiAxiosParamCreator(configuration)
     return {
+        /**
+         * Fresh read of the persisted kiosk order (same PosOrderDto shape as POS): basketPrice, paymentEvents, targetUserId, etc. 404 when the order snapshot does not exist. Replaces the client\'s direct Firestore reads for the receipt screen and the recovery paid-status gate.
+         * @summary Get the full kiosk order snapshot by id
+         * @param {string} orderId The unique ID of the order.
+         * @param {string} businessId The unique ID of the business.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getKioskOrder(orderId: string, businessId: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PosOrderDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getKioskOrder(orderId, businessId, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * 
          * @param {string} orderId The unique ID of the order to validate against the system.
@@ -34767,6 +35434,17 @@ export const KiosksApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.recoverOrder(orderId, businessId, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * 
+         * @summary Sync a kiosk order snapshot
+         * @param {SyncKioskOrderDto} syncKioskOrderDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async syncKioskOrder(syncKioskOrderDto: SyncKioskOrderDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SyncKioskOrderResponseDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.syncKioskOrder(syncKioskOrderDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * 
          * @param {string} terminalId The unique ID of the terminal to validate against the system.
@@ -34788,6 +35466,17 @@ export const KiosksApiFp = function(configuration?: Configuration) {
 export const KiosksApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
     const localVarFp = KiosksApiFp(configuration)
     return {
+        /**
+         * Fresh read of the persisted kiosk order (same PosOrderDto shape as POS): basketPrice, paymentEvents, targetUserId, etc. 404 when the order snapshot does not exist. Replaces the client\'s direct Firestore reads for the receipt screen and the recovery paid-status gate.
+         * @summary Get the full kiosk order snapshot by id
+         * @param {string} orderId The unique ID of the order.
+         * @param {string} businessId The unique ID of the business.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getKioskOrder(orderId: string, businessId: string, options?: any): AxiosPromise<PosOrderDto> {
+            return localVarFp.getKioskOrder(orderId, businessId, options).then((request) => request(axios, basePath));
+        },
         /**
          * 
          * @param {string} orderId The unique ID of the order to validate against the system.
@@ -34808,6 +35497,16 @@ export const KiosksApiFactory = function (configuration?: Configuration, basePat
         recoverOrder(orderId: string, businessId: string, options?: any): AxiosPromise<void> {
             return localVarFp.recoverOrder(orderId, businessId, options).then((request) => request(axios, basePath));
         },
+        /**
+         * 
+         * @summary Sync a kiosk order snapshot
+         * @param {SyncKioskOrderDto} syncKioskOrderDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        syncKioskOrder(syncKioskOrderDto: SyncKioskOrderDto, options?: any): AxiosPromise<SyncKioskOrderResponseDto> {
+            return localVarFp.syncKioskOrder(syncKioskOrderDto, options).then((request) => request(axios, basePath));
+        },
         /**
          * 
          * @param {string} terminalId The unique ID of the terminal to validate against the system.
@@ -34827,6 +35526,17 @@ export const KiosksApiFactory = function (configuration?: Configuration, basePat
  * @interface KiosksApi
  */
 export interface KiosksApiInterface {
+    /**
+     * Fresh read of the persisted kiosk order (same PosOrderDto shape as POS): basketPrice, paymentEvents, targetUserId, etc. 404 when the order snapshot does not exist. Replaces the client\'s direct Firestore reads for the receipt screen and the recovery paid-status gate.
+     * @summary Get the full kiosk order snapshot by id
+     * @param {string} orderId The unique ID of the order.
+     * @param {string} businessId The unique ID of the business.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof KiosksApiInterface
+     */
+    getKioskOrder(orderId: string, businessId: string, options?: AxiosRequestConfig): AxiosPromise<PosOrderDto>;
+
     /**
      * 
      * @param {string} orderId The unique ID of the order to validate against the system.
@@ -34847,6 +35557,16 @@ export interface KiosksApiInterface {
      */
     recoverOrder(orderId: string, businessId: string, options?: AxiosRequestConfig): AxiosPromise<void>;
 
+    /**
+     * 
+     * @summary Sync a kiosk order snapshot
+     * @param {SyncKioskOrderDto} syncKioskOrderDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof KiosksApiInterface
+     */
+    syncKioskOrder(syncKioskOrderDto: SyncKioskOrderDto, options?: AxiosRequestConfig): AxiosPromise<SyncKioskOrderResponseDto>;
+
     /**
      * 
      * @param {string} terminalId The unique ID of the terminal to validate against the system.
@@ -34866,6 +35586,19 @@ export interface KiosksApiInterface {
  * @extends {BaseAPI}
  */
 export class KiosksApi extends BaseAPI implements KiosksApiInterface {
+    /**
+     * Fresh read of the persisted kiosk order (same PosOrderDto shape as POS): basketPrice, paymentEvents, targetUserId, etc. 404 when the order snapshot does not exist. Replaces the client\'s direct Firestore reads for the receipt screen and the recovery paid-status gate.
+     * @summary Get the full kiosk order snapshot by id
+     * @param {string} orderId The unique ID of the order.
+     * @param {string} businessId The unique ID of the business.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof KiosksApi
+     */
+    public getKioskOrder(orderId: string, businessId: string, options?: AxiosRequestConfig) {
+        return KiosksApiFp(this.configuration).getKioskOrder(orderId, businessId, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * 
      * @param {string} orderId The unique ID of the order to validate against the system.
@@ -34890,6 +35623,18 @@ export class KiosksApi extends BaseAPI implements KiosksApiInterface {
         return KiosksApiFp(this.configuration).recoverOrder(orderId, businessId, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * 
+     * @summary Sync a kiosk order snapshot
+     * @param {SyncKioskOrderDto} syncKioskOrderDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof KiosksApi
+     */
+    public syncKioskOrder(syncKioskOrderDto: SyncKioskOrderDto, options?: AxiosRequestConfig) {
+        return KiosksApiFp(this.configuration).syncKioskOrder(syncKioskOrderDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * 
      * @param {string} terminalId The unique ID of the terminal to validate against the system.
@@ -40911,6 +41656,48 @@ export const PaymentSessionApiAxiosParamCreator = function (configuration?: Conf
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Unified paid-status check for both POS and kiosk. Reads the order from the channel-appropriate collection (via the x-app-x channel header) and derives the settlement from its persisted paymentEvents — the same events reconciliation writes for every provider (Viva/Nets/Worldline, card or manual). The FE polls this after a payment and stops when isFullyPaid is true. Send an empty body for the plain check, or optional { cashChange, cartTotalAmount } overrides. Always 200: `settlement` is null while the order snapshot does not yet exist / cannot be computed (treat as pending).
+         * @summary Get an order\'s paid/reconcile status (POS or kiosk)
+         * @param {number} businessId The internal business ID.
+         * @param {string} orderId The order ID.
+         * @param {OrderSettlementStatusRequestDto} [orderSettlementStatusRequestDto] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getOrderSettlementStatus: async (businessId: number, orderId: string, orderSettlementStatusRequestDto?: OrderSettlementStatusRequestDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'businessId' is not null or undefined
+            assertParamExists('getOrderSettlementStatus', 'businessId', businessId)
+            // verify required parameter 'orderId' is not null or undefined
+            assertParamExists('getOrderSettlementStatus', 'orderId', orderId)
+            const localVarPath = `/api/v1/payment-session/order-settlement/{businessId}/{orderId}`
+                .replace(`{${"businessId"}}`, encodeURIComponent(String(businessId)))
+                .replace(`{${"orderId"}}`, encodeURIComponent(String(orderId)));
+            // 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(orderSettlementStatusRequestDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Reads PaymentSession from Postgres. Use this to poll session lifecycle without hitting the Viva API.
          * @summary Get payment session status by clientToken
@@ -41063,6 +41850,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)
@@ -41099,6 +41927,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
@@ -41195,6 +42059,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-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);
@@ -41267,6 +42167,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);
@@ -41336,6 +42272,19 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.cancelSession(clientToken, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Unified paid-status check for both POS and kiosk. Reads the order from the channel-appropriate collection (via the x-app-x channel header) and derives the settlement from its persisted paymentEvents — the same events reconciliation writes for every provider (Viva/Nets/Worldline, card or manual). The FE polls this after a payment and stops when isFullyPaid is true. Send an empty body for the plain check, or optional { cashChange, cartTotalAmount } overrides. Always 200: `settlement` is null while the order snapshot does not yet exist / cannot be computed (treat as pending).
+         * @summary Get an order\'s paid/reconcile status (POS or kiosk)
+         * @param {number} businessId The internal business ID.
+         * @param {string} orderId The order ID.
+         * @param {OrderSettlementStatusRequestDto} [orderSettlementStatusRequestDto] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getOrderSettlementStatus(businessId: number, orderId: string, orderSettlementStatusRequestDto?: OrderSettlementStatusRequestDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OrderSettlementStatusResponseDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getOrderSettlementStatus(businessId, orderId, orderSettlementStatusRequestDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Reads PaymentSession from Postgres. Use this to poll session lifecycle without hitting the Viva API.
          * @summary Get payment session status by clientToken
@@ -41382,6 +42331,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)
@@ -41393,6 +42354,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
@@ -41426,6 +42398,17 @@ 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)
@@ -41448,6 +42431,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
@@ -41479,6 +42473,18 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         cancelSession(clientToken: string, options?: any): AxiosPromise<PaymentSessionViewDto> {
             return localVarFp.cancelSession(clientToken, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Unified paid-status check for both POS and kiosk. Reads the order from the channel-appropriate collection (via the x-app-x channel header) and derives the settlement from its persisted paymentEvents — the same events reconciliation writes for every provider (Viva/Nets/Worldline, card or manual). The FE polls this after a payment and stops when isFullyPaid is true. Send an empty body for the plain check, or optional { cashChange, cartTotalAmount } overrides. Always 200: `settlement` is null while the order snapshot does not yet exist / cannot be computed (treat as pending).
+         * @summary Get an order\'s paid/reconcile status (POS or kiosk)
+         * @param {number} businessId The internal business ID.
+         * @param {string} orderId The order ID.
+         * @param {OrderSettlementStatusRequestDto} [orderSettlementStatusRequestDto] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getOrderSettlementStatus(businessId: number, orderId: string, orderSettlementStatusRequestDto?: OrderSettlementStatusRequestDto, options?: any): AxiosPromise<OrderSettlementStatusResponseDto> {
+            return localVarFp.getOrderSettlementStatus(businessId, orderId, orderSettlementStatusRequestDto, options).then((request) => request(axios, basePath));
+        },
         /**
          * Reads PaymentSession from Postgres. Use this to poll session lifecycle without hitting the Viva API.
          * @summary Get payment session status by clientToken
@@ -41521,6 +42527,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)
@@ -41531,6 +42548,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
@@ -41561,6 +42588,16 @@ 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)
@@ -41581,6 +42618,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
@@ -41610,6 +42657,18 @@ export interface PaymentSessionApiInterface {
      */
     cancelSession(clientToken: string, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
 
+    /**
+     * Unified paid-status check for both POS and kiosk. Reads the order from the channel-appropriate collection (via the x-app-x channel header) and derives the settlement from its persisted paymentEvents — the same events reconciliation writes for every provider (Viva/Nets/Worldline, card or manual). The FE polls this after a payment and stops when isFullyPaid is true. Send an empty body for the plain check, or optional { cashChange, cartTotalAmount } overrides. Always 200: `settlement` is null while the order snapshot does not yet exist / cannot be computed (treat as pending).
+     * @summary Get an order\'s paid/reconcile status (POS or kiosk)
+     * @param {number} businessId The internal business ID.
+     * @param {string} orderId The order ID.
+     * @param {OrderSettlementStatusRequestDto} [orderSettlementStatusRequestDto] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    getOrderSettlementStatus(businessId: number, orderId: string, orderSettlementStatusRequestDto?: OrderSettlementStatusRequestDto, options?: AxiosRequestConfig): AxiosPromise<OrderSettlementStatusResponseDto>;
+
     /**
      * Reads PaymentSession from Postgres. Use this to poll session lifecycle without hitting the Viva API.
      * @summary Get payment session status by clientToken
@@ -41652,6 +42711,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)
@@ -41662,6 +42732,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
@@ -41692,6 +42772,16 @@ 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)
@@ -41712,6 +42802,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
@@ -41743,6 +42843,20 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).cancelSession(clientToken, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Unified paid-status check for both POS and kiosk. Reads the order from the channel-appropriate collection (via the x-app-x channel header) and derives the settlement from its persisted paymentEvents — the same events reconciliation writes for every provider (Viva/Nets/Worldline, card or manual). The FE polls this after a payment and stops when isFullyPaid is true. Send an empty body for the plain check, or optional { cashChange, cartTotalAmount } overrides. Always 200: `settlement` is null while the order snapshot does not yet exist / cannot be computed (treat as pending).
+     * @summary Get an order\'s paid/reconcile status (POS or kiosk)
+     * @param {number} businessId The internal business ID.
+     * @param {string} orderId The order ID.
+     * @param {OrderSettlementStatusRequestDto} [orderSettlementStatusRequestDto] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public getOrderSettlementStatus(businessId: number, orderId: string, orderSettlementStatusRequestDto?: OrderSettlementStatusRequestDto, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).getOrderSettlementStatus(businessId, orderId, orderSettlementStatusRequestDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Reads PaymentSession from Postgres. Use this to poll session lifecycle without hitting the Viva API.
      * @summary Get payment session status by clientToken
@@ -41793,6 +42907,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)
@@ -41805,6 +42932,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
@@ -41841,6 +42980,18 @@ 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)
@@ -41865,6 +43016,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
@@ -47337,6 +48500,36 @@ 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-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: 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;
+            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};
@@ -47634,6 +48827,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)
@@ -47821,6 +49024,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)
@@ -48003,6 +49215,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)
@@ -48217,6 +49438,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)