squarefi-bff-api-module 1.36.51 → 1.36.53

package/dist/api/types/autogen/apiV1Legacy.types.d.ts

@@ -1309,13 +1309,45 @@ export interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Sensitive card details retrieved successfully */
+                /** @description Sensitive card details retrieved successfully.
+                 *
+                 *     This legacy surface answers with a BARE object — no `{ success, data }` envelope —
+                 *     and splits the vendor's `MM/YY` expiry into `expiry_month` / `expiry_year`.
+                 *     The `/api` and `/admin` surfaces return the envelope and the raw `expiry_date`
+                 *     instead (`CardSensitiveData`), so the two shapes are not interchangeable.
+                 *      */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["CardSensitiveData"];
+                        "application/json": {
+                            /**
+                             * @description Full card number
+                             * @example 4111111111111111
+                             */
+                            card_number: string;
+                            /**
+                             * @description Card security code
+                             * @example 123
+                             */
+                            cvv: string;
+                            /**
+                             * @description Card expiration month (MM)
+                             * @example 07
+                             */
+                            expiry_month: string;
+                            /**
+                             * @description Card expiration year, as the vendor's two-digit YY
+                             * @example 29
+                             */
+                            expiry_year: string;
+                            /**
+                             * @description 3-D Secure password where the vendor exposes one (Wallester); null otherwise
+                             * @example null
+                             */
+                            security_code: string | null;
+                        };
                     };
                 };
                 /** @description Server Error */
