@munchi_oy/core 2.21.0 → 2.22.0

package/generated/api.ts

@@ -16048,6 +16048,345 @@ export interface NexiConfigResponseDto {
      */
     'hasPassword': boolean;
 }
+/**
+ * 
+ * @export
+ * @interface NexiOnDeviceAnswerDto
+ */
+export interface NexiOnDeviceAnswerDto {
+    /**
+     * 
+     * @type {PoyntPaymentStatus}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'status': PoyntPaymentStatus;
+    /**
+     * The reference the payment app was given, read back from the transaction\'s references: the session\'s sessionId. Required on a sale\'s or a refund\'s approval, which is refused when it is not the session\'s. A decline or a cancel may come without it, and then only ends the wait. Not read on a revert: Poynt\'s void carries the sale\'s references.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'reference'?: string;
+    /**
+     * Poynt\'s `Transaction.id`. Required on an approval. On a sale or a refund it becomes the session\'s providerTransactionId, and one id settles one session only. On a revert it is the void\'s own transaction or the sale\'s, and it or parentId must be the sale\'s; it is kept in the stored answer only.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'transactionId'?: string;
+    /**
+     * Poynt\'s `Transaction.parentId`: on a void, the sale\'s transaction id. Absent on a sale, and on a refund, which Poynt does not link to its sale (a non-referenced refund).
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'parentId'?: string;
+    /**
+     * Poynt\'s `Transaction.status`. A sale\'s approval must carry CAPTURED, a refund\'s REFUNDED, a revert\'s VOIDED; any other is kept for ops and the session is not settled.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'transactionStatus'?: string;
+    /**
+     * Poynt\'s `Transaction.action` (SALE, REFUND). Kept in the stored answer, not checked.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'transactionAction'?: string;
+    /**
+     * Poynt\'s `Transaction.partiallyApproved`. An approval for part of the amount is kept for ops and the session is not settled. Absent reads as false.
+     * @type {boolean}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'partiallyApproved'?: boolean;
+    /**
+     * How many of the Payment\'s transactions Poynt approved. Absent or 1 is the normal case; 2 or more is kept for ops and the session is not settled.
+     * @type {number}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'approvedTransactionCount'?: number;
+    /**
+     * The currency charged, ISO 4217 alpha code (`amounts.currency`). Required on a sale\'s or a refund\'s approval, and must be the session\'s.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'currency'?: string;
+    /**
+     * What the card was charged or refunded, in cents (`amounts.transactionAmount`), tip included. Required on a sale\'s or a refund\'s approval: a sale\'s must be the session\'s amount plus its tip, a refund\'s the refund\'s amount. One that does not match is kept for ops and the session is not settled. Not checked on a revert, which gives back the whole sale.
+     * @type {number}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'transactionAmount'?: number;
+    /**
+     * The tip in `amounts.tipAmount`, in cents. Kept in the stored answer; the payment event\'s tip is the session\'s, since the payment app takes no tip of its own.
+     * @type {number}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'tipAmount'?: number;
+    /**
+     * The card brand, Poynt\'s `card.type`.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'cardType'?: string;
+    /**
+     * The card\'s first six digits (`card.numberFirst6`); they tell a benefit card. Six digits exactly.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'numberFirst6'?: string;
+    /**
+     * The card\'s last four digits (`card.numberLast4`). A refund whose card differs from the sale\'s is recorded and logged, never refused. Four digits exactly.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'numberLast4'?: string;
+    /**
+     * The issuer\'s approval code (`processorResponse.approvalCode`; Poynt\'s top-level `approvalCode` is null on the N950). Optional: shown on the payment event, never required.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'approvalCode'?: string;
+    /**
+     * The acquirer\'s retrieval reference number (`processorResponse.retrievalRefNum`).
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'retrievalRefNum'?: string;
+    /**
+     * `processorResponse.status`: Successful or Failure. Kept, not checked.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'processorStatus'?: string;
+    /**
+     * `processorResponse.statusMessage`: why a transaction failed, in Poynt\'s words. Stored, trimmed, as the session\'s errorMessage when the session ends without money; a blank one (the N950 sends a single space when it has none) is replaced by the server\'s own words.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'processorStatusMessage'?: string;
+    /**
+     * Nexi\'s own reference of the transaction (the `npay-reference-number` reference), as the Nexi portal shows it. Kept, not checked.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'nexiReferenceNumber'?: string;
+    /**
+     * When Poynt created the transaction, ISO 8601, as the device\'s clock says. Kept in the stored answer only; the payment event\'s time is the server\'s.
+     * @type {string}
+     * @memberof NexiOnDeviceAnswerDto
+     */
+    'createdAt'?: string;
+}
+
+
+/**
+ * 
+ * @export
+ * @interface NexiOnDeviceResultViewDto
+ */
+export interface NexiOnDeviceResultViewDto {
+    /**
+     * Opaque client token.
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'clientToken': string;
+    /**
+     * Internal session ID.
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'sessionId': string;
+    /**
+     * Viva transaction ID set after webhook completes.
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'providerTransactionId'?: string;
+    /**
+     * 
+     * @type {PaymentSessionStatus}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'status': PaymentSessionStatus;
+    /**
+     * Amount in cents.
+     * @type {number}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'amount': number;
+    /**
+     * Currency.
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'currency': string;
+    /**
+     * Tip amount (cents).
+     * @type {number}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'tipAmount': number;
+    /**
+     * Surcharge amount (cents).
+     * @type {number}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'surchargeAmount': number;
+    /**
+     * Error code if failed.
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'errorCode'?: string;
+    /**
+     * Error message if failed.
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'errorMessage'?: string;
+    /**
+     * When the session was started (ISO 8601, UTC).
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'createdAt': string;
+    /**
+     * When the session last changed (ISO 8601, UTC).
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'updatedAt': string;
+    /**
+     * When the sale was written to the order and closed (ISO 8601, UTC); null while it is not.
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'closedAt'?: string;
+    /**
+     * 
+     * @type {NexiOnDeviceResultViewDtoTransaction}
+     * @memberof NexiOnDeviceResultViewDto
+     */
+    'transaction'?: NexiOnDeviceResultViewDtoTransaction;
+}
+
+
+/**
+ * The payment event the order receives for this sale, built from the payment app\'s approval: the session\'s amount, the tip as a fee, the card\'s brand and masked number. Present while the session is a paid sale (SUCCESS or CLOSED), a repeated answer included; absent for a failure, a cancel, a refund or a revert.
+ * @export
+ * @interface NexiOnDeviceResultViewDtoTransaction
+ */
+export interface NexiOnDeviceResultViewDtoTransaction {
+    /**
+     * Id of this payment: the payment provider\'s transaction id for a card payment, or an id the till made
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'id': string;
+    /**
+     * The payment\'s reference: the provider\'s session or merchant reference for a card payment, or, on a reversal, the id of the payment it reverses; null when there is none
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'referenceId': string | null;
+    /**
+     * 
+     * @type {PaymentProvider}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'provider': PaymentProvider;
+    /**
+     * 
+     * @type {PaymentMethod}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'type': PaymentMethod;
+    /**
+     * 
+     * @type {PaymentOutcomeStatus}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'paymentOutcomeStatus'?: PaymentOutcomeStatus;
+    /**
+     * Amount paid in cents
+     * @type {number}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'amount': number;
+    /**
+     * Difference from cash rounding in cents
+     * @type {number}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'roundingDifference': number;
+    /**
+     * Raw data from payment provider, as it sent it
+     * @type {object}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'rawData': object;
+    /**
+     * When the payment was taken
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'createdAt': string;
+    /**
+     * 
+     * @type {TransactionDtoCardDetail}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'cardDetail': TransactionDtoCardDetail | null;
+    /**
+     * The monetary amount of the voucher value that was *not* used and *not* refunded to the customer (i.e., the overage). This is applicable only when a voucher is used and its value exceeds the order total.
+     * @type {number}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'voucherForfeitedAmount'?: number | null;
+    /**
+     * The specific line items this transaction paid for. If null or empty, it was a pooled payment against the total bill.
+     * @type {Array<string>}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'lineItemIds'?: Array<string> | null;
+    /**
+     * The specific split part this transaction paid for. If null, it was not a payment for a split part.
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'splitPartId'?: string | null;
+    /**
+     * Detailed settlement allocations for this transaction. Use this for accurate refund and reconciliation logic, especially when one line item is split across multiple payments.
+     * @type {Array<TransactionItemAllocationDto>}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'itemAllocations'?: Array<TransactionItemAllocationDto> | null;
+    /**
+     * 
+     * @type {TransactionDtoDevice}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'device'?: TransactionDtoDevice | null;
+    /**
+     * 
+     * @type {TransactionDtoCapturedBy}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'capturedBy'?: TransactionDtoCapturedBy | null;
+    /**
+     * Indicates whether this transaction was processed as a pre-authorization.
+     * @type {string}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'label': string | null;
+    /**
+     * 
+     * @type {TransactionDtoFees}
+     * @memberof NexiOnDeviceResultViewDtoTransaction
+     */
+    'fees'?: TransactionDtoFees | null;
+}
+
+
 /**
  * 
  * @export
@@ -18906,6 +19245,69 @@ export interface ParkPosOrderResponseDto {
      */
     'heldLineItems': number;
 }
