@munchi_oy/core 2.16.0 → 2.17.0

package/dist/generated/api.d.ts

@@ -8854,6 +8854,12 @@ export interface GiftCardHistoryEventDto {
      * @memberof GiftCardHistoryEventDto
      */
     'orderId': string | null;
+    /**
+     * The number of that till order, as its receipt and the Orders screen show it; null when there is no order, or its number could not be read
+     * @type {string}
+     * @memberof GiftCardHistoryEventDto
+     */
+    'orderNumber'?: string | null;
     /**
      * The address of an EMAILED, EMAIL_FAILED or EMAIL_CHANGED line; null for the others
      * @type {string}
@@ -9130,6 +9136,12 @@ export interface GiftCardMovementDto {
      * @memberof GiftCardMovementDto
      */
     'orderId': string | null;
+    /**
+     * The number of that till order, as its receipt and the Orders screen show it; null when there is no order, or its number could not be read
+     * @type {string}
+     * @memberof GiftCardMovementDto
+     */
+    'orderNumber'?: string | null;
     /**
      * True for a SOLD movement whose card is still NOT_YET_VALID: its POS order is not paid yet, and the report\'s sold leaves it out
      * @type {boolean}
@@ -10125,6 +10137,68 @@ export interface InitiateNetsTerminalPaymentResponseDto {
      */
     'connectCloudRequestId': string;
 }
+/**
+ *
+ * @export
+ * @interface InitiateNexiSessionDto
+ */
+export interface InitiateNexiSessionDto {
+    /**
+     *
+     * @type {CreateManualSessionDtoDevice}
+     * @memberof InitiateNexiSessionDto
+     */
+    'device'?: CreateManualSessionDtoDevice | null;
+    /**
+     * The venue\'s orderingBusinessId. Must be the venue of the station calling.
+     * @type {number}
+     * @memberof InitiateNexiSessionDto
+     */
+    'businessId': number;
+    /**
+     * The POS order this payment is for.
+     * @type {string}
+     * @memberof InitiateNexiSessionDto
+     */
+    'orderId': string;
+    /**
+     * Amount to charge, in cents, without a tip: a tip the customer adds on the Nexi terminal is recorded from Nexi\'s answer. Must not exceed what the order still owes.
+     * @type {number}
+     * @memberof InitiateNexiSessionDto
+     */
+    'amount': number;
+    /**
+     *
+     * @type {InitiateNexiSessionDtoSplitContext}
+     * @memberof InitiateNexiSessionDto
+     */
+    'splitContext'?: InitiateNexiSessionDtoSplitContext;
+}
+/**
+ * Split context. Omit for a full-cart payment, or send { mode, partId|seatId } for a split. Must match the order\'s checkoutModel.
+ * @export
+ * @interface InitiateNexiSessionDtoSplitContext
+ */
+export interface InitiateNexiSessionDtoSplitContext {
+    /**
+     *
+     * @type {CheckoutModelEnum}
+     * @memberof InitiateNexiSessionDtoSplitContext
+     */
+    'mode': CheckoutModelEnum;
+    /**
+     * Equal-split part id. Required when mode=EQUAL_SPLIT; ignored otherwise.
+     * @type {string}
+     * @memberof InitiateNexiSessionDtoSplitContext
+     */
+    'partId'?: string;
+    /**
+     * Item-split seat id. Required when mode=ITEM_SPLIT; ignored otherwise.
+     * @type {string}
+     * @memberof InitiateNexiSessionDtoSplitContext
+     */
+    'seatId'?: string;
+}
 /**
  *
  * @export
@@ -15297,6 +15371,61 @@ export interface NewKdsStationDto {
      */
     'categoryIds': Array<string>;
 }