@@ -1348,7 +1380,14 @@ export interface paths {
         put?: never;
         /**
          * Get encrypted sensitive card details
-         * @description Retrieves sensitive information about a specific card including full card number, CVV, and expiry date. The response is encrypted using the provided public key.
+         * @description Retrieves sensitive information about a specific card including full card number, CVV, and expiry date.
+         *     The response is encrypted using the provided public key.
+         *
+         *     Decrypting `data` with the matching private key yields
+         *     `{ success, data: { card_number, cvv, expiry_month, expiry_year, security_code } }` —
+         *     the same split-expiry shape the plaintext legacy `GET .../sensitive` returns, NOT the
+         *     `expiry_date` form of `CardSensitiveData` on the `/api` and `/admin` surfaces.
+         *
          */
         post: {
             parameters: {
@@ -7416,7 +7455,7 @@ export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
         /**
-         * @description Order type identifier. Must be one of the active values from the `order_types` table. Examples: `EXCHANGE_OMNI` (omnibus exchange), `L2F_SWIFT_OFFRAMP` (SWIFT offramp), `OMNIBUS_CRYPTO_TRANSFER` (crypto withdrawal). Legacy `DEPOSIT_*`, `WITHDRAWAL_*` and `AUTO_CONVERT_CRYPTO` are intentionally excluded.
+         * @description Order type identifier. Must be one of the active values from the `order_types` table. Examples: `EXCHANGE_OMNI` (omnibus exchange), `BRL_WIRE_OFFRAMP` (wire offramp), `OMNIBUS_CRYPTO_TRANSFER` (crypto withdrawal). `L2F_*` ids are historical (rail retired) and cannot be used to create orders. Legacy `DEPOSIT_*`, `WITHDRAWAL_*` and `AUTO_CONVERT_CRYPTO` are intentionally excluded.
          * @example EXCHANGE_OMNI
          * @enum {string}
          */
@@ -8282,7 +8321,6 @@ export interface components {
         Country: unknown;
         IssuingCardList: unknown;
         IssuingCard: unknown;
-        CardSensitiveData: unknown;
         CardLimitsUpdateRequest: unknown;
         IssuingCardLimits: unknown;
         CardUpdateRequest: unknown;

package/dist/api/types/autogen/apiV1Tenant.types.d.ts

@@ -2487,7 +2487,7 @@ export interface paths {
                         };
                     };
                 };
-                /** @description Validation error (insufficient balance, virtual account missing, etc.) */
+                /** @description Validation error — invalid body, pair disabled by the exchange config, or calculated amount too small. Balance is checked only at approve. */
                 400: {
                     headers: {
                         [name: string]: unknown;
@@ -3404,8 +3404,10 @@ export interface paths {
          *     debits the funds (transaction written as `complete`) and triggers the
          *     order execution pipeline. Exchange orders (EXCHANGE_OMNI) and internal
          *     transfers (TRANSFER_INTERNAL / OMNIBUS_INTERNAL_TRANSFER) settle
-         *     synchronously and land in COMPLETE. An insufficient balance fails the
-         *     order (FAILED). Only orders with status NEW can be approved. Orders
+         *     synchronously and land in COMPLETE. An insufficient balance answers
+         *     400 `INSUFFICIENT_FUNDS` and releases the order back to NEW; FAILED is
+         *     reached only when a step after the debit fails. Only orders with
+         *     status NEW can be approved. Orders
          *     created with `scheduled_at` move to EXPECTED instead — no funds are
          *     debited until execution at the requested time.
          *
@@ -3422,7 +3424,7 @@ export interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Order approved and processing started */
+                /** @description Order approved — PROCESSING for workflow rails, COMPLETE for exchange / internal transfers, EXPECTED for scheduled orders */
                 200: {
                     headers: {
                         [name: string]: unknown;
@@ -3432,11 +3434,23 @@ export interface paths {
                             /** @example true */
                             success?: boolean;
                             data?: components["schemas"]["TenantOrder"];
-                            /** @example Order approved and processing started */
-                            message?: string;
                         };
                     };
                 };
+                /** @description Insufficient funds (`INSUFFICIENT_FUNDS` — the order is released back to NEW) or validation error */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Order does not belong to the tenant */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
                 /** @description Order not found */
                 404: {
                     headers: {
@@ -3444,7 +3458,7 @@ export interface paths {
                     };
                     content?: never;
                 };
-                /** @description Invalid status transition */
+                /** @description Order is not in an approvable state (`INVALID_STATE`), or another lifecycle call holds the order lock (`OPERATION_IN_PROGRESS`) */
                 409: {
                     headers: {
                         [name: string]: unknown;
@@ -3511,11 +3525,16 @@ export interface paths {
                             /** @example true */
                             success?: boolean;
                             data?: components["schemas"]["TenantOrder"];
-                            /** @example Order canceled successfully */
-                            message?: string;
                         };
                     };
                 };
+                /** @description Order does not belong to the tenant */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
                 /** @description Order not found */
                 404: {
                     headers: {
@@ -3523,7 +3542,7 @@ export interface paths {
                     };
                     content?: never;
                 };
-                /** @description Invalid status transition */
+                /** @description Order is not in a cancelable state (`INVALID_STATE`), or another lifecycle call holds the order lock (`OPERATION_IN_PROGRESS`) */
                 409: {
                     headers: {
                         [name: string]: unknown;
@@ -3612,6 +3631,78 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/admin/orders/{order_id}/confirmation-pdf": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Download payment confirmation (PDF)
+         * @description Operation-level proof that ONE payment was executed. One format serves both directions — on a deposit the payer is the external sender and the beneficiary is the customer's account, on a withdrawal the roles swap — and both payment kinds. A bank transfer is documented with payer and beneficiary requisites, amount in digits and in words, fee and rail; an on-chain transfer with both wallet addresses, the network, the token contract, gas paid and the transaction hash plus the explorer address where it can be verified. Carries no balances.
+         *
+         *     Only settled payments between two identifiable parties qualify: card top-ups, exchanges, book transfers between wallets and payments that have not reached COMPLETE are refused with 409 rather than documented, since the recipient reads this document as proof the money moved.
+         *
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Order ID or order UUID */
+                    order_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description PDF document */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/pdf": string;
+                    };
+                };
+                /** @description Order not found (also returned when the id exists in another tenant — no info leak) */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Order is not an executed payment between two identifiable parties */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/admin/orders/{order_id}": {
         parameters: {
             query?: never;
@@ -6156,6 +6247,14 @@ export interface paths {
                         };
                     };
                 };
+                /** @description Missing/invalid fields, or a `user_data_id` precondition not met (user not verified, no KYC applicant, or the applicant is unknown to the KYC provider). Code `INVALID_REQUEST`; the message names the failed precondition.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
                 /** @description Vendor or sub-account not found */
                 404: {
                     headers: {
@@ -6171,6 +6270,14 @@ export interface paths {
                     };
                     content?: never;
                 };
+                /** @description The KYC provider failed while the dossier was being pulled for `user_data_id` (code `EXTERNAL_SERVICE_ERROR`). Retry later; the draft was not created.
+                 *      */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
             };
         };
         delete?: never;
@@ -7790,18 +7897,28 @@ export interface components {
             /** @description Per transaction amount spent */
             per_transaction_spent?: number;
         };
-        /** @description Sensitive card data */
+        /** @description Sensitive card data, live-fetched from the vendor on every call and never persisted. */
         CardSensitiveData: {
-            /** @description Full card number */
-            card_number?: string;
-            /** @description Card security code */
-            cvv?: string;
-            /** @description Card expiration month (MM) */
-            expiry_month?: string;
-            /** @description Card expiration year (YYYY) */
-            expiry_year?: string;
-            /** @description Card PIN (if applicable) */
-            pin?: string;
+            /**
+             * @description Full card number
+             * @example 4111111111111111
+             */
+            card_number: string;
+            /**
+             * @description Card expiration date, `MM/YY`
+             * @example 07/29
+             */
+            expiry_date: string;
+            /**
+             * @description Card security code
+             * @example 123
+             */
+            cvv: string;
+            /**
+             * @description 3-D Secure password where the vendor exposes one (Wallester); `null` otherwise.
+             * @example null
+             */
+            security_code: string | null;
         };
         /** @description Card transaction */
         IssuingTransaction: {
@@ -8534,7 +8651,7 @@ export interface components {
             };
         };
         /**
-         * @description Order type identifier. Must be one of the active values from the `order_types` table. Examples: `EXCHANGE_OMNI` (omnibus exchange), `L2F_SWIFT_OFFRAMP` (SWIFT offramp), `OMNIBUS_CRYPTO_TRANSFER` (crypto withdrawal). Legacy `DEPOSIT_*`, `WITHDRAWAL_*` and `AUTO_CONVERT_CRYPTO` are intentionally excluded.
+         * @description Order type identifier. Must be one of the active values from the `order_types` table. Examples: `EXCHANGE_OMNI` (omnibus exchange), `BRL_WIRE_OFFRAMP` (wire offramp), `OMNIBUS_CRYPTO_TRANSFER` (crypto withdrawal). `L2F_*` ids are historical (rail retired) and cannot be used to create orders. Legacy `DEPOSIT_*`, `WITHDRAWAL_*` and `AUTO_CONVERT_CRYPTO` are intentionally excluded.
          * @example EXCHANGE_OMNI
          * @enum {string}
          */
@@ -8622,7 +8739,7 @@ export interface components {
             virtual_account_id: string;
             /**
              * Format: uuid
-             * @description Bank counterparty destination UUID created via POST /api/counterparty/destinations. The destination type must match the rail (WIRE/ACH/SEPA/SWIFT/CHAPS/FPS).
+             * @description Bank counterparty destination UUID created via POST /api/counterparty/destinations. The destination type must match the rail (FEDWIRE for wire, ACH, SEPA, SWIFT, CHAPS, FPS).
              */
             counterparty_destination_id: string;
             /** @description Free-form reference visible in order/transaction listings */
@@ -8671,7 +8788,7 @@ export interface components {
             amount_to?: number | null;
             order_type?: string;
             /** @enum {string} */
-            status?: "NEW" | "EXPECTED" | "PROCESSING" | "COMPLETE" | "FAILED" | "CANCELED" | "REFUNDED";
+            status?: "NEW" | "PENDING" | "EXPECTED" | "PROCESSING" | "COMPLETE" | "FAILED" | "CANCELED" | "REFUNDED";
             /** Format: uuid */
             sub_account_id?: string | null;
             info?: string | null;

package/dist/api/types/types.d.ts

@@ -115,6 +115,17 @@ export declare namespace API {
                 card_issuing_fee: number | null;
                 card_monthly_fee: number | null;
                 initial_topup: number | null;
+                /**
+                 * Minimum top-up in the program's currency, compared against the amount
+                 * CREDITED to the card (after fees and conversion) — the same figure the
+                 * server checks before it refuses a deposit with `TOPUP_BELOW_MINIMUM`.
+                 * `0` means the program sets no minimum. Does not apply to the initial
+                 * top-up at issuance.
+                 *
+                 * Optional on the type because programs served by a backend older than
+                 * the `issuing_programs.min_topup` migration omit it.
+                 */
+                min_topup?: number;
                 status?: IssuingProgramStatus | string;
             }
         }
@@ -270,7 +281,34 @@ export declare namespace API {
             adjustment_type: string;
             review_status: string;
             group: string;
+            /**
+             * What actually left the card: `billing_amount` plus `fee` for a debit
+             * (minus it for a credit, which arrives net of what the vendor keeps).
+             * Equals `billing_amount` when no fee sits inside the operation, so it is
+             * the figure to show as the transaction's amount.
+             */
             total_amount: number;
+            /**
+             * Fee charged INSIDE this operation, in billing currency. `0` for vendors
+             * that bill fees as their own transactions — those arrive as separate rows
+             * with `transaction_type: FEE`. Optional: older backends omit it.
+             */
+            fee?: number;
+            /** Vendor's itemisation of `fee`; empty when it gave none. */
+            fee_details?: TransactionFee[];
+            /**
+             * Units of billing currency per unit of transaction currency, so
+             * `transaction_amount * conversion_rate ≈ billing_amount`. 1 when the
+             * currencies match.
+             */
+            conversion_rate?: number;
+        }
+        /** One line of a transaction's fee itemisation (`TransactionItem.fee_details`). */
+        interface TransactionFee {
+            amount: number;
+            currency: string;
+            /** Vendor's own fee code — no cross-vendor meaning. */
+            type: string | null;
         }
         interface TransactionsList {
             data: TransactionItem[];
@@ -385,7 +423,7 @@ export declare namespace API {
         };
         namespace Destination {
             type CounterpartyDestinationType = componentsV1Frontend['schemas']['CounterpartyDestination']['type'];
-            type BankingDestinationType = Extract<CounterpartyDestinationType, 'FEDWIRE'> | Extract<CounterpartyDestinationType, 'ACH'> | Extract<CounterpartyDestinationType, 'SWIFT'> | Extract<CounterpartyDestinationType, 'SEPA'> | Extract<CounterpartyDestinationType, 'CHAPS'> | Extract<CounterpartyDestinationType, 'FPS'>;
+            type BankingDestinationType = Extract<CounterpartyDestinationType, 'FEDWIRE'> | Extract<CounterpartyDestinationType, 'ACH'> | Extract<CounterpartyDestinationType, 'RTP'> | Extract<CounterpartyDestinationType, 'SWIFT'> | Extract<CounterpartyDestinationType, 'SEPA'> | Extract<CounterpartyDestinationType, 'CHAPS'> | Extract<CounterpartyDestinationType, 'FPS'>;
             type CryptoDestinationType = Extract<CounterpartyDestinationType, 'CRYPTO_EXTERNAL'> | Extract<CounterpartyDestinationType, 'CRYPTO_INTERNAL'>;
             type InternalDestinationType = Extract<CounterpartyDestinationType, 'INTERNAL'>;
             type DestinationType = BankingDestinationType | CryptoDestinationType | InternalDestinationType;
@@ -1331,6 +1369,133 @@ export declare namespace API {
             }
         }
     }
+    /**
+     * Mass payouts (SFI-1528): a wallet-scoped batch of payouts to existing counterparty
+     * destinations. A batch is created as a DRAFT, freely edited and previewed, then submitted
+     * and approved — nothing moves until approval. Templates are reusable recipient lists
+     * (no documents, no schedule) a draft can be seeded from.
+     *
+     * Every path is scoped by the source `wallet_id`, so each Request carries it alongside the
+     * query/body. Responses are the frontend `{ success, data }` envelope as the spec declares it.
+     */
+    namespace MassPayouts {
+        type BatchesRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}'];
+        type BatchRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}/{id}'];
+        type BatchItemsRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}/{id}/items'];
+        type BatchPreviewRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}/{id}/preview'];
+        type BatchSubmitRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}/{id}/submit'];
+        type BatchApproveRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}/{id}/approve'];
+        type BatchCancelRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}/{id}/cancel'];
+        type BatchReportCsvRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}/{id}/report.csv'];
+        type TemplatesRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}/templates'];
+        type TemplateRoot = pathsV1Frontend['/frontend/mass-payouts/{wallet_id}/templates/{template_id}'];
+        /** The batch itself: progress counters, totals and the approval/schedule state. */
+        export type MassPayout = componentsV1Frontend['schemas']['MassPayout'];
+        /** A stored recipient row, with its own status and the order created for it at execution. */
+        export type MassPayoutItem = componentsV1Frontend['schemas']['MassPayoutItem'];
+        /** A recipient row as written on create/update. */
+        export type MassPayoutItemInput = componentsV1Frontend['schemas']['MassPayoutItemInput'];
+        /** Supporting attachment; an `INVOICE` satisfies the invoice rule for large rows. */
+        export type MassPayoutDocument = componentsV1Frontend['schemas']['MassPayoutDocument'];
+        /** Exact recipient total for one payout currency (cross-currency rows are listed here). */
+        export type MassPayoutCurrencyTotal = componentsV1Frontend['schemas']['MassPayoutCurrencyTotal'];
+        export type MassPayoutTemplate = componentsV1Frontend['schemas']['MassPayoutTemplate'];
+        export type MassPayoutTemplateItem = componentsV1Frontend['schemas']['MassPayoutTemplateItem'];
+        export type MassPayoutTemplateItemInput = componentsV1Frontend['schemas']['MassPayoutTemplateItemInput'];
+        export type MassPayoutTemplateWithItems = componentsV1Frontend['schemas']['MassPayoutTemplateWithItems'];
+        /**
+         * Status unions read off the schemas rather than re-declared, so a spec change lands here
+         * automatically. `SCHEDULED` = approved with a future send date; `CANCELED` on an item means
+         * it was never attempted.
+         */
+        export type MassPayoutStatus = NonNullable<MassPayout['status']>;
+        export type MassPayoutItemStatus = NonNullable<MassPayoutItem['status']>;
+        export type MassPayoutDocumentType = MassPayoutDocument['type'];
+        export namespace List {
+            type Request = BatchesRoot['get']['parameters']['path'] & NonNullable<BatchesRoot['get']['parameters']['query']>;
+            type Response = BatchesRoot['get']['responses']['200']['content']['application/json'];
+        }
+        export namespace Create {
+            type Request = BatchesRoot['post']['parameters']['path'] & BatchesRoot['post']['requestBody']['content']['application/json'];
+            type Response = BatchesRoot['post']['responses']['200']['content']['application/json'];
+        }
+        export namespace GetById {
+            type Request = BatchRoot['get']['parameters']['path'];
+            type Response = BatchRoot['get']['responses']['200']['content']['application/json'];
+        }
+        /**
+         * Draft-only. `items` fully replaces the recipient list; `virtual_account_id: null` clears the
+         * source virtual account and `scheduled_at: null` makes the batch execute right after approval.
+         */
+        export namespace Update {
+            type Request = BatchRoot['put']['parameters']['path'] & BatchRoot['put']['requestBody']['content']['application/json'];
+            type Response = BatchRoot['put']['responses']['200']['content']['application/json'];
+        }
+        export namespace Items {
+            type Request = BatchItemsRoot['get']['parameters']['path'] & NonNullable<BatchItemsRoot['get']['parameters']['query']>;
+            type Response = BatchItemsRoot['get']['responses']['200']['content']['application/json'];
+        }
+        /**
+         * Dry run before submitting: per-item fee estimates, the total debit in the batch source
+         * currency and the balance check, plus `problems[]` for the rows that would block a submit.
+         */
+        export namespace Preview {
+            type Request = BatchPreviewRoot['get']['parameters']['path'];
+            type Response = BatchPreviewRoot['get']['responses']['200']['content']['application/json'];
+            type PreviewItem = NonNullable<NonNullable<Response['data']>['items']>[number];
+            /**
+             * The same shape the submit refusal returns in `error.details.problems` — the spec types the
+             * error envelope's `details` as free-form, so this is the one declared home for it.
+             */
+            type PreviewProblem = NonNullable<NonNullable<Response['data']>['problems']>[number];
+        }
+        /** DRAFT to PENDING_APPROVAL. Refused while any recipient is invalid. */
+        export namespace Submit {
+            type Request = BatchSubmitRoot['post']['parameters']['path'];
+            type Response = BatchSubmitRoot['post']['responses']['200']['content']['application/json'];
+        }
+        /** Approve and start execution (or arm the schedule when `scheduled_at` is set). */
+        export namespace Approve {
+            type Request = BatchApproveRoot['post']['parameters']['path'];
+            type Response = BatchApproveRoot['post']['responses']['200']['content']['application/json'];
+        }
+        export namespace Cancel {
+            type Request = BatchCancelRoot['post']['parameters']['path'];
+            type Response = BatchCancelRoot['post']['responses']['200']['content']['application/json'];
+        }
+        /** Streaming `text/csv`, not the JSON envelope — the response is the raw CSV body. */
+        export namespace ReportCsv {
+            type Request = BatchReportCsvRoot['get']['parameters']['path'];
+            type Response = BatchReportCsvRoot['get']['responses']['200']['content']['text/csv'];
+        }
+        export namespace Templates {
+            namespace List {
+                type Request = TemplatesRoot['get']['parameters']['path'] & NonNullable<TemplatesRoot['get']['parameters']['query']>;
+                type Response = TemplatesRoot['get']['responses']['200']['content']['application/json'];
+            }
+            namespace Create {
+                type Request = TemplatesRoot['post']['parameters']['path'] & TemplatesRoot['post']['requestBody']['content']['application/json'];
+                type Response = TemplatesRoot['post']['responses']['200']['content']['application/json'];
+            }
+            namespace GetById {
+                type Request = TemplateRoot['get']['parameters']['path'];
+                type Response = TemplateRoot['get']['responses']['200']['content']['application/json'];
+            }
+            /**
+             * `items` fully replaces the row list; `virtual_account_id: null` clears the template's
+             * source account.
+             */
+            namespace Update {
+                type Request = TemplateRoot['put']['parameters']['path'] & TemplateRoot['put']['requestBody']['content']['application/json'];
+                type Response = TemplateRoot['put']['responses']['200']['content']['application/json'];
+            }
+            namespace Delete {
+                type Request = TemplateRoot['delete']['parameters']['path'];
+                type Response = TemplateRoot['delete']['responses']['200']['content']['application/json'];
+            }
+        }
+        export {};
+    }
     namespace Orders {
         namespace Create {
             namespace ByOrderType {
@@ -2191,27 +2356,27 @@ export declare namespace API {
                         type Response = OrderEnvelope;
                     }
                     namespace Wire {
-                        type Request = componentsV1Frontend['schemas']['FrontendL2FOrderRequest'];
+                        type Request = componentsV1Frontend['schemas']['FrontendFiatWithdrawalRequest'];
                         type Response = OrderEnvelope;
                     }
                     namespace Ach {
-                        type Request = componentsV1Frontend['schemas']['FrontendL2FOrderRequest'];
+                        type Request = componentsV1Frontend['schemas']['FrontendFiatWithdrawalRequest'];
                         type Response = OrderEnvelope;
                     }
                     namespace Sepa {
-                        type Request = componentsV1Frontend['schemas']['FrontendL2FOrderRequest'];
+                        type Request = componentsV1Frontend['schemas']['FrontendFiatWithdrawalRequest'];
                         type Response = OrderEnvelope;
                     }
                     namespace Swift {
-                        type Request = componentsV1Frontend['schemas']['FrontendL2FOrderRequest'];
+                        type Request = componentsV1Frontend['schemas']['FrontendFiatWithdrawalRequest'];
                         type Response = OrderEnvelope;
                     }
                     namespace Chaps {
-                        type Request = componentsV1Frontend['schemas']['FrontendL2FOrderRequest'];
+                        type Request = componentsV1Frontend['schemas']['FrontendFiatWithdrawalRequest'];
                         type Response = OrderEnvelope;
                     }
                     namespace Fps {
-                        type Request = componentsV1Frontend['schemas']['FrontendL2FOrderRequest'];
+                        type Request = componentsV1Frontend['schemas']['FrontendFiatWithdrawalRequest'];
                         type Response = OrderEnvelope;
                     }
                 }

package/dist/constants.d.ts

@@ -391,6 +391,7 @@ export declare const counterpartyTypeCheck: IsEnumEqualToUnion<CounterpartyType,
 export declare enum CounterpartyDestinationType {
     FEDWIRE = "FEDWIRE",
     ACH = "ACH",
+    RTP = "RTP",
     SWIFT = "SWIFT",
     SEPA = "SEPA",
     CRYPTO_EXTERNAL = "CRYPTO_EXTERNAL",

package/dist/constants.js

@@ -415,6 +415,7 @@ export var CounterpartyDestinationType;
 (function (CounterpartyDestinationType) {
     CounterpartyDestinationType["FEDWIRE"] = "FEDWIRE";
     CounterpartyDestinationType["ACH"] = "ACH";
+    CounterpartyDestinationType["RTP"] = "RTP";
     CounterpartyDestinationType["SWIFT"] = "SWIFT";
     CounterpartyDestinationType["SEPA"] = "SEPA";
     CounterpartyDestinationType["CRYPTO_EXTERNAL"] = "CRYPTO_EXTERNAL";
@@ -427,6 +428,7 @@ export var CounterpartyDestinationType;
 export const counterpartyBankingDestinationTypes = {
     FEDWIRE: CounterpartyDestinationType.FEDWIRE,
     ACH: CounterpartyDestinationType.ACH,
+    RTP: CounterpartyDestinationType.RTP,
     SWIFT: CounterpartyDestinationType.SWIFT,
     SEPA: CounterpartyDestinationType.SEPA,
     CHAPS: CounterpartyDestinationType.CHAPS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squarefi-bff-api-module",
-  "version": "1.36.51",
+  "version": "1.36.53",
   "description": "Squarefi BFF API client module",
   "type": "module",
   "main": "./dist/index.js",