+/**
+ * 
+ * @export
+ * @interface PartnerDto
+ */
+export interface PartnerDto {
+    /**
+     * The partner\'s id, which never changes: a provider row links to it, and an order keeps it with the partner\'s name and logo as they were when the order was saved
+     * @type {string}
+     * @memberof PartnerDto
+     */
+    'id': string;
+    /**
+     * The partner\'s key, which never changes once created: orders keep it. A platform Munchi connected before the partner standard has its channel name as key (Wolt, WoltStorefront, UberEats, Foodora, Bolt, ResQ); a partner on the partner standard a slug: words of lowercase letters and digits joined by single -, starting with a letter, 2 to 41 characters, that names no Munchi channel
+     * @type {string}
+     * @memberof PartnerDto
+     */
+    'key': string;
+    /**
+     * The partner\'s name as the apps show it
+     * @type {string}
+     * @memberof PartnerDto
+     */
+    'name': string;
+    /**
+     * The partner\'s logo, an https address; null when it has none
+     * @type {string}
+     * @memberof PartnerDto
+     */
+    'logoUrl': string | null;
+    /**
+     * Whether the partner is active
+     * @type {boolean}
+     * @memberof PartnerDto
+     */
+    'isActive': boolean;
+    /**
+     * When the partner was added, ISO 8601 in UTC
+     * @type {string}
+     * @memberof PartnerDto
+     */
+    'createdAt': string;
+    /**
+     * When the partner was last changed, ISO 8601 in UTC
+     * @type {string}
+     * @memberof PartnerDto
+     */
+    'updatedAt': string;
+}
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+
+export const PartnerWrite = {
+    Created: 'created',
+    Updated: 'updated'
+} as const;
+
+export type PartnerWrite = typeof PartnerWrite[keyof typeof PartnerWrite];
+
+
 /**
  * 
  * @export
@@ -24225,6 +24627,27 @@ export interface PosVivaMerchantDto {
      */
     'merchantId': string | null;
 }
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+
+export const PoyntPaymentStatus = {
+    Authorized: 'AUTHORIZED',
+    Canceled: 'CANCELED',
+    Completed: 'COMPLETED',
+    Declined: 'DECLINED',
+    Failed: 'FAILED',
+    Hold: 'HOLD',
+    ReadCardOnly: 'READ_CARD_ONLY',
+    Refunded: 'REFUNDED',
+    Voided: 'VOIDED'
+} as const;
+
+export type PoyntPaymentStatus = typeof PoyntPaymentStatus[keyof typeof PoyntPaymentStatus];
+
+
 /**
  * 
  * @export
@@ -27494,6 +27917,154 @@ export const RecordManualStatus = {
 export type RecordManualStatus = typeof RecordManualStatus[keyof typeof RecordManualStatus];
 
 
+/**
+ * 
+ * @export
+ * @interface RecordNexiOnDeviceResultDto
+ */
+export interface RecordNexiOnDeviceResultDto {
+    /**
+     * The sessionId the start, refund or revert route answered. A sale\'s and a refund\'s is the reference the payment app was given; a revert\'s names the reversal the void settles.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDto
+     */
+    'sessionId': string;
+    /**
+     * 
+     * @type {RecordNexiOnDeviceResultDtoAnswer}
+     * @memberof RecordNexiOnDeviceResultDto
+     */
+    'answer': RecordNexiOnDeviceResultDtoAnswer;
+}
+/**
+ * The payment app\'s answer, flattened from Poynt\'s Payment by the app.
+ * @export
+ * @interface RecordNexiOnDeviceResultDtoAnswer
+ */
+export interface RecordNexiOnDeviceResultDtoAnswer {
+    /**
+     * 
+     * @type {PoyntPaymentStatus}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'status': PoyntPaymentStatus;
+    /**
+     * The reference the payment app was given, read back from the transaction\'s references: the session\'s sessionId. Required on a sale\'s or a refund\'s approval, which is refused when it is not the session\'s. A decline or a cancel may come without it, and then only ends the wait. Not read on a revert: Poynt\'s void carries the sale\'s references.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'reference'?: string;
+    /**
+     * Poynt\'s `Transaction.id`. Required on an approval. On a sale or a refund it becomes the session\'s providerTransactionId, and one id settles one session only. On a revert it is the void\'s own transaction or the sale\'s, and it or parentId must be the sale\'s; it is kept in the stored answer only.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'transactionId'?: string;
+    /**
+     * Poynt\'s `Transaction.parentId`: on a void, the sale\'s transaction id. Absent on a sale, and on a refund, which Poynt does not link to its sale (a non-referenced refund).
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'parentId'?: string;
+    /**
+     * Poynt\'s `Transaction.status`. A sale\'s approval must carry CAPTURED, a refund\'s REFUNDED, a revert\'s VOIDED; any other is kept for ops and the session is not settled.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'transactionStatus'?: string;
+    /**
+     * Poynt\'s `Transaction.action` (SALE, REFUND). Kept in the stored answer, not checked.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'transactionAction'?: string;
+    /**
+     * Poynt\'s `Transaction.partiallyApproved`. An approval for part of the amount is kept for ops and the session is not settled. Absent reads as false.
+     * @type {boolean}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'partiallyApproved'?: boolean;
+    /**
+     * How many of the Payment\'s transactions Poynt approved. Absent or 1 is the normal case; 2 or more is kept for ops and the session is not settled.
+     * @type {number}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'approvedTransactionCount'?: number;
+    /**
+     * The currency charged, ISO 4217 alpha code (`amounts.currency`). Required on a sale\'s or a refund\'s approval, and must be the session\'s.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'currency'?: string;
+    /**
+     * What the card was charged or refunded, in cents (`amounts.transactionAmount`), tip included. Required on a sale\'s or a refund\'s approval: a sale\'s must be the session\'s amount plus its tip, a refund\'s the refund\'s amount. One that does not match is kept for ops and the session is not settled. Not checked on a revert, which gives back the whole sale.
+     * @type {number}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'transactionAmount'?: number;
+    /**
+     * The tip in `amounts.tipAmount`, in cents. Kept in the stored answer; the payment event\'s tip is the session\'s, since the payment app takes no tip of its own.
+     * @type {number}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'tipAmount'?: number;
+    /**
+     * The card brand, Poynt\'s `card.type`.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'cardType'?: string;
+    /**
+     * The card\'s first six digits (`card.numberFirst6`); they tell a benefit card. Six digits exactly.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'numberFirst6'?: string;
+    /**
+     * The card\'s last four digits (`card.numberLast4`). A refund whose card differs from the sale\'s is recorded and logged, never refused. Four digits exactly.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'numberLast4'?: string;
+    /**
+     * The issuer\'s approval code (`processorResponse.approvalCode`; Poynt\'s top-level `approvalCode` is null on the N950). Optional: shown on the payment event, never required.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'approvalCode'?: string;
+    /**
+     * The acquirer\'s retrieval reference number (`processorResponse.retrievalRefNum`).
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'retrievalRefNum'?: string;
+    /**
+     * `processorResponse.status`: Successful or Failure. Kept, not checked.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'processorStatus'?: string;
+    /**
+     * `processorResponse.statusMessage`: why a transaction failed, in Poynt\'s words. Stored, trimmed, as the session\'s errorMessage when the session ends without money; a blank one (the N950 sends a single space when it has none) is replaced by the server\'s own words.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'processorStatusMessage'?: string;
+    /**
+     * Nexi\'s own reference of the transaction (the `npay-reference-number` reference), as the Nexi portal shows it. Kept, not checked.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'nexiReferenceNumber'?: string;
+    /**
+     * When Poynt created the transaction, ISO 8601, as the device\'s clock says. Kept in the stored answer only; the payment event\'s time is the server\'s.
+     * @type {string}
+     * @memberof RecordNexiOnDeviceResultDtoAnswer
+     */
+    'createdAt'?: string;
+}
+
+
 /**
  * 
  * @export
@@ -32085,6 +32656,76 @@ export interface SaveEpassiCredentialsDto {
      */
     'posName': string;
 }
