@cobre-npm/library-portal-core 0.56.0 → 0.58.0

package/README.md

@@ -4,6 +4,10 @@ Shared catalogs, configuration and interfaces for Cobre's Portal MFEs (Vue 3 + T
 It is a **static data** library (no app runtime): account types, counterparties, countries, currencies,
 movement types, document types, etc., together with their translated labels.
 
+The vocabulary these catalogs share with the Portal and the BFF (rail, movement type, line, business category,
+product type, nature, …) is defined in [`GLOSSARY.md`](./GLOSSARY.md); [`GLOSSARY-MAP.md`](./GLOSSARY-MAP.md)
+lists it together with the glossary local to `canonicalTransactions`.
+
 - No runtime dependencies (only `devDependencies`).
 - Published compiled to `dist/` (CommonJS + `.d.ts`).
 - Managed with **pnpm**; built with plain `tsc`.
@@ -43,8 +47,9 @@ import { getCountries }    from "@cobre-npm/library-portal-core/countries"
 | `@cobre-npm/library-portal-core/subclients` | Subclient statuses + `Subclient`/`SubclientPerson` interfaces |
 | `@cobre-npm/library-portal-core/documentTypes` | Document types (definition + per-country applicability) |
 | `@cobre-npm/library-portal-core/currencies` | Currencies |
+| `@cobre-npm/library-portal-core/blockchains` | Blockchains (chains of the counterparty dropdown) |
 | `@cobre-npm/library-portal-core/transactions` | Transaction types + interfaces |
-| `@cobre-npm/library-portal-core/canonicalTransactions` | Canonical transaction/money-movement detail interfaces |
+| `@cobre-npm/library-portal-core/canonicalTransactions` | Canonical transaction/money-movement detail interfaces + product type and nature catalogs |
 | `@cobre-npm/library-portal-core/search` | Search / aggregation interfaces |
 | `@cobre-npm/library-portal-core/filterClassification` | Grouped type-filter vocabulary (families, sections, categories), `splitTypeLabel`, group-selection helpers |
 | `@cobre-npm/library-portal-core/trustedSessions` | Trusted session (OTP elevation window) interfaces + constants |
@@ -145,7 +150,7 @@ one-off predicates even where `queryX()` exists.
 
 | Class | When | Signature | Examples |
 |---|---|---|---|
-| **With i18n** | the label depends on the language | `getX(lang)` | accountTypes, counterpartyTypes, movementTypes, transactionTypes, countries, countriesISO, documentTypes |
+| **With i18n** | the label depends on the language | `getX(lang)` | accountTypes, counterpartyTypes, movementTypes, transactionTypes, countries, countriesISO, documentTypes, blockchains, productTypes, natures |
 | **Without i18n** | the label is fixed (or there is none) | `getX()` | currencies (inline label), accountProviders |
 
 `currencies`/`providers` **don't take `lang`** because there's no translation — the signature is honest.