+/**
+ *
+ * @export
+ * @enum {string}
+ */
+export declare const NexiPauseReason: {
+    readonly NexiUnheard: "nexi unheard";
+    readonly NexiPaused: "nexi paused";
+    readonly ConfirmNotTaken: "confirm not taken";
+    readonly OrderNotWritten: "order not written";
+};
+export type NexiPauseReason = typeof NexiPauseReason[keyof typeof NexiPauseReason];
+/**
+ *
+ * @export
+ * @interface NexiWaitRoundDto
+ */
+export interface NexiWaitRoundDto {
+    /**
+     * The session\'s id, which Nexi knows as the sale\'s external_id.
+     * @type {string}
+     * @memberof NexiWaitRoundDto
+     */
+    'sessionId': string;
+    /**
+     * This round\'s number, from 1. It names the Cloud Task, so one round is never queued twice.
+     * @type {number}
+     * @memberof NexiWaitRoundDto
+     */
+    'round': number;
+    /**
+     * How many rounds in a row before this one were booked after a pause. The pause before the next round doubles with it, up to a minute.
+     * @type {number}
+     * @memberof NexiWaitRoundDto
+     */
+    'pausedRounds': number;
+    /**
+     *
+     * @type {NexiPauseReason}
+     * @memberof NexiWaitRoundDto
+     */
+    'pausedFor'?: NexiPauseReason;
+    /**
+     * When the pauses for `pausedFor` began, as an ISO 8601 time; absent when this round was booked at once.
+     * @type {string}
+     * @memberof NexiWaitRoundDto
+     */
+    'pausedSince'?: string;
+    /**
+     * True once a person was alerted that the pauses for `pausedFor` outlasted their window; the server then keeps asking a minute apart and does not alert again. Absent before.
+     * @type {boolean}
+     * @memberof NexiWaitRoundDto
+     */
+    'personTold'?: boolean;
+}
 /**
  *
  * @export
@@ -53088,6 +53217,15 @@ export declare const PaymentSessionApiAxiosParamCreator: (configuration?: Config
      * @throws {RequiredError}
      */
     initiateNetsSession: (initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * Saves the session first, its sessionId being the sale\'s external_id at Nexi, then asks Nexi to start the sale and answer at once. The customer then taps on the terminal; Cloud Tasks ask Nexi until the sale ends. When Nexi answers paid, in this order: Nexi\'s answer is kept on the session (the status unchanged), Nexi is confirmed (which takes the money), the session is stored SUCCESS, the payment is written on the order (reconciliation, which announces the settled order on the venue\'s channel), and only then SUCCESS is announced on the session\'s channel. So nothing tells the till \'paid\' before the money is taken. If the order cannot take the payment, it is asked again for up to 5 minutes, then the charge goes to the till as its own order and a person is alerted. Follow the session on the Ably channel nexi.<channel>.requests.<sessionId> (event payment:status-changed) or with GET /payment-session/:clientToken, which shows SUCCESS from the moment Nexi took the money. A tip or surcharge typed on the terminal is recorded from Nexi\'s answer. A Nexi sale is refused by :clientToken/cancel; Nexi\'s own cancel comes with a later route. Idempotent by the X-Idempotency-Key header within the venue: a repeat answers the session it started without asking Nexi again. A signed-in ticket only: the service key is not accepted (R27).
+     * @summary Start a card payment on the station\'s Nexi terminal
+     * @param {InitiateNexiSessionDto} initiateNexiSessionDto
+     * @param {string} [xIdempotencyKey] A UUID the app makes for this payment. A repeated key answers the session it started, without charging again.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    initiateNexiSession: (initiateNexiSessionDto: InitiateNexiSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * 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
@@ -53268,6 +53406,14 @@ export declare const PaymentSessionApiAxiosParamCreator: (configuration?: Config
      * @throws {RequiredError}
      */
     voidManualPayment: (voidManualSessionDto: VoidManualSessionDto, options?: AxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * Called by a Cloud Task with the scheduler key, never by an app. Repeats a waiting sale\'s purchase at Nexi, which holds the question up to 25 seconds and answers the moment the customer finishes. Still at the terminal: the next round is booked at once; paused at Nexi: after a pause. Paid: Nexi\'s answer is kept, Nexi is confirmed, the sale is stored SUCCESS, written on the order, then announced. Not paid: the failure is confirmed at Nexi with its code, then recorded FAILED in the till\'s words and announced. A sale already stored paid is put on the order from what the session keeps: Nexi is not asked and no login is read. Nexi busy or unreachable: the next round follows Nexi\'s Retry-After up to a minute, or a pause that doubles up to a minute, each with jitter. After 5 minutes of pauses for one reason: an order write that keeps failing hands the charge to the till as its own order and alerts a person; a confirm Nexi keeps refusing (Nexi: confirm until the server takes it) and a Nexi that cannot be heard alert a person once and are asked on every minute, never given up. Answers 500 when the next round could not be booked, so Cloud Tasks runs this round again.
+     * @summary Internal: ask Nexi about a sale once more (Cloud Task callback)
+     * @param {NexiWaitRoundDto} nexiWaitRoundDto
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    waitForNexiSession: (nexiWaitRoundDto: NexiWaitRoundDto, options?: AxiosRequestConfig) => Promise<RequestArgs>;
 };
 /**
  * PaymentSessionApi - functional programming interface
@@ -53338,6 +53484,15 @@ export declare const PaymentSessionApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InitiateNetsSessionResponseDto>>;
+    /**
+     * Saves the session first, its sessionId being the sale\'s external_id at Nexi, then asks Nexi to start the sale and answer at once. The customer then taps on the terminal; Cloud Tasks ask Nexi until the sale ends. When Nexi answers paid, in this order: Nexi\'s answer is kept on the session (the status unchanged), Nexi is confirmed (which takes the money), the session is stored SUCCESS, the payment is written on the order (reconciliation, which announces the settled order on the venue\'s channel), and only then SUCCESS is announced on the session\'s channel. So nothing tells the till \'paid\' before the money is taken. If the order cannot take the payment, it is asked again for up to 5 minutes, then the charge goes to the till as its own order and a person is alerted. Follow the session on the Ably channel nexi.<channel>.requests.<sessionId> (event payment:status-changed) or with GET /payment-session/:clientToken, which shows SUCCESS from the moment Nexi took the money. A tip or surcharge typed on the terminal is recorded from Nexi\'s answer. A Nexi sale is refused by :clientToken/cancel; Nexi\'s own cancel comes with a later route. Idempotent by the X-Idempotency-Key header within the venue: a repeat answers the session it started without asking Nexi again. A signed-in ticket only: the service key is not accepted (R27).
+     * @summary Start a card payment on the station\'s Nexi terminal
+     * @param {InitiateNexiSessionDto} initiateNexiSessionDto
+     * @param {string} [xIdempotencyKey] A UUID the app makes for this payment. A repeated key answers the session it started, without charging again.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    initiateNexiSession(initiateNexiSessionDto: InitiateNexiSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PaymentSessionViewDto>>;
     /**
      * 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
@@ -53518,6 +53673,14 @@ export declare const PaymentSessionApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     voidManualPayment(voidManualSessionDto: VoidManualSessionDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RecordManualPaymentResultDto>>;
+    /**
+     * Called by a Cloud Task with the scheduler key, never by an app. Repeats a waiting sale\'s purchase at Nexi, which holds the question up to 25 seconds and answers the moment the customer finishes. Still at the terminal: the next round is booked at once; paused at Nexi: after a pause. Paid: Nexi\'s answer is kept, Nexi is confirmed, the sale is stored SUCCESS, written on the order, then announced. Not paid: the failure is confirmed at Nexi with its code, then recorded FAILED in the till\'s words and announced. A sale already stored paid is put on the order from what the session keeps: Nexi is not asked and no login is read. Nexi busy or unreachable: the next round follows Nexi\'s Retry-After up to a minute, or a pause that doubles up to a minute, each with jitter. After 5 minutes of pauses for one reason: an order write that keeps failing hands the charge to the till as its own order and alerts a person; a confirm Nexi keeps refusing (Nexi: confirm until the server takes it) and a Nexi that cannot be heard alert a person once and are asked on every minute, never given up. Answers 500 when the next round could not be booked, so Cloud Tasks runs this round again.
+     * @summary Internal: ask Nexi about a sale once more (Cloud Task callback)
+     * @param {NexiWaitRoundDto} nexiWaitRoundDto
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    waitForNexiSession(nexiWaitRoundDto: NexiWaitRoundDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
 };
 /**
  * PaymentSessionApi - factory interface
@@ -53588,6 +53751,15 @@ export declare const PaymentSessionApiFactory: (configuration?: Configuration, b
      * @throws {RequiredError}
      */
     initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: any): AxiosPromise<InitiateNetsSessionResponseDto>;
+    /**
+     * Saves the session first, its sessionId being the sale\'s external_id at Nexi, then asks Nexi to start the sale and answer at once. The customer then taps on the terminal; Cloud Tasks ask Nexi until the sale ends. When Nexi answers paid, in this order: Nexi\'s answer is kept on the session (the status unchanged), Nexi is confirmed (which takes the money), the session is stored SUCCESS, the payment is written on the order (reconciliation, which announces the settled order on the venue\'s channel), and only then SUCCESS is announced on the session\'s channel. So nothing tells the till \'paid\' before the money is taken. If the order cannot take the payment, it is asked again for up to 5 minutes, then the charge goes to the till as its own order and a person is alerted. Follow the session on the Ably channel nexi.<channel>.requests.<sessionId> (event payment:status-changed) or with GET /payment-session/:clientToken, which shows SUCCESS from the moment Nexi took the money. A tip or surcharge typed on the terminal is recorded from Nexi\'s answer. A Nexi sale is refused by :clientToken/cancel; Nexi\'s own cancel comes with a later route. Idempotent by the X-Idempotency-Key header within the venue: a repeat answers the session it started without asking Nexi again. A signed-in ticket only: the service key is not accepted (R27).
+     * @summary Start a card payment on the station\'s Nexi terminal
+     * @param {InitiateNexiSessionDto} initiateNexiSessionDto
+     * @param {string} [xIdempotencyKey] A UUID the app makes for this payment. A repeated key answers the session it started, without charging again.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    initiateNexiSession(initiateNexiSessionDto: InitiateNexiSessionDto, xIdempotencyKey?: string, options?: any): AxiosPromise<PaymentSessionViewDto>;
     /**
      * 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
@@ -53768,6 +53940,14 @@ export declare const PaymentSessionApiFactory: (configuration?: Configuration, b
      * @throws {RequiredError}
      */
     voidManualPayment(voidManualSessionDto: VoidManualSessionDto, options?: any): AxiosPromise<RecordManualPaymentResultDto>;
+    /**
+     * Called by a Cloud Task with the scheduler key, never by an app. Repeats a waiting sale\'s purchase at Nexi, which holds the question up to 25 seconds and answers the moment the customer finishes. Still at the terminal: the next round is booked at once; paused at Nexi: after a pause. Paid: Nexi\'s answer is kept, Nexi is confirmed, the sale is stored SUCCESS, written on the order, then announced. Not paid: the failure is confirmed at Nexi with its code, then recorded FAILED in the till\'s words and announced. A sale already stored paid is put on the order from what the session keeps: Nexi is not asked and no login is read. Nexi busy or unreachable: the next round follows Nexi\'s Retry-After up to a minute, or a pause that doubles up to a minute, each with jitter. After 5 minutes of pauses for one reason: an order write that keeps failing hands the charge to the till as its own order and alerts a person; a confirm Nexi keeps refusing (Nexi: confirm until the server takes it) and a Nexi that cannot be heard alert a person once and are asked on every minute, never given up. Answers 500 when the next round could not be booked, so Cloud Tasks runs this round again.
+     * @summary Internal: ask Nexi about a sale once more (Cloud Task callback)
+     * @param {NexiWaitRoundDto} nexiWaitRoundDto
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    waitForNexiSession(nexiWaitRoundDto: NexiWaitRoundDto, options?: any): AxiosPromise<void>;
 };
 /**
  * PaymentSessionApi - interface
@@ -53846,6 +54026,16 @@ export interface PaymentSessionApiInterface {
      * @memberof PaymentSessionApiInterface
      */
     initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): AxiosPromise<InitiateNetsSessionResponseDto>;
+    /**
+     * Saves the session first, its sessionId being the sale\'s external_id at Nexi, then asks Nexi to start the sale and answer at once. The customer then taps on the terminal; Cloud Tasks ask Nexi until the sale ends. When Nexi answers paid, in this order: Nexi\'s answer is kept on the session (the status unchanged), Nexi is confirmed (which takes the money), the session is stored SUCCESS, the payment is written on the order (reconciliation, which announces the settled order on the venue\'s channel), and only then SUCCESS is announced on the session\'s channel. So nothing tells the till \'paid\' before the money is taken. If the order cannot take the payment, it is asked again for up to 5 minutes, then the charge goes to the till as its own order and a person is alerted. Follow the session on the Ably channel nexi.<channel>.requests.<sessionId> (event payment:status-changed) or with GET /payment-session/:clientToken, which shows SUCCESS from the moment Nexi took the money. A tip or surcharge typed on the terminal is recorded from Nexi\'s answer. A Nexi sale is refused by :clientToken/cancel; Nexi\'s own cancel comes with a later route. Idempotent by the X-Idempotency-Key header within the venue: a repeat answers the session it started without asking Nexi again. A signed-in ticket only: the service key is not accepted (R27).
+     * @summary Start a card payment on the station\'s Nexi terminal
+     * @param {InitiateNexiSessionDto} initiateNexiSessionDto
+     * @param {string} [xIdempotencyKey] A UUID the app makes for this payment. A repeated key answers the session it started, without charging again.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    initiateNexiSession(initiateNexiSessionDto: InitiateNexiSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
     /**
      * 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
@@ -54048,6 +54238,15 @@ export interface PaymentSessionApiInterface {
      * @memberof PaymentSessionApiInterface
      */
     voidManualPayment(voidManualSessionDto: VoidManualSessionDto, options?: AxiosRequestConfig): AxiosPromise<RecordManualPaymentResultDto>;
+    /**
+     * Called by a Cloud Task with the scheduler key, never by an app. Repeats a waiting sale\'s purchase at Nexi, which holds the question up to 25 seconds and answers the moment the customer finishes. Still at the terminal: the next round is booked at once; paused at Nexi: after a pause. Paid: Nexi\'s answer is kept, Nexi is confirmed, the sale is stored SUCCESS, written on the order, then announced. Not paid: the failure is confirmed at Nexi with its code, then recorded FAILED in the till\'s words and announced. A sale already stored paid is put on the order from what the session keeps: Nexi is not asked and no login is read. Nexi busy or unreachable: the next round follows Nexi\'s Retry-After up to a minute, or a pause that doubles up to a minute, each with jitter. After 5 minutes of pauses for one reason: an order write that keeps failing hands the charge to the till as its own order and alerts a person; a confirm Nexi keeps refusing (Nexi: confirm until the server takes it) and a Nexi that cannot be heard alert a person once and are asked on every minute, never given up. Answers 500 when the next round could not be booked, so Cloud Tasks runs this round again.
+     * @summary Internal: ask Nexi about a sale once more (Cloud Task callback)
+     * @param {NexiWaitRoundDto} nexiWaitRoundDto
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    waitForNexiSession(nexiWaitRoundDto: NexiWaitRoundDto, options?: AxiosRequestConfig): AxiosPromise<void>;
 }
 /**
  * PaymentSessionApi - object-oriented interface
@@ -54127,6 +54326,16 @@ export declare class PaymentSessionApi extends BaseAPI implements PaymentSession
      * @memberof PaymentSessionApi
      */
     initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<InitiateNetsSessionResponseDto, any, {}>>;
+    /**
+     * Saves the session first, its sessionId being the sale\'s external_id at Nexi, then asks Nexi to start the sale and answer at once. The customer then taps on the terminal; Cloud Tasks ask Nexi until the sale ends. When Nexi answers paid, in this order: Nexi\'s answer is kept on the session (the status unchanged), Nexi is confirmed (which takes the money), the session is stored SUCCESS, the payment is written on the order (reconciliation, which announces the settled order on the venue\'s channel), and only then SUCCESS is announced on the session\'s channel. So nothing tells the till \'paid\' before the money is taken. If the order cannot take the payment, it is asked again for up to 5 minutes, then the charge goes to the till as its own order and a person is alerted. Follow the session on the Ably channel nexi.<channel>.requests.<sessionId> (event payment:status-changed) or with GET /payment-session/:clientToken, which shows SUCCESS from the moment Nexi took the money. A tip or surcharge typed on the terminal is recorded from Nexi\'s answer. A Nexi sale is refused by :clientToken/cancel; Nexi\'s own cancel comes with a later route. Idempotent by the X-Idempotency-Key header within the venue: a repeat answers the session it started without asking Nexi again. A signed-in ticket only: the service key is not accepted (R27).
+     * @summary Start a card payment on the station\'s Nexi terminal
+     * @param {InitiateNexiSessionDto} initiateNexiSessionDto
+     * @param {string} [xIdempotencyKey] A UUID the app makes for this payment. A repeated key answers the session it started, without charging again.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    initiateNexiSession(initiateNexiSessionDto: InitiateNexiSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<PaymentSessionViewDto, any, {}>>;
     /**
      * 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
@@ -54329,6 +54538,15 @@ export declare class PaymentSessionApi extends BaseAPI implements PaymentSession
      * @memberof PaymentSessionApi
      */
     voidManualPayment(voidManualSessionDto: VoidManualSessionDto, options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<RecordManualPaymentResultDto, any, {}>>;
+    /**
+     * Called by a Cloud Task with the scheduler key, never by an app. Repeats a waiting sale\'s purchase at Nexi, which holds the question up to 25 seconds and answers the moment the customer finishes. Still at the terminal: the next round is booked at once; paused at Nexi: after a pause. Paid: Nexi\'s answer is kept, Nexi is confirmed, the sale is stored SUCCESS, written on the order, then announced. Not paid: the failure is confirmed at Nexi with its code, then recorded FAILED in the till\'s words and announced. A sale already stored paid is put on the order from what the session keeps: Nexi is not asked and no login is read. Nexi busy or unreachable: the next round follows Nexi\'s Retry-After up to a minute, or a pause that doubles up to a minute, each with jitter. After 5 minutes of pauses for one reason: an order write that keeps failing hands the charge to the till as its own order and alerts a person; a confirm Nexi keeps refusing (Nexi: confirm until the server takes it) and a Nexi that cannot be heard alert a person once and are asked on every minute, never given up. Answers 500 when the next round could not be booked, so Cloud Tasks runs this round again.
+     * @summary Internal: ask Nexi about a sale once more (Cloud Task callback)
+     * @param {NexiWaitRoundDto} nexiWaitRoundDto
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    waitForNexiSession(nexiWaitRoundDto: NexiWaitRoundDto, options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any, {}>>;
 }
 /**
  * PrintersApi - axios parameter creator