+/**
+ * 
+ * @export
+ * @interface SavedPartnerDto
+ */
+export interface SavedPartnerDto {
+    /**
+     * 
+     * @type {PartnerWrite}
+     * @memberof SavedPartnerDto
+     */
+    'write': PartnerWrite;
+    /**
+     * 
+     * @type {SavedPartnerDtoPartner}
+     * @memberof SavedPartnerDto
+     */
+    'partner': SavedPartnerDtoPartner;
+}
+
+
+/**
+ * The partner as it is after the save; its key is the one it was saved under, which a key asked in another case is changed to
+ * @export
+ * @interface SavedPartnerDtoPartner
+ */
+export interface SavedPartnerDtoPartner {
+    /**
+     * The partner\'s id, which never changes: a provider row links to it, and an order keeps it with the partner\'s name and logo as they were when the order was saved
+     * @type {string}
+     * @memberof SavedPartnerDtoPartner
+     */
+    'id': string;
+    /**
+     * The partner\'s key, which never changes once created: orders keep it. A platform Munchi connected before the partner standard has its channel name as key (Wolt, WoltStorefront, UberEats, Foodora, Bolt, ResQ); a partner on the partner standard a slug: words of lowercase letters and digits joined by single -, starting with a letter, 2 to 41 characters, that names no Munchi channel
+     * @type {string}
+     * @memberof SavedPartnerDtoPartner
+     */
+    'key': string;
+    /**
+     * The partner\'s name as the apps show it
+     * @type {string}
+     * @memberof SavedPartnerDtoPartner
+     */
+    'name': string;
+    /**
+     * The partner\'s logo, an https address; null when it has none
+     * @type {string}
+     * @memberof SavedPartnerDtoPartner
+     */
+    'logoUrl': string | null;
+    /**
+     * Whether the partner is active
+     * @type {boolean}
+     * @memberof SavedPartnerDtoPartner
+     */
+    'isActive': boolean;
+    /**
+     * When the partner was added, ISO 8601 in UTC
+     * @type {string}
+     * @memberof SavedPartnerDtoPartner
+     */
+    'createdAt': string;
+    /**
+     * When the partner was last changed, ISO 8601 in UTC
+     * @type {string}
+     * @memberof SavedPartnerDtoPartner
+     */
+    'updatedAt': string;
+}
 /**
  * 
  * @export
@@ -38906,6 +39547,31 @@ export interface UpsertNexiDto {
      */
     'password'?: string;
 }
+/**
+ * 
+ * @export
+ * @interface UpsertPartnerDto
+ */
+export interface UpsertPartnerDto {
+    /**
+     * The partner\'s name as the apps show it, 1 to 60 characters once the spaces around it are removed
+     * @type {string}
+     * @memberof UpsertPartnerDto
+     */
+    'name': string;
+    /**
+     * The partner\'s logo, an https address of at most 2048 characters (Munchi keeps its logos on Google Cloud Storage). null removes it; absent: a new partner has none, and a partner already there keeps its own
+     * @type {string}
+     * @memberof UpsertPartnerDto
+     */
+    'logoUrl'?: string | null;
+    /**
+     * Whether the partner is active. Absent: a new partner is active, and a partner already there keeps its own
+     * @type {boolean}
+     * @memberof UpsertPartnerDto
+     */
+    'isActive'?: boolean;
+}
 /**
  * 
  * @export
@@ -39577,11 +40243,17 @@ export interface VendureSellerUpsertDto {
      */
     'enabled': boolean;
     /**
-     * The Clerk user ids of the venue\'s owners. Each is trimmed and added to the owners the venue has; none is ever removed. An empty list or none keeps them as they are
+     * The Clerk user ids of the venue\'s owners. Each is trimmed and added to the owners the venue has; an owner is removed only when owners_removed lists it. An empty list or none keeps them as they are
      * @type {Array<string>}
      * @memberof VendureSellerUpsertDto
      */
     'owners'?: Array<string>;
+    /**
+     * The owner keys Vendure removed from the venue in this change: a Clerk user\'s externalId or a Clerk user id. Each is trimmed and removed from the owners the venue has, unless owners sends it too; an owner not listed here is never removed. Absent or empty means nothing was removed. Vendure builds from before its remove-owner route never send it
+     * @type {Array<string>}
+     * @memberof VendureSellerUpsertDto
+     */
+    'owners_removed'?: Array<string>;
     /**
      * The venue\'s opening hours, seven days Sunday first, stored on the venue as sent: each day { enabled, lapses: [{ open: { hour, minute }, close: { hour, minute } }] }. Only checked to be a list. An empty list or none keeps the stored schedule
      * @type {Array<object>}
@@ -59749,6 +60421,40 @@ export const OpsApiAxiosParamCreator = function (configuration?: Configuration)
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * The partner directory: every delivery platform Munchi works with, active or not, by key, with its name and logo. Read from the cache, which a save clears.
+         * @summary Every delivery partner, by key
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listPartners: async (options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/v1/ops/partners`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication JWT-auth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -59839,6 +60545,50 @@ export const OpsApiAxiosParamCreator = function (configuration?: Configuration)
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
 
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Creates the partner under the key, or changes the one there. The key itself never changes: orders keep it. A platform Munchi connected before the partner standard uses its channel name as key. The key is read in any case and saved as a platform\'s channel name (wolt as Wolt) or in lowercase (Fin-Delivery as fin-delivery); the answer\'s partner.key is the key saved. Only the fields sent change a partner already there. The directory\'s cache is cleared after the save.
+         * @summary Add a delivery partner, or change its name, logo or active state
+         * @param {string} key The partner\&#39;s key
+         * @param {UpsertPartnerDto} upsertPartnerDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        upsertPartner: async (key: string, upsertPartnerDto: UpsertPartnerDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'key' is not null or undefined
+            assertParamExists('upsertPartner', 'key', key)
+            // verify required parameter 'upsertPartnerDto' is not null or undefined
+            assertParamExists('upsertPartner', 'upsertPartnerDto', upsertPartnerDto)
+            const localVarPath = `/api/v1/ops/partners/{key}`
+                .replace(`{${"key"}}`, encodeURIComponent(String(key)));
+            // 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: 'PUT', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication JWT-auth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(upsertPartnerDto, localVarRequestOptions, configuration)
+
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -59889,6 +60639,16 @@ export const OpsApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.disconnectDeliveryPlatform(venueId, channel, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * The partner directory: every delivery platform Munchi works with, active or not, by key, with its name and logo. Read from the cache, which a save clears.
+         * @summary Every delivery partner, by key
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async listPartners(options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<PartnerDto>>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listPartners(options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Undoes what licences turned off. Per venue, by venue id: turns on the provider rows the licence turned off that are still there and still off, and empties the hold. A dry run unless dryRun is false; call again until holdsLeft is 0. The next unpaid event turns the rows off again.
          * @summary Turn back on the kiosk and online store rows licence enforcement turned off
@@ -59912,6 +60672,18 @@ export const OpsApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.searchVenues(search, limit, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Creates the partner under the key, or changes the one there. The key itself never changes: orders keep it. A platform Munchi connected before the partner standard uses its channel name as key. The key is read in any case and saved as a platform\'s channel name (wolt as Wolt) or in lowercase (Fin-Delivery as fin-delivery); the answer\'s partner.key is the key saved. Only the fields sent change a partner already there. The directory\'s cache is cleared after the save.
+         * @summary Add a delivery partner, or change its name, logo or active state
+         * @param {string} key The partner\&#39;s key
+         * @param {UpsertPartnerDto} upsertPartnerDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async upsertPartner(key: string, upsertPartnerDto: UpsertPartnerDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SavedPartnerDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.upsertPartner(key, upsertPartnerDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
     }
 };
 
@@ -59954,6 +60726,15 @@ export const OpsApiFactory = function (configuration?: Configuration, basePath?:
         disconnectDeliveryPlatform(venueId: number, channel: DeliveryPlatformOpsConnect, options?: any): AxiosPromise<DisconnectedDeliveryPlatformDto> {
             return localVarFp.disconnectDeliveryPlatform(venueId, channel, options).then((request) => request(axios, basePath));
         },
+        /**
+         * The partner directory: every delivery platform Munchi works with, active or not, by key, with its name and logo. Read from the cache, which a save clears.
+         * @summary Every delivery partner, by key
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listPartners(options?: any): AxiosPromise<Array<PartnerDto>> {
+            return localVarFp.listPartners(options).then((request) => request(axios, basePath));
+        },
         /**
          * Undoes what licences turned off. Per venue, by venue id: turns on the provider rows the licence turned off that are still there and still off, and empties the hold. A dry run unless dryRun is false; call again until holdsLeft is 0. The next unpaid event turns the rows off again.
          * @summary Turn back on the kiosk and online store rows licence enforcement turned off
@@ -59975,6 +60756,17 @@ export const OpsApiFactory = function (configuration?: Configuration, basePath?:
         searchVenues(search: string, limit?: number, options?: any): AxiosPromise<Array<VenueFoundDto>> {
             return localVarFp.searchVenues(search, limit, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Creates the partner under the key, or changes the one there. The key itself never changes: orders keep it. A platform Munchi connected before the partner standard uses its channel name as key. The key is read in any case and saved as a platform\'s channel name (wolt as Wolt) or in lowercase (Fin-Delivery as fin-delivery); the answer\'s partner.key is the key saved. Only the fields sent change a partner already there. The directory\'s cache is cleared after the save.
+         * @summary Add a delivery partner, or change its name, logo or active state
+         * @param {string} key The partner\&#39;s key
+         * @param {UpsertPartnerDto} upsertPartnerDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        upsertPartner(key: string, upsertPartnerDto: UpsertPartnerDto, options?: any): AxiosPromise<SavedPartnerDto> {
+            return localVarFp.upsertPartner(key, upsertPartnerDto, options).then((request) => request(axios, basePath));
+        },
     };
 };
 
@@ -60016,6 +60808,15 @@ export interface OpsApiInterface {
      */
     disconnectDeliveryPlatform(venueId: number, channel: DeliveryPlatformOpsConnect, options?: AxiosRequestConfig): AxiosPromise<DisconnectedDeliveryPlatformDto>;
 