@@ -440,8 +445,10 @@ And two on rule 1: `{ minAmount: 1 }` is equality, not `>=`, which is rarely wha
 ```ts
 import {
   getTransactionTypes, queryTransactionTypes, type TransactionType, type TransactionTypeQuery,
+  collapseTransactionTypes, type TransactionTypeGroup, type TransactionTypeGroupOption,
   type Transaction, type EnrichedTransaction, /* ...interfaces */
 } from "@cobre-npm/library-portal-core/transactions"
+import { isGroupOption, expandGroupSelection } from "@cobre-npm/library-portal-core/filterClassification"
 
 getTransactionTypes("en").spei_debit.label            // "Outgoing transfer · SPEI"
 getTransactionTypes("es-mex").spei_debit.label        // "Transferencia enviada · SPEI"
@@ -458,6 +465,33 @@ queryTransactionTypes({ lang: "en", category: "top_up" })  // col_top_up_credit
   "· débito" / "· crédito" (en "· debit" / "· credit") suffix, except `offramp_treasury_credit`, whose label has none; elsewhere the direction is in the verb
   ("Outgoing transfer", "Incoming transfer"). `col_cb_*` keeps "Cobre Balance" in its label. `misc_*`,
   `internal_*` and `adjustment_*` have `line: "unclassified"`, and `misc_*` also `category: "unclassified"`.
+  Each type also carries a required `section: FilterClassificationSection`, the heading it is listed under in the
+  grouped filter (group members take their group's section; `internal_spei_*`, `col_cb_debit` → `internal`,
+  `misc_*` → `connected_account`).
+- **conditional marker**: five rarely used types (`misc_debit`, `misc_credit`, `col_cb_debit`, `internal_spei_debit`,
+  `internal_spei_credit`) carry `filterDisplay: "when_present"`: the grouped filter should list them only when the
+  data has them. It is descriptive, not a visibility switch: there is no default, `queryTransactionTypes()` still
+  returns them and their labels are unchanged, so flat filters see no difference. The field is absent on every
+  other type, so read it with `"filterDisplay" in type`.
+- **group**: every type carries a required `group: TransactionTypeGroup | null`. The 14 debit/credit legs name
+  one of 7 UI-only groups (`cbmm`, `global_pay_to_usa`, `usa_pay_to_global`, `on_ramp`, `off_ramp`,
+  `stable_payout`, `internal`); every other type is `null`. A group code is **never** a transaction type and is
+  never sent to the API: selecting a group means selecting its member codes (`expandGroupSelection`). There is no
+  separate groups catalog; group labels come out of `collapseTransactionTypes`.
+- **collapse** (i18n): `collapseTransactionTypes({ lang, ...filters })` takes the same query as
+  `queryTransactionTypes`, filters first, then folds each group into one `TransactionTypeGroupOption`
+  `{ code, members, line, category, section, label }`, placed at its first member's position. A group collapses
+  only if **all** its legs survive the filter; otherwise the surviving legs come out as plain options. Tell the
+  two apart with `isGroupOption` (from [`filterClassification`](#filterclassification)), which also feeds
+  `expandGroupSelection` / `getGroupSelectionState`:
+
+  ```ts
+  collapseTransactionTypes({ lang: "en", category: "conversions" }).map(option => option.code)
+  // 7 conversion types → 4 options: ["on_ramp", "off_ramp", "stable_payout", "offramp_treasury_credit"]
+  collapseTransactionTypes({ lang: "en", creditDebitType: "debit" })  // no group survives: plain legs only
+  const groups = collapseTransactionTypes({ lang: "en" }).filter(isGroupOption)
+  expandGroupSelection(["cbmm", "spei_debit"], groups)  // ["cbmm_debit", "cbmm_credit", "spei_debit"]
+  ```
 - **types query** (i18n `queryX()`): `queryTransactionTypes({ lang, ...filters })` — `lang` is **required inside
   the query object**, not a separate argument, so the result is already localized. There is no default field
   (unlike `currencies`' `scope`): every transaction type comes back when only `lang` is given.
@@ -483,7 +517,7 @@ the headings inside a chip, and **types** (movement / transaction types) are the
 ```ts
 import {
   getFilterClassificationCategoryFamilies, getFilterClassificationSections, splitTypeLabel,
-  expandGroupSelection, getGroupSelectionState,
+  expandGroupSelection, getGroupSelectionState, isGroupOption,
   type FilterClassificationCategoryFamily, type FilterClassificationSection,
   type FilterClassificationCategory, type FilterClassificationRecord,
 } from "@cobre-npm/library-portal-core/filterClassification"
@@ -493,6 +527,7 @@ declare const record: { section: FilterClassificationSection }     // one of tho
 declare const groups: FilterClassificationRecord<string>[]         // the UI's group records
 declare const group: FilterClassificationRecord<string>            // one of them
 declare const selectedCodes: string[]                              // what the user has ticked
+declare const options: ({ code: string } | FilterClassificationRecord<string>)[]  // a mixed list: plain and group options
 
 const families = getFilterClassificationCategoryFamilies("en")
 families.between_accounts.label                            // "Between accounts"
@@ -503,6 +538,7 @@ splitTypeLabel("Transfer · ACH")                           // { title: "Transfe
 splitTypeLabel("International")                            // { title: "International" } — no empty rail
 expandGroupSelection(["stablecoin_group", "ach"], groups)  // member codes + "ach"; the group code is never returned
 getGroupSelectionState(group, selectedCodes)               // "checked" | "indeterminate" | "unchecked"
