squarefi-bff-api-module 1.36.77 → 1.36.79

package/dist/api/frontend.d.ts

@@ -70,6 +70,12 @@ export declare const frontend: {
             getAll: ({ wallet_id, ...params }: API.Frontend.VirtualAccounts.Programs.List.Request) => Promise<API.Frontend.VirtualAccounts.Programs.List.Response>;
         };
     };
+    kycRails: {
+        getAll: ({ wallet_id }: API.Frontend.KycRails.List.Request) => Promise<API.Frontend.KycRails.List.Response>;
+        getById: ({ wallet_id, rail_id }: API.Frontend.KycRails.Get.Request) => Promise<API.Frontend.KycRails.Get.Response>;
+        submit: ({ wallet_id, rail_id, }: API.Frontend.KycRails.Submit.Request) => Promise<API.Frontend.KycRails.Submit.Response>;
+        confirmTerms: ({ wallet_id, rail_id, }: API.Frontend.KycRails.ConfirmTerms.Request) => Promise<API.Frontend.KycRails.ConfirmTerms.Response>;
+    };
     reference: {
         exchangeRates: {
             list: (params?: API.Frontend.Reference.ExchangeRates.List.Request) => Promise<API.Frontend.Reference.ExchangeRates.List.Response>;

package/dist/api/frontend.js

@@ -144,6 +144,14 @@ export const frontend = {
             getAll: ({ wallet_id, ...params }) => apiClientV1Frontend.getRequest(`/frontend/virtual-accounts/programs/wallet/${wallet_id}`, { params }),
         },
     },
+    // Frontend twin of `kyc.rails.*` (BFF `/kyc/{wallet_id}/rails`). Reads take any wallet member; `submit` and
+    // `confirmTerms` take the wallet admin or owner, and only they get the rail's `extra_actions`.
+    kycRails: {
+        getAll: ({ wallet_id }) => apiClientV1Frontend.getRequest(`/frontend/wallets/${wallet_id}/kyc-rails`),
+        getById: ({ wallet_id, rail_id }) => apiClientV1Frontend.getRequest(`/frontend/wallets/${wallet_id}/kyc-rails/${rail_id}`),
+        submit: ({ wallet_id, rail_id, }) => apiClientV1Frontend.postRequest(`/frontend/wallets/${wallet_id}/kyc-rails/${rail_id}`),
+        confirmTerms: ({ wallet_id, rail_id, }) => apiClientV1Frontend.postRequest(`/frontend/wallets/${wallet_id}/kyc-rails/${rail_id}/terms-and-conditions`),
+    },
     reference: {
         // Frontend twin of `exchange.byOrderType.*` (legacy `GET /exchange/`): the same tenant pairs, but paged in
         // memory — 50 per page by default, 500 at most, in no particular order — and behind the bearer session.

package/dist/api/index.d.ts

@@ -10,6 +10,7 @@ import { list } from './list';
 import { massPayouts } from './mass-payouts';
 import { orders } from './orders';
 import { referrals } from './referrals';
+import { rfi } from './rfi';
 import { statements } from './statements';
 import { storage } from './storage';
 import { tenants } from './tenants';
@@ -30,6 +31,7 @@ type Api = {
     massPayouts: typeof massPayouts;
     orders: typeof orders;
     referrals: typeof referrals;
+    rfi: typeof rfi;
     statements: typeof statements;
     storage: typeof storage;
     tenants: typeof tenants;

package/dist/api/index.js

@@ -10,6 +10,7 @@ import { list } from './list';
 import { massPayouts } from './mass-payouts';
 import { orders } from './orders';
 import { referrals } from './referrals';
+import { rfi } from './rfi';
 import { statements } from './statements';
 import { storage } from './storage';
 import { tenants } from './tenants';
@@ -30,6 +31,7 @@ export const squarefi_bff_api_client = {
     massPayouts,
     orders,
     referrals,
+    rfi,
     statements,
     storage,
     tenants,

package/dist/api/kyc.d.ts

@@ -17,6 +17,7 @@ export declare const kyc: {
         init: ({ kyc_entity_id, ...params }: API.KYC.Entity.Init.Request) => Promise<API.KYC.Entity.Init.Response>;
         resume: ({ kyc_entity_id, verification_ref, }: API.KYC.Entity.Resume.Request) => Promise<API.KYC.Entity.Resume.Response>;
     };
+    /** @deprecated BFF rails are replaced by CORE `/frontend/wallets/{wallet_id}/kyc-rails` (SFI-2614). Use `frontend.kycRails`. */
     rails: {
         info: {
             getAll: ({ wallet_id }: API.KYC.Rails.RailInfo.List.Request) => Promise<API.KYC.Rails.RailInfo.List.Response>;

package/dist/api/kyc.js

@@ -17,6 +17,7 @@ export const kyc = {
         init: ({ kyc_entity_id, ...params }) => apiClientV2.postRequest(`/kyc/entities/${kyc_entity_id}/init`, { params }),
         resume: ({ kyc_entity_id, verification_ref, }) => apiClientV2.postRequest(`/kyc/entities/${kyc_entity_id}/resume/${verification_ref}`),
     },
+    /** @deprecated BFF rails are replaced by CORE `/frontend/wallets/{wallet_id}/kyc-rails` (SFI-2614). Use `frontend.kycRails`. */
     rails: {
         info: {
             getAll: ({ wallet_id }) => apiClientV2.getRequest(`/kyc/${wallet_id}/rails`),

package/dist/api/rfi.d.ts

@@ -0,0 +1,11 @@
+import { API } from './types/types';
+/**
+ * Requests for information from compliance (SFI-2280), scoped by `wallet_id`. The client can only
+ * read and answer them: the spec declares no method to close, edit or delete one.
+ */
+export declare const rfi: {
+    list: ({ wallet_id, ...params }: API.Rfi.List.Request) => Promise<API.Rfi.List.Response>;
+    getById: ({ wallet_id, case_id }: API.Rfi.GetById.Request) => Promise<API.Rfi.GetById.Response>;
+    reply: ({ wallet_id, case_id, body, files, signal, timeout, }: API.Rfi.Reply.Request) => Promise<API.Rfi.Reply.Response>;
+    getAttachmentLink: ({ wallet_id, case_id, attachment_id, }: API.Rfi.GetAttachmentLink.Request) => Promise<API.Rfi.GetAttachmentLink.Response>;
+};

package/dist/api/rfi.js

@@ -0,0 +1,26 @@
+import { apiClientV1Frontend } from '../utils/apiClientFactory';
+/**
+ * Requests for information from compliance (SFI-2280), scoped by `wallet_id`. The client can only
+ * read and answer them: the spec declares no method to close, edit or delete one.
+ */
+export const rfi = {
+    list: ({ wallet_id, ...params }) => apiClientV1Frontend.getRequest(`/frontend/rfi/${wallet_id}`, { params }),
+    getById: ({ wallet_id, case_id }) => apiClientV1Frontend.getRequest(`/frontend/rfi/${wallet_id}/${case_id}`),
+    // Each file is its own part named `files` (repeated, not `files[]`) — the form verified live.
+    // Content-Type is left to the browser, which adds the multipart boundary. A reply carries up to
+    // 10 files of 20 MB, which the client's 60 s default timeout may not cover: pass `timeout`.
+    reply: ({ wallet_id, case_id, body, files, signal, timeout, }) => {
+        const formData = new FormData();
+        if (body)
+            formData.append('body', body);
+        files?.forEach((file) => formData.append('files', file));
+        return apiClientV1Frontend.postRequest(`/frontend/rfi/${wallet_id}/${case_id}/messages`, {
+            data: formData,
+            signal,
+            timeout,
+        });
+    },
+    // The signed link lives `expires_in` seconds (about 120): open it right away and request a new
+    // one for every download instead of storing it.
+    getAttachmentLink: ({ wallet_id, case_id, attachment_id, }) => apiClientV1Frontend.getRequest(`/frontend/rfi/${wallet_id}/${case_id}/attachments/${attachment_id}`),
+};

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

@@ -2428,6 +2428,8 @@ export interface paths {
                      *     Pass `status=FAILED` to get them back.
                      *      */
                     status?: ("ACTIVE" | "INACTIVE" | "SUSPENDED" | "CANCELED")[];
+                    /** @description Only cards issued to this cardholder. */
+                    cardholder_id?: string;
                     /** @description Filter cards by last 4 digits of the card number (partial, case-insensitive match) */
                     last4?: string;
                     /** @description Number of items to skip */
@@ -4261,7 +4263,10 @@ export interface paths {
         /**
          * Withdraw funds from sub-account
          * @description Withdraws funds from a sub-account back to the associated wallet.
-         *     Currency is automatically determined from sub-account's account_currency.
+         *     The sub-account is debited in its account_currency. The wallet is credited
+         *     in the tenant's base currency when the tenant has auto-exchange on (converted
+         *     at the tenant's WITHDRAW_CARD_SUBACCOUNT rate inside the same order), otherwise
+         *     — or when that pair has no rate — in the sub-account's account_currency.
          *
          *     **Authentication**: x-api-key header required
          *

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

@@ -2903,6 +2903,8 @@ export interface paths {
                      *     client can act on. Pass `status=FAILED` to get them back.
                      *      */
                     status?: ("ACTIVE" | "INACTIVE" | "FROZEN" | "CANCELED" | "CLOSED" | "BLOCKED" | "FAILED" | "PENDING")[];
+                    /** @description Only cards issued to this cardholder. */
+                    cardholder_id?: string;
                     /** @description Filter cards by last 4 digits of the card number (partial, case-insensitive match) */
                     last4?: string;
                     /** @description Number of items to skip */
@@ -4764,7 +4766,10 @@ export interface paths {
         /**
          * Withdraw funds from sub-account
          * @description Withdraws funds from a sub-account back to the associated wallet.
-         *     Currency is automatically determined from sub-account's account_currency.
+         *     The sub-account is debited in its account_currency. The wallet is credited
+         *     in the tenant's base currency when the tenant has auto-exchange on (converted
+         *     at the tenant's WITHDRAW_CARD_SUBACCOUNT rate inside the same order), otherwise
+         *     — or when that pair has no rate — in the sub-account's account_currency.
          *
          *     **Authentication**: Bearer token with x-tenant-id header required
          *
@@ -15127,6 +15132,279 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/frontend/wallets/{wallet_id}/kyc-rails": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * KYC rails of the wallet
+         * @description The tenant's KYC rails of the wallet's entity type and the universal ones, each with the wallet's
+         *     application on it. A rail is listed while it is active; an archived rail stays listed only when the
+         *     wallet is approved on it. `can_submit` tells whether `POST …/kyc-rails/{rail_id}` would be accepted now.
+         *
+         *     Replaces the BFF `GET /kyc/{wallet_id}/rails`; items have its shape plus `can_submit`.
+         *
+         *     **Access Control**: any member of the wallet except the scoped `user` role. No KYC gate.
+         *
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    wallet_id: components["parameters"]["KycRailsWalletId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Rails of the wallet */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example true */
+                            success: boolean;
+                            data: components["schemas"]["WalletKycRail"][];
+                            count: number;
+                        };
+                    };
+                };
+                401: components["responses"]["UnauthorizedError"];
+                403: components["responses"]["ForbiddenError"];
+                /** @description Wallet not found (NOT_FOUND) */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/frontend/wallets/{wallet_id}/kyc-rails/{rail_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * One KYC rail of the wallet
+         * @description One rail with the wallet's application on it, under the visibility rule of the list.
+         *
+         *     Replaces the BFF `GET /kyc/{wallet_id}/rails/{rail_id}`.
+         *
+         *     **Access Control**: any member of the wallet except the scoped `user` role. No KYC gate.
+         *
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    wallet_id: components["parameters"]["KycRailsWalletId"];
+                    /** @description `kyc_rails.id` of the wallet's tenant */
+                    rail_id: components["parameters"]["KycRailId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The rail */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["WalletKycRailResponse"];
+                    };
+                };
+                /** @description `rail_id` is not a UUID (VALIDATION_ERROR) */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                401: components["responses"]["UnauthorizedError"];
+                403: components["responses"]["ForbiddenError"];
+                /** @description No such rail on the wallet's tenant, or an archived rail the wallet is not approved on (RAIL_NOT_FOUND) */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Submit the wallet to a KYC rail
+         * @description Puts the wallet on the rail, the way compliance does from the panel: a rail whose vendor CORE onboards
+         *     itself is submitted here, any other goes through the KYC-admin service. A manual rail waits for
+         *     compliance (`WAITING_ON_REVIEW`); a universal rail is approved on the spot. An application the vendor
+         *     sent back (`HOLD`, `SOFT_REJECT`) is resubmitted. No body.
+         *
+         *     Refused unless the rail has an onboarding implementation (Rail.io rails never do), takes submissions,
+         *     fits the entity type, and the entity's KYC is `APPROVED` or `WAITING_ON_REVIEW`. On a tenant without KYC
+         *     only the tenant's default universal rail can be submitted without it.
+         *
+         *     Replaces the BFF `POST /kyc/{wallet_id}/rails/{rail_id}`.
+         *
+         *     **Access Control**: wallet `admin` or `owner`. No KYC gate.
+         *
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    wallet_id: components["parameters"]["KycRailsWalletId"];
+                    /** @description `kyc_rails.id` of the wallet's tenant */
+                    rail_id: components["parameters"]["KycRailId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The rail after the submission */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["WalletKycRailResponse"];
+                    };
+                };
+                /** @description `rail_id` is not a UUID (VALIDATION_ERROR); the rail has no onboarding implementation, or is a universal
+                 *     rail other than the tenant's default on a tenant without KYC (RAIL_NOT_AVAILABLE); the rail takes no
+                 *     submissions (RAIL_SUBMIT_UNAVAILABLE); the rail is of the other entity type (RAIL_TYPE_MISMATCH); the
+                 *     onboarding behind the rail refused the submission (RAIL_SUBMISSION_REJECTED — the vendor's reason is
+                 *     logged, never returned)
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                401: components["responses"]["UnauthorizedError"];
+                /** @description Not an admin of the wallet (ACCESS_DENIED), or the entity's KYC is not approved or under review (KYC_NOT_APPROVED) */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description No such rail on the wallet's tenant, or an archived one (RAIL_NOT_FOUND) */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Already approved on the rail (RAIL_ALREADY_APPROVED), an application is with the vendor
+                 *     (RAIL_SUBMISSION_IN_PROGRESS), or the same submission is being processed (OPERATION_IN_PROGRESS)
+                 *      */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The onboarding behind the rail failed or is unreachable (RAIL_SUBMISSION_FAILED), or the lock service is down (SERVICE_UNAVAILABLE) */
+                503: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/frontend/wallets/{wallet_id}/kyc-rails/{rail_id}/terms-and-conditions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Accept the terms of a KYC rail
+         * @description Records that the wallet accepted the rail's terms (`wallet_rail.terms_confirmed`). The wallet must have
+         *     submitted to the rail first. No body.
+         *
+         *     Replaces the BFF `POST /kyc/{wallet_id}/rails/{rail_id}/terms-and-conditions`.
+         *
+         *     **Access Control**: wallet `admin` or `owner`. No KYC gate.
+         *
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    wallet_id: components["parameters"]["KycRailsWalletId"];
+                    /** @description `kyc_rails.id` of the wallet's tenant */
+                    rail_id: components["parameters"]["KycRailId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The rail with the terms accepted */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["WalletKycRailResponse"];
+                    };
+                };
+                /** @description `rail_id` is not a UUID (VALIDATION_ERROR) */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                401: components["responses"]["UnauthorizedError"];
+                403: components["responses"]["ForbiddenError"];
+                /** @description No such rail (RAIL_NOT_FOUND), or the wallet never submitted to it (RAIL_NOT_SUBMITTED) */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/frontend/notifications/test": {
         parameters: {
             query?: never;
@@ -17007,6 +17285,50 @@ export interface components {
             email: string | null;
             phone: string | null;
         };
+        /** @description A terms-and-conditions document of a KYC rail. */
+        WalletKycRailTerms: {
+            title: string;
+            description: string | null;
+            link: string | null;
+        };
+        /** @description Something the user has to do with the rail vendor: `verification` — a vendor self-verification link (`type` names it, `full_name` the person it is for); `kyb_onboarding` — the vendor-hosted onboarding link. */
+        WalletKycRailExtraAction: {
+            /** @enum {string} */
+            action: "verification" | "kyb_onboarding";
+            type: string;
+            full_name: string | null;
+            /** Format: uri */
+            url: string;
+        };
+        /** @description The wallet's application on the rail. `null` on the rail while the wallet never submitted to it. */
+        WalletKycRailApplication: {
+            /**
+             * @description `APPROVED` — onboarded. `PROCESSING` / `PENDING` — with the vendor. `HOLD` / `SOFT_REJECT` — the vendor asked for a resubmission. `WAITING_ON_REVIEW` — a manual rail waiting for compliance.
+             * @enum {string}
+             */
+            status: "APPROVED" | "DECLINED" | "PENDING" | "PROCESSING" | "HOLD" | "NEEDS_ATTENTION" | "DOUBLE" | "SOFT_REJECT" | "REJECT" | "UNVERIFIED" | "WAITING_ON_UBOS" | "WAITING_ON_REVIEW";
+            /** @description Neutral text for the status, for display. Never the vendor's or compliance's own words. */
+            message: string | null;
+            terms_confirmed: boolean;
+            /** @description Vendor links to follow. Always empty for a caller below wallet `admin` — the links are one-time capabilities. */
+            extra_actions: components["schemas"]["WalletKycRailExtraAction"][];
+            /** @description The terms the rail had when the wallet first submitted — what the user accepted. */
+            terms_and_conditions: components["schemas"]["WalletKycRailTerms"][];
+        };
+        /** @description A KYC rail of the wallet's tenant with the wallet's application on it. Same shape as the BFF `GET /kyc/{wallet_id}/rails` item, plus `can_submit`. Vendor texts are not returned: `wallet_rail.message` is a neutral text for the status. */
+        WalletKycRail: {
+            /** Format: uuid */
+            id: string;
+            code: string | null;
+            name: string;
+            /** @description The rail takes submissions at all. */
+            is_submit_available: boolean;
+            /** @description The wallet can submit to the rail right now: it has an onboarding implementation, is of the entity's type or universal, the entity's KYC is approved or under review, and no application is approved or with the vendor. */
+            can_submit: boolean;
+            /** @description The rail's active terms, in display order. */
+            terms_and_conditions: components["schemas"]["WalletKycRailTerms"][];
+            wallet_rail: components["schemas"]["WalletKycRailApplication"] | null;
+        };
         /** @description One aggregated crypto balance of the wallet: every balance row sharing the same symbol is merged into a single entry, and `details[]` keeps the per-row breakdown. */
         WalletBalanceEntry: {
             symbol: string;
@@ -17946,6 +18268,11 @@ export interface components {
             /** @description Every transaction the request covers, in the order compliance linked them */
             transactions?: components["schemas"]["RfiTransaction"][];
         };
+        WalletKycRailResponse: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["WalletKycRail"];
+        };
     };
     responses: {
         /** @description Authentication credentials are missing or invalid */
@@ -18021,6 +18348,9 @@ export interface components {
         /** @description The account the requests are about. Requests and their conversations are kept per account. */
         RfiWalletId: string;
         RfiCaseId: string;
+        KycRailsWalletId: string;
+        /** @description `kyc_rails.id` of the wallet's tenant */
+        KycRailId: string;
     };
     requestBodies: never;
     headers: never;

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

@@ -6513,6 +6513,8 @@ export interface paths {
                      *     Accepts a single value or a comma-separated list, e.g. `status=ACTIVE,CANCELED`.
                      *      */
                     status?: ("ACTIVE" | "INACTIVE" | "SUSPENDED" | "CANCELED")[];
+                    /** @description Only cards issued to this cardholder. */
+                    cardholder_id?: string;
                     sub_account_type?: "balance" | "prepaid";
                     offset?: number;
                     limit?: number;

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

@@ -816,6 +816,33 @@ export declare namespace API {
             }
             export {};
         }
+        namespace KycRails {
+            type ListRoot = pathsV1Frontend['/frontend/wallets/{wallet_id}/kyc-rails'];
+            type RailRoot = pathsV1Frontend['/frontend/wallets/{wallet_id}/kyc-rails/{rail_id}'];
+            type TermsRoot = pathsV1Frontend['/frontend/wallets/{wallet_id}/kyc-rails/{rail_id}/terms-and-conditions'];
+            export type WalletKycRail = componentsV1Frontend['schemas']['WalletKycRail'];
+            export type WalletKycRailApplication = componentsV1Frontend['schemas']['WalletKycRailApplication'];
+            export type WalletKycRailExtraAction = componentsV1Frontend['schemas']['WalletKycRailExtraAction'];
+            export type WalletKycRailTerms = componentsV1Frontend['schemas']['WalletKycRailTerms'];
+            export type RailStatus = WalletKycRailApplication['status'];
+            export namespace List {
+                type Request = ListRoot['get']['parameters']['path'];
+                type Response = ListRoot['get']['responses'][200]['content']['application/json'];
+            }
+            export namespace Get {
+                type Request = RailRoot['get']['parameters']['path'];
+                type Response = RailRoot['get']['responses'][200]['content']['application/json'];
+            }
+            export namespace Submit {
+                type Request = RailRoot['post']['parameters']['path'];
+                type Response = RailRoot['post']['responses'][200]['content']['application/json'];
+            }
+            export namespace ConfirmTerms {
+                type Request = TermsRoot['post']['parameters']['path'];
+                type Response = TermsRoot['post']['responses'][200]['content']['application/json'];
+            }
+            export {};
+        }
         namespace Reference {
             namespace ExchangeRates {
                 type ExchangeRatesRoot = pathsV1Frontend['/frontend/reference/exchange_rates'];
@@ -1661,6 +1688,52 @@ export declare namespace API {
         }
         export {};
     }
+    /**
+     * Requests for information (RFI, SFI-2280): compliance's questions about an account or its
+     * transactions, answered by the account's team with text and files.
+     *
+     * Every path is scoped by `wallet_id`, so each Request carries it. Responses are the frontend
+     * `{ success, data }` envelope as the spec declares it. Every `Rfi*` field is optional for now
+     * because the spec declares no `required`; the types tighten on the regeneration that adds it.
+     */
+    namespace Rfi {
+        type CasesRoot = pathsV1Frontend['/frontend/rfi/{wallet_id}'];
+        type CaseRoot = pathsV1Frontend['/frontend/rfi/{wallet_id}/{case_id}'];
+        type CaseMessagesRoot = pathsV1Frontend['/frontend/rfi/{wallet_id}/{case_id}/messages'];
+        type CaseAttachmentRoot = pathsV1Frontend['/frontend/rfi/{wallet_id}/{case_id}/attachments/{attachment_id}'];
+        export type Case = componentsV1Frontend['schemas']['RfiCase'];
+        export type CaseDetail = componentsV1Frontend['schemas']['RfiCaseDetail'];
+        export type Message = componentsV1Frontend['schemas']['RfiMessage'];
+        export type Attachment = componentsV1Frontend['schemas']['RfiAttachment'];
+        export type Transaction = componentsV1Frontend['schemas']['RfiTransaction'];
+        export type CaseStatus = NonNullable<Case['status']>;
+        export type CaseType = NonNullable<Case['type']>;
+        export type MessageAuthor = NonNullable<Message['author']>;
+        /** The list's `status` filter. `open` = `action_required` + `awaiting_compliance`; no case has it. */
+        export type ListStatus = NonNullable<List.Request['status']>;
+        export type Summary = NonNullable<NonNullable<List.Response['data']>['summary']>;
+        export namespace List {
+            type Request = CasesRoot['get']['parameters']['path'] & NonNullable<CasesRoot['get']['parameters']['query']>;
+            type Response = CasesRoot['get']['responses']['200']['content']['application/json'];
+        }
+        export namespace GetById {
+            type Request = CaseRoot['get']['parameters']['path'];
+            type Response = CaseRoot['get']['responses']['200']['content']['application/json'];
+        }
+        export namespace Reply {
+            type Request = CaseMessagesRoot['post']['parameters']['path'] & Omit<CaseMessagesRoot['post']['requestBody']['content']['multipart/form-data'], 'files'> & {
+                files?: File[];
+                signal?: AbortSignal;
+                timeout?: number;
+            };
+            type Response = CaseMessagesRoot['post']['responses']['201']['content']['application/json'];
+        }
+        export namespace GetAttachmentLink {
+            type Request = CaseAttachmentRoot['get']['parameters']['path'];
+            type Response = CaseAttachmentRoot['get']['responses']['200']['content']['application/json'];
+        }
+        export {};
+    }
     namespace Orders {
         namespace Create {
             namespace ByOrderType {

package/package.json

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