+    /**
+     * The partner directory: every delivery platform Munchi works with, active or not, by key, with its name and logo. Read from the cache, which a save clears.
+     * @summary Every delivery partner, by key
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof OpsApiInterface
+     */
+    listPartners(options?: AxiosRequestConfig): AxiosPromise<Array<PartnerDto>>;
+
     /**
      * Undoes what licences turned off. Per venue, by venue id: turns on the provider rows the licence turned off that are still there and still off, and empties the hold. A dry run unless dryRun is false; call again until holdsLeft is 0. The next unpaid event turns the rows off again.
      * @summary Turn back on the kiosk and online store rows licence enforcement turned off
@@ -60037,6 +60838,17 @@ export interface OpsApiInterface {
      */
     searchVenues(search: string, limit?: number, options?: AxiosRequestConfig): AxiosPromise<Array<VenueFoundDto>>;
 
+    /**
+     * Creates the partner under the key, or changes the one there. The key itself never changes: orders keep it. A platform Munchi connected before the partner standard uses its channel name as key. The key is read in any case and saved as a platform\'s channel name (wolt as Wolt) or in lowercase (Fin-Delivery as fin-delivery); the answer\'s partner.key is the key saved. Only the fields sent change a partner already there. The directory\'s cache is cleared after the save.
+     * @summary Add a delivery partner, or change its name, logo or active state
+     * @param {string} key The partner\&#39;s key
+     * @param {UpsertPartnerDto} upsertPartnerDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof OpsApiInterface
+     */
+    upsertPartner(key: string, upsertPartnerDto: UpsertPartnerDto, options?: AxiosRequestConfig): AxiosPromise<SavedPartnerDto>;
+
 }
 
 /**
@@ -60084,6 +60896,17 @@ export class OpsApi extends BaseAPI implements OpsApiInterface {
         return OpsApiFp(this.configuration).disconnectDeliveryPlatform(venueId, channel, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * The partner directory: every delivery platform Munchi works with, active or not, by key, with its name and logo. Read from the cache, which a save clears.
+     * @summary Every delivery partner, by key
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof OpsApi
+     */
+    public listPartners(options?: AxiosRequestConfig) {
+        return OpsApiFp(this.configuration).listPartners(options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Undoes what licences turned off. Per venue, by venue id: turns on the provider rows the licence turned off that are still there and still off, and empties the hold. A dry run unless dryRun is false; call again until holdsLeft is 0. The next unpaid event turns the rows off again.
      * @summary Turn back on the kiosk and online store rows licence enforcement turned off
@@ -60108,6 +60931,19 @@ export class OpsApi extends BaseAPI implements OpsApiInterface {
     public searchVenues(search: string, limit?: number, options?: AxiosRequestConfig) {
         return OpsApiFp(this.configuration).searchVenues(search, limit, options).then((request) => request(this.axios, this.basePath));
     }
+
+    /**
+     * Creates the partner under the key, or changes the one there. The key itself never changes: orders keep it. A platform Munchi connected before the partner standard uses its channel name as key. The key is read in any case and saved as a platform\'s channel name (wolt as Wolt) or in lowercase (Fin-Delivery as fin-delivery); the answer\'s partner.key is the key saved. Only the fields sent change a partner already there. The directory\'s cache is cleared after the save.
+     * @summary Add a delivery partner, or change its name, logo or active state
+     * @param {string} key The partner\&#39;s key
+     * @param {UpsertPartnerDto} upsertPartnerDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof OpsApi
+     */
+    public upsertPartner(key: string, upsertPartnerDto: UpsertPartnerDto, options?: AxiosRequestConfig) {
+        return OpsApiFp(this.configuration).upsertPartner(key, upsertPartnerDto, options).then((request) => request(this.axios, this.basePath));
+    }
 }
 
 
@@ -64625,6 +65461,47 @@ export const PaymentSessionApiAxiosParamCreator = function (configuration?: Conf
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Stores a DISPATCHED Nexi session for a sale the device\'s own payment app (Poynt, on the Newland N950) will take. Its sessionId is the reference the payment app is given; the device then reports the app\'s answer to nexi/on-device/result, and the server writes the order. Refused for a venue whose channel does not pay by Nexi. Nexi is not called, nothing follows the session, and it is never cancelled through :clientToken/cancel. Idempotent via X-Idempotency-Key. A signed-in ticket only.
+         * @summary Start a Nexi sale on the device\'s own card reader
+         * @param {InitiateWorldlineA2aSessionDto} initiateWorldlineA2aSessionDto 
+         * @param {string} [xIdempotencyKey] Client-generated UUID. A key this venue\&#39;s on-device sale already holds answers that sale as it stands; a key any other payment holds is refused.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        initiateNexiOnDeviceSession: async (initiateWorldlineA2aSessionDto: InitiateWorldlineA2aSessionDto, xIdempotencyKey?: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'initiateWorldlineA2aSessionDto' is not null or undefined
+            assertParamExists('initiateNexiOnDeviceSession', 'initiateWorldlineA2aSessionDto', initiateWorldlineA2aSessionDto)
+            const localVarPath = `/api/v1/payment-session/nexi/on-device`;
+            // 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(initiateWorldlineA2aSessionDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * 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. POST /payment-session/:clientToken/cancel cancels it as Nexi documents it, a confirm as failed; the outcome is still Nexi\'s answer, so a sale Nexi was already confirmed paid for ends paid. 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
@@ -65044,6 +65921,42 @@ export const PaymentSessionApiAxiosParamCreator = function (configuration?: Conf
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Settles an on-device Nexi sale, refund or revert with Poynt\'s answer, decided by Poynt\'s payment status. COMPLETED makes a sale SUCCESS, REFUNDED makes a refund REFUNDED, VOIDED makes a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. DECLINED makes it FAILED (payment.declined), CANCELED makes it CANCELLED, FAILED makes it FAILED. A sale\'s or a refund\'s answer carries the session\'s sessionId as its reference, except a decline or a cancel, which may come without one; a revert\'s names the sale\'s Poynt transaction as its transactionId or parentId. An approval may replace a failure or a cancel (a payment recovered after the app was killed); an end without money replaces only the wait. An answer that may have moved money but cannot be recorded (AUTHORIZED, HOLD, READ_CARD_ONLY, another kind\'s approval, a partial approval, several approvals, another amount or currency) is kept on the session, which stays DISPATCHED, ops are alerted, and the request is refused. A refund to another card than the sale\'s is recorded and logged. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
+         * @summary Record the device\'s payment app answer for an on-device Nexi session
+         * @param {RecordNexiOnDeviceResultDto} recordNexiOnDeviceResultDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        recordNexiOnDeviceResult: async (recordNexiOnDeviceResultDto: RecordNexiOnDeviceResultDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'recordNexiOnDeviceResultDto' is not null or undefined
+            assertParamExists('recordNexiOnDeviceResult', 'recordNexiOnDeviceResultDto', recordNexiOnDeviceResultDto)
+            const localVarPath = `/api/v1/payment-session/nexi/on-device/result`;
+            // 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(recordNexiOnDeviceResultDto, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Settles a handheld Worldline sale, refund or revert with the payment app\'s answer (WPI_RESPONSE). A sale\'s or a refund\'s approval carries the session\'s sessionId as its reference, and so does its decline, except that WPI may answer a decline or a cancel without one; a revert\'s (WPI_SVC_CANCEL_PAYMENT) carries none and names the sale\'s paymentSolutionReference instead. An approval makes a sale SUCCESS, a refund REFUNDED and a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. A sale\'s approval may carry a tip the cardholder added on the payment app: it is recorded with the session\'s tip. A failure makes it FAILED, or CANCELLED when the app reports WPI_ERR_COND_USER_CANCEL. An approval may replace a failure; a failure never replaces anything. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
          * @summary Record the Worldline payment app\'s answer for a handheld session
@@ -65140,6 +66053,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,
+            };
+        },
+        /**
+         * Stores a DISPATCHED refund session for the amount asked (what is left of the sale when none is), within what is left of the sale. Only a sale the device\'s own card reader took is accepted. The device then makes the refund on its payment app with the card presented (Poynt\'s non-referenced refund) and the refund\'s sessionId as its reference, and reports the answer to nexi/on-device/result. Does NOT write a reversal onto the order: the refund plan records it. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+         * @summary Start a card refund of an on-device Nexi sale
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refundNexiOnDeviceSession: async (reverseSessionDto: ReverseSessionDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'reverseSessionDto' is not null or undefined
+            assertParamExists('refundNexiOnDeviceSession', 'reverseSessionDto', reverseSessionDto)
+            const localVarPath = `/api/v1/payment-session/nexi/on-device/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);
@@ -65361,6 +66310,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,
+            };
+        },
+        /**
+         * Stores a DISPATCHED reversal session for the whole sale. Only a sale the device\'s own card reader took is accepted. The device then voids the sale on its payment app with no card (Poynt\'s void, by the sale\'s transaction id, which is the payment event\'s id) and reports the answer, with the reversal\'s sessionId, to nexi/on-device/result; once VOIDED, reconciliation writes the reversal onto the order. The server alone decides whether the sale may still be voided: up to 55 minutes after the sale was started, never on a closed order, and never once the sale has refund activity. `amount` is ignored: a void gives back the whole sale. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+         * @summary Start a revert (void) of an on-device Nexi sale
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        revertNexiOnDeviceSession: async (reverseSessionDto: ReverseSessionDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'reverseSessionDto' is not null or undefined
+            assertParamExists('revertNexiOnDeviceSession', 'reverseSessionDto', reverseSessionDto)
+            const localVarPath = `/api/v1/payment-session/nexi/on-device/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);
@@ -65684,6 +66669,18 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.initiateNetsSession(initiateNetsSessionDto, xIdempotencyKey, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Stores a DISPATCHED Nexi session for a sale the device\'s own payment app (Poynt, on the Newland N950) will take. Its sessionId is the reference the payment app is given; the device then reports the app\'s answer to nexi/on-device/result, and the server writes the order. Refused for a venue whose channel does not pay by Nexi. Nexi is not called, nothing follows the session, and it is never cancelled through :clientToken/cancel. Idempotent via X-Idempotency-Key. A signed-in ticket only.
+         * @summary Start a Nexi sale on the device\'s own card reader
+         * @param {InitiateWorldlineA2aSessionDto} initiateWorldlineA2aSessionDto 
+         * @param {string} [xIdempotencyKey] Client-generated UUID. A key this venue\&#39;s on-device sale already holds answers that sale as it stands; a key any other payment holds is refused.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async initiateNexiOnDeviceSession(initiateWorldlineA2aSessionDto: InitiateWorldlineA2aSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PaymentSessionViewDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.initiateNexiOnDeviceSession(initiateWorldlineA2aSessionDto, xIdempotencyKey, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * 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. POST /payment-session/:clientToken/cancel cancels it as Nexi documents it, a confirm as failed; the outcome is still Nexi\'s answer, so a sale Nexi was already confirmed paid for ends paid. 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
@@ -65810,6 +66807,17 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.recordManualPayment(createManualSessionDto, xIdempotencyKey, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Settles an on-device Nexi sale, refund or revert with Poynt\'s answer, decided by Poynt\'s payment status. COMPLETED makes a sale SUCCESS, REFUNDED makes a refund REFUNDED, VOIDED makes a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. DECLINED makes it FAILED (payment.declined), CANCELED makes it CANCELLED, FAILED makes it FAILED. A sale\'s or a refund\'s answer carries the session\'s sessionId as its reference, except a decline or a cancel, which may come without one; a revert\'s names the sale\'s Poynt transaction as its transactionId or parentId. An approval may replace a failure or a cancel (a payment recovered after the app was killed); an end without money replaces only the wait. An answer that may have moved money but cannot be recorded (AUTHORIZED, HOLD, READ_CARD_ONLY, another kind\'s approval, a partial approval, several approvals, another amount or currency) is kept on the session, which stays DISPATCHED, ops are alerted, and the request is refused. A refund to another card than the sale\'s is recorded and logged. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
+         * @summary Record the device\'s payment app answer for an on-device Nexi session
+         * @param {RecordNexiOnDeviceResultDto} recordNexiOnDeviceResultDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async recordNexiOnDeviceResult(recordNexiOnDeviceResultDto: RecordNexiOnDeviceResultDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<NexiOnDeviceResultViewDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.recordNexiOnDeviceResult(recordNexiOnDeviceResultDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Settles a handheld Worldline sale, refund or revert with the payment app\'s answer (WPI_RESPONSE). A sale\'s or a refund\'s approval carries the session\'s sessionId as its reference, and so does its decline, except that WPI may answer a decline or a cancel without one; a revert\'s (WPI_SVC_CANCEL_PAYMENT) carries none and names the sale\'s paymentSolutionReference instead. An approval makes a sale SUCCESS, a refund REFUNDED and a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. A sale\'s approval may carry a tip the cardholder added on the payment app: it is recorded with the session\'s tip. A failure makes it FAILED, or CANCELLED when the app reports WPI_ERR_COND_USER_CANCEL. An approval may replace a failure; a failure never replaces anything. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
          * @summary Record the Worldline payment app\'s answer for a handheld session
@@ -65843,6 +66851,17 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.refundNetsSession(reverseSessionDto, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Stores a DISPATCHED refund session for the amount asked (what is left of the sale when none is), within what is left of the sale. Only a sale the device\'s own card reader took is accepted. The device then makes the refund on its payment app with the card presented (Poynt\'s non-referenced refund) and the refund\'s sessionId as its reference, and reports the answer to nexi/on-device/result. Does NOT write a reversal onto the order: the refund plan records it. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+         * @summary Start a card refund of an on-device Nexi sale
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async refundNexiOnDeviceSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PaymentSessionViewDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.refundNexiOnDeviceSession(reverseSessionDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Stores a refund session for the amount asked (what is left of the sale when none is), within what is left of the sale, then asks Nexi for a customer-not-present refund of the sale on the sale\'s own terminal: the customer needs no card and the terminal shows nothing. Nexi\'s answer decides: Nexi made it → our confirm, then REFUNDED; Nexi ended it unpaid → FAILED and refused; Nexi still processing → the session waits and Cloud Tasks follow it until Nexi answers. Does NOT write a reversal onto the order: the refund plan records it, as for Viva and Nets. Idempotent by the X-Idempotency-Key header within the venue: a repeat answers the refund it started, as it stands, without asking Nexi again. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
          * @summary Refund a paid Nexi sale, customer not present, with no card
@@ -65910,6 +66929,17 @@ export const PaymentSessionApiFp = function(configuration?: Configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.revertNetsSession(reverseSessionDto, options);
             return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
         },
+        /**
+         * Stores a DISPATCHED reversal session for the whole sale. Only a sale the device\'s own card reader took is accepted. The device then voids the sale on its payment app with no card (Poynt\'s void, by the sale\'s transaction id, which is the payment event\'s id) and reports the answer, with the reversal\'s sessionId, to nexi/on-device/result; once VOIDED, reconciliation writes the reversal onto the order. The server alone decides whether the sale may still be voided: up to 55 minutes after the sale was started, never on a closed order, and never once the sale has refund activity. `amount` is ignored: a void gives back the whole sale. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+         * @summary Start a revert (void) of an on-device Nexi sale
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async revertNexiOnDeviceSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PaymentSessionViewDto>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.revertNexiOnDeviceSession(reverseSessionDto, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
         /**
          * Reads the sale at Nexi and picks the way itself, so the till decides nothing by time: within Nexi\'s hour after the sale (CONFIRMED) and with nothing refunded yet, the sale is confirmed as failed again and everything goes back; once Nexi committed it (COMMITTED, after the hour or after a refund), a customer-not-present refund gives back what is left. A confirm Nexi refuses because the hour ended in between is read again and refunded instead. A sale Nexi already holds unpaid while our record calls it paid is recorded as given back. A confirm Nexi does not answer is never recorded as failed: the revert is kept, counted against the sale, and Cloud Task rounds settle it from Nexi\'s record of the sale: given back once Nexi holds it unpaid; the confirm as failed sent again while Nexi holds it confirmed paid; a refund of what is left once Nexi committed it paid. No card either way. Once Nexi gave the money back, the session is REFUNDING and reconciliation writes the reversal onto the order, then REFUNDED. `amount` is ignored: a revert gives back what is left. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
          * @summary Revert a paid Nexi sale: give back what is left and write the reversal onto the order
@@ -66064,6 +67094,17 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: any): AxiosPromise<InitiateNetsSessionResponseDto> {
             return localVarFp.initiateNetsSession(initiateNetsSessionDto, xIdempotencyKey, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Stores a DISPATCHED Nexi session for a sale the device\'s own payment app (Poynt, on the Newland N950) will take. Its sessionId is the reference the payment app is given; the device then reports the app\'s answer to nexi/on-device/result, and the server writes the order. Refused for a venue whose channel does not pay by Nexi. Nexi is not called, nothing follows the session, and it is never cancelled through :clientToken/cancel. Idempotent via X-Idempotency-Key. A signed-in ticket only.
+         * @summary Start a Nexi sale on the device\'s own card reader
+         * @param {InitiateWorldlineA2aSessionDto} initiateWorldlineA2aSessionDto 
+         * @param {string} [xIdempotencyKey] Client-generated UUID. A key this venue\&#39;s on-device sale already holds answers that sale as it stands; a key any other payment holds is refused.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        initiateNexiOnDeviceSession(initiateWorldlineA2aSessionDto: InitiateWorldlineA2aSessionDto, xIdempotencyKey?: string, options?: any): AxiosPromise<PaymentSessionViewDto> {
+            return localVarFp.initiateNexiOnDeviceSession(initiateWorldlineA2aSessionDto, xIdempotencyKey, options).then((request) => request(axios, basePath));
+        },
         /**
          * 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. POST /payment-session/:clientToken/cancel cancels it as Nexi documents it, a confirm as failed; the outcome is still Nexi\'s answer, so a sale Nexi was already confirmed paid for ends paid. 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
@@ -66179,6 +67220,16 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         recordManualPayment(createManualSessionDto: CreateManualSessionDto, xIdempotencyKey?: string, options?: any): AxiosPromise<RecordManualPaymentResultDto> {
             return localVarFp.recordManualPayment(createManualSessionDto, xIdempotencyKey, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Settles an on-device Nexi sale, refund or revert with Poynt\'s answer, decided by Poynt\'s payment status. COMPLETED makes a sale SUCCESS, REFUNDED makes a refund REFUNDED, VOIDED makes a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. DECLINED makes it FAILED (payment.declined), CANCELED makes it CANCELLED, FAILED makes it FAILED. A sale\'s or a refund\'s answer carries the session\'s sessionId as its reference, except a decline or a cancel, which may come without one; a revert\'s names the sale\'s Poynt transaction as its transactionId or parentId. An approval may replace a failure or a cancel (a payment recovered after the app was killed); an end without money replaces only the wait. An answer that may have moved money but cannot be recorded (AUTHORIZED, HOLD, READ_CARD_ONLY, another kind\'s approval, a partial approval, several approvals, another amount or currency) is kept on the session, which stays DISPATCHED, ops are alerted, and the request is refused. A refund to another card than the sale\'s is recorded and logged. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
+         * @summary Record the device\'s payment app answer for an on-device Nexi session
+         * @param {RecordNexiOnDeviceResultDto} recordNexiOnDeviceResultDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        recordNexiOnDeviceResult(recordNexiOnDeviceResultDto: RecordNexiOnDeviceResultDto, options?: any): AxiosPromise<NexiOnDeviceResultViewDto> {
+            return localVarFp.recordNexiOnDeviceResult(recordNexiOnDeviceResultDto, options).then((request) => request(axios, basePath));
+        },
         /**
          * Settles a handheld Worldline sale, refund or revert with the payment app\'s answer (WPI_RESPONSE). A sale\'s or a refund\'s approval carries the session\'s sessionId as its reference, and so does its decline, except that WPI may answer a decline or a cancel without one; a revert\'s (WPI_SVC_CANCEL_PAYMENT) carries none and names the sale\'s paymentSolutionReference instead. An approval makes a sale SUCCESS, a refund REFUNDED and a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. A sale\'s approval may carry a tip the cardholder added on the payment app: it is recorded with the session\'s tip. A failure makes it FAILED, or CANCELLED when the app reports WPI_ERR_COND_USER_CANCEL. An approval may replace a failure; a failure never replaces anything. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
          * @summary Record the Worldline payment app\'s answer for a handheld session
@@ -66209,6 +67260,16 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         refundNetsSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<PaymentSessionViewDto> {
             return localVarFp.refundNetsSession(reverseSessionDto, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Stores a DISPATCHED refund session for the amount asked (what is left of the sale when none is), within what is left of the sale. Only a sale the device\'s own card reader took is accepted. The device then makes the refund on its payment app with the card presented (Poynt\'s non-referenced refund) and the refund\'s sessionId as its reference, and reports the answer to nexi/on-device/result. Does NOT write a reversal onto the order: the refund plan records it. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+         * @summary Start a card refund of an on-device Nexi sale
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refundNexiOnDeviceSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<PaymentSessionViewDto> {
+            return localVarFp.refundNexiOnDeviceSession(reverseSessionDto, options).then((request) => request(axios, basePath));
+        },
         /**
          * Stores a refund session for the amount asked (what is left of the sale when none is), within what is left of the sale, then asks Nexi for a customer-not-present refund of the sale on the sale\'s own terminal: the customer needs no card and the terminal shows nothing. Nexi\'s answer decides: Nexi made it → our confirm, then REFUNDED; Nexi ended it unpaid → FAILED and refused; Nexi still processing → the session waits and Cloud Tasks follow it until Nexi answers. Does NOT write a reversal onto the order: the refund plan records it, as for Viva and Nets. Idempotent by the X-Idempotency-Key header within the venue: a repeat answers the refund it started, as it stands, without asking Nexi again. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
          * @summary Refund a paid Nexi sale, customer not present, with no card
@@ -66270,6 +67331,16 @@ export const PaymentSessionApiFactory = function (configuration?: Configuration,
         revertNetsSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<NetsRevertResponseDto> {
             return localVarFp.revertNetsSession(reverseSessionDto, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Stores a DISPATCHED reversal session for the whole sale. Only a sale the device\'s own card reader took is accepted. The device then voids the sale on its payment app with no card (Poynt\'s void, by the sale\'s transaction id, which is the payment event\'s id) and reports the answer, with the reversal\'s sessionId, to nexi/on-device/result; once VOIDED, reconciliation writes the reversal onto the order. The server alone decides whether the sale may still be voided: up to 55 minutes after the sale was started, never on a closed order, and never once the sale has refund activity. `amount` is ignored: a void gives back the whole sale. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+         * @summary Start a revert (void) of an on-device Nexi sale
+         * @param {ReverseSessionDto} reverseSessionDto 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        revertNexiOnDeviceSession(reverseSessionDto: ReverseSessionDto, options?: any): AxiosPromise<PaymentSessionViewDto> {
+            return localVarFp.revertNexiOnDeviceSession(reverseSessionDto, options).then((request) => request(axios, basePath));
+        },
         /**
          * Reads the sale at Nexi and picks the way itself, so the till decides nothing by time: within Nexi\'s hour after the sale (CONFIRMED) and with nothing refunded yet, the sale is confirmed as failed again and everything goes back; once Nexi committed it (COMMITTED, after the hour or after a refund), a customer-not-present refund gives back what is left. A confirm Nexi refuses because the hour ended in between is read again and refunded instead. A sale Nexi already holds unpaid while our record calls it paid is recorded as given back. A confirm Nexi does not answer is never recorded as failed: the revert is kept, counted against the sale, and Cloud Task rounds settle it from Nexi\'s record of the sale: given back once Nexi holds it unpaid; the confirm as failed sent again while Nexi holds it confirmed paid; a refund of what is left once Nexi committed it paid. No card either way. Once Nexi gave the money back, the session is REFUNDING and reconciliation writes the reversal onto the order, then REFUNDED. `amount` is ignored: a revert gives back what is left. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
          * @summary Revert a paid Nexi sale: give back what is left and write the reversal onto the order
@@ -66417,6 +67488,17 @@ export interface PaymentSessionApiInterface {
      */
     initiateNetsSession(initiateNetsSessionDto: InitiateNetsSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): AxiosPromise<InitiateNetsSessionResponseDto>;
 
+    /**
+     * Stores a DISPATCHED Nexi session for a sale the device\'s own payment app (Poynt, on the Newland N950) will take. Its sessionId is the reference the payment app is given; the device then reports the app\'s answer to nexi/on-device/result, and the server writes the order. Refused for a venue whose channel does not pay by Nexi. Nexi is not called, nothing follows the session, and it is never cancelled through :clientToken/cancel. Idempotent via X-Idempotency-Key. A signed-in ticket only.
+     * @summary Start a Nexi sale on the device\'s own card reader
+     * @param {InitiateWorldlineA2aSessionDto} initiateWorldlineA2aSessionDto 
+     * @param {string} [xIdempotencyKey] Client-generated UUID. A key this venue\&#39;s on-device sale already holds answers that sale as it stands; a key any other payment holds is refused.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    initiateNexiOnDeviceSession(initiateWorldlineA2aSessionDto: InitiateWorldlineA2aSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
+
     /**
      * 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. POST /payment-session/:clientToken/cancel cancels it as Nexi documents it, a confirm as failed; the outcome is still Nexi\'s answer, so a sale Nexi was already confirmed paid for ends paid. 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
@@ -66532,6 +67614,16 @@ export interface PaymentSessionApiInterface {
      */
     recordManualPayment(createManualSessionDto: CreateManualSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig): AxiosPromise<RecordManualPaymentResultDto>;
 
+    /**
+     * Settles an on-device Nexi sale, refund or revert with Poynt\'s answer, decided by Poynt\'s payment status. COMPLETED makes a sale SUCCESS, REFUNDED makes a refund REFUNDED, VOIDED makes a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. DECLINED makes it FAILED (payment.declined), CANCELED makes it CANCELLED, FAILED makes it FAILED. A sale\'s or a refund\'s answer carries the session\'s sessionId as its reference, except a decline or a cancel, which may come without one; a revert\'s names the sale\'s Poynt transaction as its transactionId or parentId. An approval may replace a failure or a cancel (a payment recovered after the app was killed); an end without money replaces only the wait. An answer that may have moved money but cannot be recorded (AUTHORIZED, HOLD, READ_CARD_ONLY, another kind\'s approval, a partial approval, several approvals, another amount or currency) is kept on the session, which stays DISPATCHED, ops are alerted, and the request is refused. A refund to another card than the sale\'s is recorded and logged. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
+     * @summary Record the device\'s payment app answer for an on-device Nexi session
+     * @param {RecordNexiOnDeviceResultDto} recordNexiOnDeviceResultDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    recordNexiOnDeviceResult(recordNexiOnDeviceResultDto: RecordNexiOnDeviceResultDto, options?: AxiosRequestConfig): AxiosPromise<NexiOnDeviceResultViewDto>;
+
     /**
      * Settles a handheld Worldline sale, refund or revert with the payment app\'s answer (WPI_RESPONSE). A sale\'s or a refund\'s approval carries the session\'s sessionId as its reference, and so does its decline, except that WPI may answer a decline or a cancel without one; a revert\'s (WPI_SVC_CANCEL_PAYMENT) carries none and names the sale\'s paymentSolutionReference instead. An approval makes a sale SUCCESS, a refund REFUNDED and a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. A sale\'s approval may carry a tip the cardholder added on the payment app: it is recorded with the session\'s tip. A failure makes it FAILED, or CANCELLED when the app reports WPI_ERR_COND_USER_CANCEL. An approval may replace a failure; a failure never replaces anything. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
      * @summary Record the Worldline payment app\'s answer for a handheld session
@@ -66562,6 +67654,16 @@ export interface PaymentSessionApiInterface {
      */
     refundNetsSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
 
+    /**
+     * Stores a DISPATCHED refund session for the amount asked (what is left of the sale when none is), within what is left of the sale. Only a sale the device\'s own card reader took is accepted. The device then makes the refund on its payment app with the card presented (Poynt\'s non-referenced refund) and the refund\'s sessionId as its reference, and reports the answer to nexi/on-device/result. Does NOT write a reversal onto the order: the refund plan records it. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+     * @summary Start a card refund of an on-device Nexi sale
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    refundNexiOnDeviceSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
+
     /**
      * Stores a refund session for the amount asked (what is left of the sale when none is), within what is left of the sale, then asks Nexi for a customer-not-present refund of the sale on the sale\'s own terminal: the customer needs no card and the terminal shows nothing. Nexi\'s answer decides: Nexi made it → our confirm, then REFUNDED; Nexi ended it unpaid → FAILED and refused; Nexi still processing → the session waits and Cloud Tasks follow it until Nexi answers. Does NOT write a reversal onto the order: the refund plan records it, as for Viva and Nets. Idempotent by the X-Idempotency-Key header within the venue: a repeat answers the refund it started, as it stands, without asking Nexi again. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
      * @summary Refund a paid Nexi sale, customer not present, with no card
@@ -66623,6 +67725,16 @@ export interface PaymentSessionApiInterface {
      */
     revertNetsSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<NetsRevertResponseDto>;
 
+    /**
+     * Stores a DISPATCHED reversal session for the whole sale. Only a sale the device\'s own card reader took is accepted. The device then voids the sale on its payment app with no card (Poynt\'s void, by the sale\'s transaction id, which is the payment event\'s id) and reports the answer, with the reversal\'s sessionId, to nexi/on-device/result; once VOIDED, reconciliation writes the reversal onto the order. The server alone decides whether the sale may still be voided: up to 55 minutes after the sale was started, never on a closed order, and never once the sale has refund activity. `amount` is ignored: a void gives back the whole sale. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+     * @summary Start a revert (void) of an on-device Nexi sale
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApiInterface
+     */
+    revertNexiOnDeviceSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig): AxiosPromise<PaymentSessionViewDto>;
+
     /**
      * Reads the sale at Nexi and picks the way itself, so the till decides nothing by time: within Nexi\'s hour after the sale (CONFIRMED) and with nothing refunded yet, the sale is confirmed as failed again and everything goes back; once Nexi committed it (COMMITTED, after the hour or after a refund), a customer-not-present refund gives back what is left. A confirm Nexi refuses because the hour ended in between is read again and refunded instead. A sale Nexi already holds unpaid while our record calls it paid is recorded as given back. A confirm Nexi does not answer is never recorded as failed: the revert is kept, counted against the sale, and Cloud Task rounds settle it from Nexi\'s record of the sale: given back once Nexi holds it unpaid; the confirm as failed sent again while Nexi holds it confirmed paid; a refund of what is left once Nexi committed it paid. No card either way. Once Nexi gave the money back, the session is REFUNDING and reconciliation writes the reversal onto the order, then REFUNDED. `amount` is ignored: a revert gives back what is left. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
      * @summary Revert a paid Nexi sale: give back what is left and write the reversal onto the order
@@ -66784,6 +67896,19 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).initiateNetsSession(initiateNetsSessionDto, xIdempotencyKey, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Stores a DISPATCHED Nexi session for a sale the device\'s own payment app (Poynt, on the Newland N950) will take. Its sessionId is the reference the payment app is given; the device then reports the app\'s answer to nexi/on-device/result, and the server writes the order. Refused for a venue whose channel does not pay by Nexi. Nexi is not called, nothing follows the session, and it is never cancelled through :clientToken/cancel. Idempotent via X-Idempotency-Key. A signed-in ticket only.
+     * @summary Start a Nexi sale on the device\'s own card reader
+     * @param {InitiateWorldlineA2aSessionDto} initiateWorldlineA2aSessionDto 
+     * @param {string} [xIdempotencyKey] Client-generated UUID. A key this venue\&#39;s on-device sale already holds answers that sale as it stands; a key any other payment holds is refused.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public initiateNexiOnDeviceSession(initiateWorldlineA2aSessionDto: InitiateWorldlineA2aSessionDto, xIdempotencyKey?: string, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).initiateNexiOnDeviceSession(initiateWorldlineA2aSessionDto, xIdempotencyKey, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * 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. POST /payment-session/:clientToken/cancel cancels it as Nexi documents it, a confirm as failed; the outcome is still Nexi\'s answer, so a sale Nexi was already confirmed paid for ends paid. 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
@@ -66921,6 +68046,18 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).recordManualPayment(createManualSessionDto, xIdempotencyKey, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Settles an on-device Nexi sale, refund or revert with Poynt\'s answer, decided by Poynt\'s payment status. COMPLETED makes a sale SUCCESS, REFUNDED makes a refund REFUNDED, VOIDED makes a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. DECLINED makes it FAILED (payment.declined), CANCELED makes it CANCELLED, FAILED makes it FAILED. A sale\'s or a refund\'s answer carries the session\'s sessionId as its reference, except a decline or a cancel, which may come without one; a revert\'s names the sale\'s Poynt transaction as its transactionId or parentId. An approval may replace a failure or a cancel (a payment recovered after the app was killed); an end without money replaces only the wait. An answer that may have moved money but cannot be recorded (AUTHORIZED, HOLD, READ_CARD_ONLY, another kind\'s approval, a partial approval, several approvals, another amount or currency) is kept on the session, which stays DISPATCHED, ops are alerted, and the request is refused. A refund to another card than the sale\'s is recorded and logged. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
+     * @summary Record the device\'s payment app answer for an on-device Nexi session
+     * @param {RecordNexiOnDeviceResultDto} recordNexiOnDeviceResultDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public recordNexiOnDeviceResult(recordNexiOnDeviceResultDto: RecordNexiOnDeviceResultDto, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).recordNexiOnDeviceResult(recordNexiOnDeviceResultDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Settles a handheld Worldline sale, refund or revert with the payment app\'s answer (WPI_RESPONSE). A sale\'s or a refund\'s approval carries the session\'s sessionId as its reference, and so does its decline, except that WPI may answer a decline or a cancel without one; a revert\'s (WPI_SVC_CANCEL_PAYMENT) carries none and names the sale\'s paymentSolutionReference instead. An approval makes a sale SUCCESS, a refund REFUNDED and a revert REFUNDING; reconciliation then writes the payment or the reversal onto the order. A sale\'s approval may carry a tip the cardholder added on the payment app: it is recorded with the session\'s tip. A failure makes it FAILED, or CANCELLED when the app reports WPI_ERR_COND_USER_CANCEL. An approval may replace a failure; a failure never replaces anything. A repeated answer is answered as the session stands. The payment event\'s time is the server\'s. A signed-in ticket only.
      * @summary Record the Worldline payment app\'s answer for a handheld session
@@ -66957,6 +68094,18 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).refundNetsSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Stores a DISPATCHED refund session for the amount asked (what is left of the sale when none is), within what is left of the sale. Only a sale the device\'s own card reader took is accepted. The device then makes the refund on its payment app with the card presented (Poynt\'s non-referenced refund) and the refund\'s sessionId as its reference, and reports the answer to nexi/on-device/result. Does NOT write a reversal onto the order: the refund plan records it. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+     * @summary Start a card refund of an on-device Nexi sale
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public refundNexiOnDeviceSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).refundNexiOnDeviceSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Stores a refund session for the amount asked (what is left of the sale when none is), within what is left of the sale, then asks Nexi for a customer-not-present refund of the sale on the sale\'s own terminal: the customer needs no card and the terminal shows nothing. Nexi\'s answer decides: Nexi made it → our confirm, then REFUNDED; Nexi ended it unpaid → FAILED and refused; Nexi still processing → the session waits and Cloud Tasks follow it until Nexi answers. Does NOT write a reversal onto the order: the refund plan records it, as for Viva and Nets. Idempotent by the X-Idempotency-Key header within the venue: a repeat answers the refund it started, as it stands, without asking Nexi again. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
      * @summary Refund a paid Nexi sale, customer not present, with no card
@@ -67030,6 +68179,18 @@ export class PaymentSessionApi extends BaseAPI implements PaymentSessionApiInter
         return PaymentSessionApiFp(this.configuration).revertNetsSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Stores a DISPATCHED reversal session for the whole sale. Only a sale the device\'s own card reader took is accepted. The device then voids the sale on its payment app with no card (Poynt\'s void, by the sale\'s transaction id, which is the payment event\'s id) and reports the answer, with the reversal\'s sessionId, to nexi/on-device/result; once VOIDED, reconciliation writes the reversal onto the order. The server alone decides whether the sale may still be voided: up to 55 minutes after the sale was started, never on a closed order, and never once the sale has refund activity. `amount` is ignored: a void gives back the whole sale. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
+     * @summary Start a revert (void) of an on-device Nexi sale
+     * @param {ReverseSessionDto} reverseSessionDto 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PaymentSessionApi
+     */
+    public revertNexiOnDeviceSession(reverseSessionDto: ReverseSessionDto, options?: AxiosRequestConfig) {
+        return PaymentSessionApiFp(this.configuration).revertNexiOnDeviceSession(reverseSessionDto, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Reads the sale at Nexi and picks the way itself, so the till decides nothing by time: within Nexi\'s hour after the sale (CONFIRMED) and with nothing refunded yet, the sale is confirmed as failed again and everything goes back; once Nexi committed it (COMMITTED, after the hour or after a refund), a customer-not-present refund gives back what is left. A confirm Nexi refuses because the hour ended in between is read again and refunded instead. A sale Nexi already holds unpaid while our record calls it paid is recorded as given back. A confirm Nexi does not answer is never recorded as failed: the revert is kept, counted against the sale, and Cloud Task rounds settle it from Nexi\'s record of the sale: given back once Nexi holds it unpaid; the confirm as failed sent again while Nexi holds it confirmed paid; a refund of what is left once Nexi committed it paid. No card either way. Once Nexi gave the money back, the session is REFUNDING and reconciliation writes the reversal onto the order, then REFUNDED. `amount` is ignored: a revert gives back what is left. A signed-in ticket only. Every refusal answers the shared error body: `name` is a stable code the till maps to its own words, `detail` the waiter\'s words when it has none.
      * @summary Revert a paid Nexi sale: give back what is left and write the reversal onto the order