+options.filter(isGroupOption)                              // only the group options, typed as such
 ```
 
 - **Family** (`FilterClassificationCategoryFamily`): the chips of the grouped type filter, in chip order: `payments`, `collections`,
@@ -517,9 +553,9 @@ getGroupSelectionState(group, selectedCodes)               // "checked" | "indet
   never sent to an API. `getFilterClassificationSections(lang)`. `internal` and `connected_account` exist but no movement type uses
   them yet.
 - **`splitTypeLabel(label)`**: splits at the first `" · "` into `{ title, rail? }` for two-line options.
-- **group helpers**: `FilterClassificationRecord<Code>` (`code`, `members`, `line`, `category`, `section`). A group code is a UI
-  identifier: `expandGroupSelection` swaps it for its members before calling an API, and `getGroupSelectionState`
-  gives the checkbox state from the selected member codes.
+- **group helpers**: `FilterClassificationRecord<Code, Member = Code>` (`code`, `members`, `line`, `category`, `section`). A group code is a UI
+  identifier: `expandGroupSelection` swaps it for its members before calling an API, `getGroupSelectionState`
+  gives the checkbox state from the selected member codes, and `isGroupOption` tells group options from plain ones in a mixed list.
 
 ### `trustedSessions`
 
@@ -536,9 +572,30 @@ caller stop attaching an `otp_token` per request while the window is active.
 `constants/trustedSessions.constants.ts` — the pattern for a domain that needs standalone constants
 (no catalog, no i18n): a `constants/<domain>.constants.ts` file, re-exported from the barrel.
 
+### `blockchains`
+
+```ts
+import {
+  getBlockchains, queryBlockchains,
+  type Blockchain, type BlockchainOption, type BlockchainQuery,
+} from "@cobre-npm/library-portal-core/blockchains"
+
+getBlockchains("en").stellar.label       // "Stellar"  → point lookup of a chain code
+queryBlockchains({ lang: "en" })        // the 7 chains as a list → dropdowns
+queryBlockchains({ lang: "en", code: ["tron", "base"] })   // [ tron, base ]
+```
+
+- Single i18n catalog (`code` + `label`), 7 chains: `ethereum`, `tron`, `solana`, `polygon`, `base`, `xrpl`, `stellar`.
+  Labels are proper names, so `en` and `es-mex` match today.
+- No logo field: the logo is a presentation concern of the consumer (Portal derives it from `code`).
+- `counterparty_chain` / `chain` stay `string` in the counterparties and accounts interfaces — a `string` from
+  the backend may not be a `Blockchain`, so consumers narrow it themselves before indexing `getBlockchains()`.
+- No visibility field, so `queryBlockchains({ lang })` returns all 7 (same rule as every `queryX()`: a key that is
+  present always filters, so `{ code: undefined }` returns `[]`).
+
 ### `canonicalTransactions`
 
-Interfaces only (pure types). This is the single source of truth for the canonical money-movement /
+Interfaces plus two small i18n catalogs (`productType`, `nature`). The interfaces are the single source of truth for the canonical money-movement /
 transaction detail — built by `core-portal-bff`'s transaction-canonical BFF, consumed as-is by the
 `portal` MFE (`CanonicalMoneyMovement`), and narrowed with `Pick` by the receipts-generation service:
 
@@ -560,6 +617,17 @@ import type {
   consumers (`portal`, `core-portal-bff`, `util-portal-receipts`) — see `ICanonicalApprovalEvent`'s
   doc comment for one case that's a superset of two non-overlapping shapes rather than a clean merge,
   and revisit it once the real payload is confirmed.
+- **productType / nature** (i18n): `getProductTypes(lang)` / `getNatures(lang)` cover the 5 `product_type` and 6
+  `nature` values of the BFF's `rail-mapper.interface.ts` (the source of truth), and `CanonicalProductType` /
+  `CanonicalNature` are derived from them — `conversion`, `on_ramp` and `off_ramp` used to be missing. `en` labels
+  are the humanized code in Title Case (`on_ramp` → "On Ramp"); `es-mex` labels are Design's copy (`payout` →
+  "Transferencia", `payin` → "Depósito", `cross_border` → "Internacional", `payment` → "Pago", `collection` →
+  "Recaudo", `return` → "Reversión", `on_ramp` → "Conversión a stablecoin", `off_ramp` → "Conversión a moneda
+  local"). Only `getX()` for now (no `queryX()`).
+  They are not duplicates of `businessLines` or `movements/types`: `product_type` is the BFF's per-transaction class
+  and flips with the ledger direction (`payin` ↔ `payout`), whereas a `BusinessLine` is fixed per movement type;
+  the value sets differ (`internal_transfer`, `conversion` vs `cbmm`, `stable`, `unclassified`) and
+  `movements/types` has 26 rail codes, not 5 classes. The only shared label is `cross_border`.
 
 ### `exports`
 

package/dist/cjs/blockchains/catalog.d.ts

@@ -0,0 +1,25 @@
+export declare const BLOCKCHAINS: {
+    readonly ethereum: {
+        readonly code: "ethereum";
+    };
+    readonly tron: {
+        readonly code: "tron";
+    };
+    readonly solana: {
+        readonly code: "solana";
+    };
+    readonly polygon: {
+        readonly code: "polygon";
+    };
+    readonly base: {
+        readonly code: "base";
+    };
+    readonly xrpl: {
+        readonly code: "xrpl";
+    };
+    readonly stellar: {
+        readonly code: "stellar";
+    };
+};
+export type Blockchain = keyof typeof BLOCKCHAINS;
+export type BlockchainRecord = (typeof BLOCKCHAINS)[Blockchain];

package/dist/cjs/blockchains/catalog.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOCKCHAINS = void 0;
+exports.BLOCKCHAINS = {
+    ethereum: { code: "ethereum" },
+    tron: { code: "tron" },
+    solana: { code: "solana" },
+    polygon: { code: "polygon" },
+    base: { code: "base" },
+    xrpl: { code: "xrpl" },
+    stellar: { code: "stellar" },
+};

package/dist/cjs/blockchains/index.d.ts

@@ -0,0 +1,2 @@
+export type { Blockchain } from "./catalog";
+export * from "./utils/blockchain.utils";

package/dist/cjs/blockchains/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils/blockchain.utils"), exports);

package/dist/cjs/blockchains/locales/en.json

@@ -0,0 +1,11 @@
+{
+    "blockchains": {
+        "ethereum": "Ethereum",
+        "tron": "Tron",
+        "solana": "Solana",
+        "polygon": "Polygon",
+        "base": "Base",
+        "xrpl": "XRP Ledger",
+        "stellar": "Stellar"
+    }
+}

package/dist/cjs/blockchains/locales/es-mex.json

@@ -0,0 +1,11 @@
+{
+    "blockchains": {
+        "ethereum": "Ethereum",
+        "tron": "Tron",
+        "solana": "Solana",
+        "polygon": "Polygon",
+        "base": "Base",
+        "xrpl": "XRP Ledger",
+        "stellar": "Stellar"
+    }
+}

package/dist/cjs/blockchains/utils/blockchain.utils.d.ts

@@ -0,0 +1,13 @@
+import type { Blockchain, BlockchainRecord } from "../catalog";
+import type { Locale } from "../../lang";
+import type { CatalogQuery } from "../../utils/catalog-query.utils";
+export type BlockchainOption = BlockchainRecord & {
+    label: string;
+};
+export declare const getBlockchains: (lang: Locale) => Record<Blockchain, BlockchainOption>;
+/** `lang` is required (i18n domain, no default) and travels inside the query object, never positional. */
+export type BlockchainQuery = CatalogQuery<BlockchainRecord> & {
+    lang: Locale;
+};
+/** The catalog as a list, narrowed by the query — see `matchesQuery` for the matching rules. */
+export declare const queryBlockchains: (query: BlockchainQuery) => BlockchainOption[];

package/dist/cjs/blockchains/utils/blockchain.utils.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryBlockchains = exports.getBlockchains = void 0;
+const catalog_1 = require("../catalog");
+const en_json_1 = __importDefault(require("../locales/en.json"));
+const es_mex_json_1 = __importDefault(require("../locales/es-mex.json"));
+const catalog_query_utils_1 = require("../../utils/catalog-query.utils");
+const locales = { en: en_json_1.default, "es-mex": es_mex_json_1.default };
+const getBlockchains = (lang) => {
+    const locale = locales[lang];
+    const result = {};
+    for (const record of Object.values(catalog_1.BLOCKCHAINS)) {
+        result[record.code] = { ...record, label: locale.blockchains[record.code] };
+    }
+    return result;
+};
+exports.getBlockchains = getBlockchains;
+/** The catalog as a list, narrowed by the query — see `matchesQuery` for the matching rules. */
+const queryBlockchains = (query) => {
+    const { lang, ...criteria } = query;
+    const blockchains = (0, exports.getBlockchains)(lang);
+    return Object.values(blockchains).filter(blockchain => (0, catalog_query_utils_1.matchesQuery)(blockchain, criteria));
+};
+exports.queryBlockchains = queryBlockchains;

package/dist/cjs/canonicalTransactions/index.d.ts

@@ -1,2 +1,6 @@
 export * from "./interfaces/response.interface";
 export * from "./interfaces/request.interface";
+export type { ProductType } from "./productType/catalog";
+export * from "./productType/utils/product-type.utils";
+export type { Nature } from "./nature/catalog";
+export * from "./nature/utils/nature.utils";

package/dist/cjs/canonicalTransactions/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./interfaces/response.interface"), exports);
 __exportStar(require("./interfaces/request.interface"), exports);
+__exportStar(require("./productType/utils/product-type.utils"), exports);
+__exportStar(require("./nature/utils/nature.utils"), exports);

package/dist/cjs/canonicalTransactions/interfaces/response.interface.d.ts

@@ -3,9 +3,11 @@ import type { CounterpartyType } from "../../counterparties/types/catalog";
 import type { Currency } from "../../currencies/catalog";
 import type { DocumentType } from "../../documentTypes/catalog";
 import type { MovementStatus } from "../../movements/status/catalog";
+import type { Nature } from "../nature/catalog";
+import type { ProductType } from "../productType/catalog";
 export type CanonicalDirection = "credit" | "debit";
-export type CanonicalProductType = "payout" | "payin" | "internal_transfer" | "cross_border";
-export type CanonicalNature = "payment" | "collection" | "return" | "fx_conversion";
+export type CanonicalProductType = ProductType;
+export type CanonicalNature = Nature;
 export type CanonicalStatusPresentationType = "status-pending" | "info" | "success" | "error" | "neutral" | "warning";
 export type CanonicalAlertType = "danger" | "success" | "warning" | "info";
 export type CanonicalAlertActionType = "open_drawer" | "copy_to_clipboard";

package/dist/cjs/canonicalTransactions/nature/catalog.d.ts

@@ -0,0 +1,22 @@
+export declare const NATURES: {
+    readonly payment: {
+        readonly code: "payment";
+    };
+    readonly collection: {
+        readonly code: "collection";
+    };
+    readonly return: {
+        readonly code: "return";
+    };
+    readonly fx_conversion: {
+        readonly code: "fx_conversion";
+    };
+    readonly on_ramp: {
+        readonly code: "on_ramp";
+    };
+    readonly off_ramp: {
+        readonly code: "off_ramp";
+    };
+};
+export type Nature = keyof typeof NATURES;
+export type NatureRecord = (typeof NATURES)[Nature];

package/dist/cjs/canonicalTransactions/nature/catalog.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATURES = void 0;
+exports.NATURES = {
+    payment: { code: "payment" },
+    collection: { code: "collection" },
+    return: { code: "return" },
+    fx_conversion: { code: "fx_conversion" },
+    on_ramp: { code: "on_ramp" },
+    off_ramp: { code: "off_ramp" },
+};

package/dist/cjs/canonicalTransactions/nature/locales/en.json

@@ -0,0 +1,10 @@
+{
+    "natures": {
+        "payment": "Payment",
+        "collection": "Collection",
+        "return": "Return",
+        "fx_conversion": "FX Conversion",
+        "on_ramp": "On Ramp",
+        "off_ramp": "Off Ramp"
+    }
+}

package/dist/cjs/canonicalTransactions/nature/locales/es-mex.json

@@ -0,0 +1,10 @@
+{
+    "natures": {
+        "payment": "Pago",
+        "collection": "Recaudo",
+        "return": "Reversión",
+        "fx_conversion": "Conversión FX",
+        "on_ramp": "Conversión a stablecoin",
+        "off_ramp": "Conversión a moneda local"
+    }
+}

package/dist/cjs/canonicalTransactions/nature/utils/nature.utils.d.ts

@@ -0,0 +1,6 @@
+import type { Nature, NatureRecord } from "../catalog";
+import type { Locale } from "../../../lang";
+export type NatureOption = NatureRecord & {
+    label: string;
+};
+export declare const getNatures: (lang: Locale) => Record<Nature, NatureOption>;

package/dist/cjs/canonicalTransactions/nature/utils/nature.utils.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNatures = void 0;
+const catalog_1 = require("../catalog");
+const en_json_1 = __importDefault(require("../locales/en.json"));
+const es_mex_json_1 = __importDefault(require("../locales/es-mex.json"));
+const locales = { en: en_json_1.default, "es-mex": es_mex_json_1.default };
+const getNatures = (lang) => {
+    const locale = locales[lang];
+    const result = {};
+    for (const record of Object.values(catalog_1.NATURES)) {
+        result[record.code] = { ...record, label: locale.natures[record.code] };
+    }
+    return result;
+};
+exports.getNatures = getNatures;

package/dist/cjs/canonicalTransactions/productType/catalog.d.ts

@@ -0,0 +1,19 @@
+export declare const PRODUCT_TYPES: {
+    readonly payout: {
+        readonly code: "payout";
+    };
+    readonly payin: {
+        readonly code: "payin";
+    };
+    readonly internal_transfer: {
+        readonly code: "internal_transfer";
+    };
+    readonly cross_border: {
+        readonly code: "cross_border";
+    };
+    readonly conversion: {
+        readonly code: "conversion";
+    };
+};
+export type ProductType = keyof typeof PRODUCT_TYPES;
+export type ProductTypeRecord = (typeof PRODUCT_TYPES)[ProductType];

package/dist/cjs/canonicalTransactions/productType/catalog.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRODUCT_TYPES = void 0;
+/*
+  The BFF's `classification.product_type` (core-portal-bff `rail-mapper.interface.ts`). Not a BusinessLine and not
+  a MovementType, even though `payin`/`payout` share a name with the former:
+  - It is assigned per rail and flips with the ledger direction (a debit `payin` becomes `payout` and a credit
+    `payout` becomes `payin`), while a BusinessLine is a fixed property of each movement type.
+  - It has values a BusinessLine lacks (`internal_transfer`, `conversion`, `cross_border`) and vice versa
+    (`cbmm`, `stable`, `unclassified`), and it needs labels, which `businessLines` does not have.
+*/
+exports.PRODUCT_TYPES = {
+    payout: { code: "payout" },
+    payin: { code: "payin" },
+    internal_transfer: { code: "internal_transfer" },
+    cross_border: { code: "cross_border" },
+    conversion: { code: "conversion" },
+};

package/dist/cjs/canonicalTransactions/productType/locales/en.json

@@ -0,0 +1,9 @@
+{
+    "productTypes": {
+        "payout": "Payout",
+        "payin": "Payin",
+        "internal_transfer": "Internal Transfer",
+        "cross_border": "Cross Border",
+        "conversion": "Conversion"
+    }
+}

package/dist/cjs/canonicalTransactions/productType/locales/es-mex.json

@@ -0,0 +1,9 @@
+{
+    "productTypes": {
+        "payout": "Transferencia",
+        "payin": "Depósito",
+        "internal_transfer": "Transferencia interna",
+        "cross_border": "Internacional",
+        "conversion": "Conversión"
+    }
+}

package/dist/cjs/canonicalTransactions/productType/utils/product-type.utils.d.ts

@@ -0,0 +1,6 @@
+import type { ProductType, ProductTypeRecord } from "../catalog";
+import type { Locale } from "../../../lang";
+export type ProductTypeOption = ProductTypeRecord & {
+    label: string;
+};
+export declare const getProductTypes: (lang: Locale) => Record<ProductType, ProductTypeOption>;

package/dist/cjs/canonicalTransactions/productType/utils/product-type.utils.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProductTypes = void 0;
+const catalog_1 = require("../catalog");
+const en_json_1 = __importDefault(require("../locales/en.json"));
+const es_mex_json_1 = __importDefault(require("../locales/es-mex.json"));
+const locales = { en: en_json_1.default, "es-mex": es_mex_json_1.default };
+const getProductTypes = (lang) => {
+    const locale = locales[lang];
+    const result = {};
+    for (const record of Object.values(catalog_1.PRODUCT_TYPES)) {
+        result[record.code] = { ...record, label: locale.productTypes[record.code] };
+    }
+    return result;
+};
+exports.getProductTypes = getProductTypes;

package/dist/cjs/filterClassification/interfaces/filter-classification.interface.d.ts

@@ -5,9 +5,9 @@ import type { FilterClassificationSection } from "../sections/catalog";
  * A selectable group of type codes (one checkbox that stands for several types). The group `code` is a UI
  * identifier: it is never sent to an API, only its `members` are — see `expandGroupSelection`.
  */
-export type FilterClassificationRecord<Code extends string> = {
+export type FilterClassificationRecord<Code extends string, Member extends string = Code> = {
     readonly code: Code;
-    readonly members: readonly Code[];
+    readonly members: readonly Member[];
     readonly line: BusinessLine;
     readonly category: FilterClassificationCategory;
     readonly section: FilterClassificationSection;

package/dist/cjs/filterClassification/utils/type-group.utils.d.ts

@@ -1,9 +1,13 @@
 import type { FilterClassificationRecord } from "../interfaces/filter-classification.interface";
 export type GroupSelectionState = "checked" | "indeterminate" | "unchecked";
+/** Tells a group option (it has `members`) from a plain option, narrowing a mixed list of both. */
+export declare const isGroupOption: <Option extends object>(option: Option) => option is Extract<Option, {
+    readonly members: readonly string[];
+}>;
 /**
  * The codes to send to an API: each selected group code is replaced by its members, anything else passes
  * through. The group code itself never appears in the output, and repeated codes are dropped.
  */
-export declare const expandGroupSelection: <Code extends string>(selected: readonly Code[], groups: readonly FilterClassificationRecord<Code>[]) => Code[];
+export declare const expandGroupSelection: <Code extends string, Member extends string = Code>(selected: readonly (Code | Member)[], groups: readonly FilterClassificationRecord<Code, Member>[]) => Member[];
 /** checked = every member selected, indeterminate = some, unchecked = none (or a group without members). */
-export declare const getGroupSelectionState: <Code extends string>(group: FilterClassificationRecord<Code>, selected: readonly Code[]) => GroupSelectionState;
+export declare const getGroupSelectionState: <Code extends string, Member extends string = Code>(group: FilterClassificationRecord<Code, Member>, selected: readonly Member[]) => GroupSelectionState;

package/dist/cjs/filterClassification/utils/type-group.utils.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGroupSelectionState = exports.expandGroupSelection = void 0;
+exports.getGroupSelectionState = exports.expandGroupSelection = exports.isGroupOption = void 0;
+/** Tells a group option (it has `members`) from a plain option, narrowing a mixed list of both. */
+const isGroupOption = (option) => "members" in option;
+exports.isGroupOption = isGroupOption;
 /**
  * The codes to send to an API: each selected group code is replaced by its members, anything else passes
  * through. The group code itself never appears in the output, and repeated codes are dropped.

package/dist/cjs/transactions/index.d.ts

@@ -1,3 +1,3 @@
-export type { TransactionType } from "./types/catalog";
+export type { TransactionType, TransactionTypeGroup } from "./types/catalog";
 export * from "./types/utils/transaction-type.utils";
 export * from "./interfaces/response.interface";