@cobre-npm/library-portal-core 0.55.0 → 0.57.0

package/README.md

@@ -39,12 +39,14 @@ import { getCountries }    from "@cobre-npm/library-portal-core/countries"
 | `@cobre-npm/library-portal-core/counterparties` | Counterparty types + `Counterparty` interfaces |
 | `@cobre-npm/library-portal-core/countries` | Countries (base) and ISO countries (dialing codes, etc.) |
 | `@cobre-npm/library-portal-core/movements` | Movement types and statuses |
+| `@cobre-npm/library-portal-core/businessLines` | Cobre's lines of business (LoB) |
 | `@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/transactions` | Transaction types + interfaces |
 | `@cobre-npm/library-portal-core/canonicalTransactions` | Canonical transaction/money-movement detail interfaces |
 | `@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 |
 | `@cobre-npm/library-portal-core/exports` | Export request/response entity + the engine's format/operator allow-lists |
 | `@cobre-npm/library-portal-core/financialInstitutions` | Financial institutions (banks) by country, with labels |
@@ -254,44 +256,37 @@ queryCountries({ lang, ...(codes ? { code: codes } : {}) })
 
 ```ts
 import {
-  getMovementTypes, queryMovementTypes, type MovementType, type MovementTypeGroupLabel,
+  getMovementTypes, queryMovementTypes, type MovementType,
   type MovementTypeOption, type MovementTypeQuery,
-  type ClassificationLine, type ClassificationCategory,
   getMovementStatuses, queryMovementStatuses, type MovementStatus, type MovementStatusType,
   type MovementStatusOption, type MovementStatusQuery,
 } from "@cobre-npm/library-portal-core/movements"
 
 getMovementTypes("en").ach.label                    // "Transfer · ACH"
-getMovementTypes("en").on_ramp.groupLabel            // "Stablecoin"
+getMovementTypes("en").on_ramp.section               // "stablecoin"
 getMovementTypes("en").on_ramp.label                 // "Conversion to stablecoin" (individual label)
 getMovementTypes("en").spei.category                 // "payments"
 queryMovementTypes({ lang: "en", category: "top_up" })        // r2p_top_up_bancolombia, r2p_top_up_pse
-queryMovementTypes({ lang: "en", groupLabel: "Stablecoin" })  // global, off_ramp, on_ramp, stable_payout
+queryMovementTypes({ lang: "en", section: "stablecoin" })  // global, off_ramp, on_ramp, stable_payout
 getMovementStatuses("en").completed             // { code: "completed", label: "Completed", type: "success", icon: "icon-check" }
 queryMovementStatuses({ lang: "en", type: "error" })  // error, failed, rejected — localized
 ```
 
 - **types** (i18n): movement types, usually labelled as "what you did · rail" (`Transfer · SPEI`,
   `Collection · Bre-B`). Movement and transaction types share one classification, carried on each record as
-  codes, not translated text (nothing displays them yet): `line: ClassificationLine`
-  (`payin | payout | cbmm | stable | unclassified`) and `category: ClassificationCategory`
-  (`payments | collections | conversions | international | between_accounts | top_up | adjustment |
-  reward | unclassified`). Both types are exported from `/movements` and `/transactions` (the same types on
-  both subpaths). `on_ramp`/`off_ramp`/`stable_payout`/`global`
-  additionally carry `groupLabel: "Stablecoin"` — a display grouping for views that need to show them
-  under one label. `getMovementTypes()` keeps returning each rail's own individual `label` unchanged; a
-  consumer that wants the grouped label picks `groupLabel ?? label`. There's no separate `getXLabel`
-  for this — the value already comes back inside `getMovementTypes()`, same as everything else in this
-  catalog.
+  codes, not translated text (nothing displays them yet): `line: BusinessLine`
+  (`payin | payout | cbmm | stable | unclassified`, defined in [`businessLines`](#businesslines)) and
+  `category: FilterClassificationCategory` (`payments | collections | conversions | international | between_accounts | top_up |
+  adjustment | reward | unclassified`, defined in [`filterClassification`](#filterclassification)). Each movement type also carries a
+  `section: FilterClassificationSection` (`cop | mxn | usd_global | eur | corridors | stablecoin | …`), the heading it
+  is listed under in grouped filters. `getMovementTypes()` returns each rail's own `label` unchanged.
 - **types query** (i18n `queryX()`): `queryMovementTypes({ lang, ...filters })` — same rules as
-  `queryTransactionTypes`/`queryDocumentTypes`, no default field. `code`, `line`, `category`, `group` and
-  `groupLabel` are filterable (equality only; a list matches any of its values). Filter by `group`, not
-  `groupLabel` — the label is display text. Both are optional on the record: **a key that is present always filters**, so
-  `groupLabel: undefined` matches the rails that don't carry a group, not "no filter". An optional UI
+  `queryTransactionTypes`/`queryDocumentTypes`, no default field. `code`, `line`, `category` and `section` are
+  filterable (equality only; a list matches any of its values). A present key always filters, so an optional UI
   filter has to be spread in conditionally:
 
   ```ts
-  queryMovementTypes({ lang, ...(group.value ? { groupLabel: group.value } : {}) })
+  queryMovementTypes({ lang, ...(section.value ? { section: section.value } : {}) })
   ```
 - **status** (i18n): movement statuses (`initiated`, `processing`, `completed`, …). Each record also
   carries `type: MovementStatusType` (`success | warning | error | info | neutral | pending`) — a
@@ -306,6 +301,21 @@ queryMovementStatuses({ lang: "en", type: "error" })  // error, failed, rejected
   the real use case: `queryMovementStatuses({ lang, type: "error" })` returns `error`, `failed`,
   `rejected`, replacing a hand-maintained list of codes with a query.
 
+### `businessLines`
+
+Cobre's lines of business (LoB). No i18n (no labels exist yet), so `getBusinessLines()` takes no arguments.
+
+```ts
+import { getBusinessLines, type BusinessLine } from "@cobre-npm/library-portal-core/businessLines"
+
+getBusinessLines().cbmm  // { code: "cbmm" }
+```
+
+- **lines**: `payin`, `payout`, `cbmm`, `stable`, `unclassified`. `BusinessLine` is the type of the `line` field of
+  movement and transaction types.
+- `/movements` and `/transactions` no longer re-export the line/category types (formerly `ClassificationLine` /
+  `ClassificationCategory`): use `BusinessLine` from `/businessLines` and `FilterClassificationCategory` from [`/filterClassification`](#filterclassification).
+
 ### `subclients`
 
 ```ts
@@ -430,9 +440,10 @@ And two on rule 1: `{ minAmount: 1 }` is equality, not `>=`, which is rarely wha
 ```ts
 import {
   getTransactionTypes, queryTransactionTypes, type TransactionType, type TransactionTypeQuery,
-  type ClassificationLine, type ClassificationCategory,
+  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"
@@ -442,13 +453,40 @@ queryTransactionTypes({ lang: "en", category: "top_up" })  // col_top_up_credit
 
 - **types** (i18n): `getTransactionTypes(lang)`; each record carries `code`, `creditDebitType`
   (`"credit" | "debit"` — the same `CreditDebitType` used by the `Transaction` interface), `label`, and the same
-  `line: ClassificationLine` / `category: ClassificationCategory` codes as movement types (value sets
+  `line: BusinessLine` / `category: FilterClassificationCategory` codes as movement types (value sets
   listed under [`movements`](#movements)). Labels are usually "what you did · rail" (`Outgoing transfer ·
   SPEI`). Types that stand for a collapsed matrix row (`cbmm_*`, `internal_*`, `mex_*`, `col_debit`/`col_credit`, `misc_*`,
   `adjustment_*`, `col_cb_*`, the corridors, ramps and `stable_payout_*`, plus `transfer_credit`) add a
   "· 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.
@@ -457,12 +495,68 @@ queryTransactionTypes({ lang: "en", category: "top_up" })  // col_top_up_credit
   `queryTransactionTypes({ lang: "en", line: "payin", category: "collections" })`.
 - **interfaces**: `Transaction`, `EnrichedTransaction`, `TransactionMetadata`, `CreditDebitType`.
 
-### `search` / `trustedSessions`
+### `search`
 
-Interfaces only (pure types):
+Interfaces only (pure types): the Cobre Search request/response contract.
 
 ```ts
 import type { SearchRequest, SearchResponse, SearchFilter } from "@cobre-npm/library-portal-core/search"
+```
+
+### `filterClassification`
+
+The vocabulary of the grouped type filter, shared by movement and transaction types and owned by neither (some
+transactions, like adjustments and rewards, have no money movement): **families** are the chips, **sections** are
+the headings inside a chip, and **types** (movement / transaction types) are the options.
+
+```ts
+import {
+  getFilterClassificationCategoryFamilies, getFilterClassificationSections, splitTypeLabel,
+  expandGroupSelection, getGroupSelectionState, isGroupOption,
+  type FilterClassificationCategoryFamily, type FilterClassificationSection,
+  type FilterClassificationCategory, type FilterClassificationRecord,
+} from "@cobre-npm/library-portal-core/filterClassification"
+
+declare const types: { category: FilterClassificationCategory }[]  // e.g. Object.values(getMovementTypes("en"))
+declare const record: { section: FilterClassificationSection }     // one of those types
+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"
+families.between_accounts.categories                       // ["between_accounts", "adjustment", "reward"]
+types.filter(type => families.between_accounts.categories.includes(type.category))  // group types by family
+getFilterClassificationSections("es-mex")[record.section].label  // "Corredores"
+splitTypeLabel("Transfer · ACH")                           // { title: "Transfer", rail: "ACH" }
+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`,
+  `international`, `conversions`, `top_up`, `between_accounts` and `unclassified`. Each family lists the
+  `categories` it groups, and a category belongs to exactly one family (`adjustment` and `reward` fold into
+  `between_accounts`). `getFilterClassificationCategoryFamilies(lang)` returns each family with its label and categories; `lang` is required.
+- **Category** (`FilterClassificationCategory`): derived from the families' lists: `payments`, `collections`, `conversions`,
+  `international`, `between_accounts`, `top_up`, `adjustment`, `reward`, `unclassified`. The family is never stored
+  per record: group types by family with `getFilterClassificationCategoryFamilies(lang)[family].categories.includes(type.category)`.
+- **Section** (`FilterClassificationSection`): groups types by currency, rail or corridor (`cop`, `mxn`, `usd_global`, `eur`,
+  `corridors`, `stablecoin`). It is stored per type, used as a heading in the grouped filter, never selectable and
+  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, 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`
+
+Interfaces only (pure types):
+
+```ts
 import type { TrustedSessionStatus } from "@cobre-npm/library-portal-core/trustedSessions"
 ```
 

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

@@ -0,0 +1,19 @@
+export declare const BUSINESS_LINES: {
+    readonly payin: {
+        readonly code: "payin";
+    };
+    readonly payout: {
+        readonly code: "payout";
+    };
+    readonly cbmm: {
+        readonly code: "cbmm";
+    };
+    readonly stable: {
+        readonly code: "stable";
+    };
+    readonly unclassified: {
+        readonly code: "unclassified";
+    };
+};
+export type BusinessLine = keyof typeof BUSINESS_LINES;
+export type BusinessLineRecord = (typeof BUSINESS_LINES)[BusinessLine];

package/dist/cjs/businessLines/catalog.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUSINESS_LINES = void 0;
+exports.BUSINESS_LINES = {
+    payin: { code: "payin" },
+    payout: { code: "payout" },
+    cbmm: { code: "cbmm" },
+    stable: { code: "stable" },
+    unclassified: { code: "unclassified" },
+};

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

@@ -0,0 +1,2 @@
+export type { BusinessLine, BusinessLineRecord } from "./catalog";
+export * from "./utils/business-line.utils";

package/dist/cjs/businessLines/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/business-line.utils"), exports);

package/dist/cjs/businessLines/utils/business-line.utils.d.ts

@@ -0,0 +1,2 @@
+import type { BusinessLine, BusinessLineRecord } from "../catalog";
+export declare const getBusinessLines: () => Record<BusinessLine, BusinessLineRecord>;

package/dist/cjs/businessLines/utils/business-line.utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBusinessLines = void 0;
+const catalog_1 = require("../catalog");
+const getBusinessLines = () => catalog_1.BUSINESS_LINES;
+exports.getBusinessLines = getBusinessLines;

package/dist/cjs/filterClassification/categoryFamilies/catalog.d.ts

@@ -0,0 +1,33 @@
+export declare const FILTER_CLASSIFICATION_CATEGORY_FAMILIES: {
+    readonly payments: {
+        readonly code: "payments";
+        readonly categories: readonly ["payments"];
+    };
+    readonly collections: {
+        readonly code: "collections";
+        readonly categories: readonly ["collections"];
+    };
+    readonly international: {
+        readonly code: "international";
+        readonly categories: readonly ["international"];
+    };
+    readonly conversions: {
+        readonly code: "conversions";
+        readonly categories: readonly ["conversions"];
+    };
+    readonly top_up: {
+        readonly code: "top_up";
+        readonly categories: readonly ["top_up"];
+    };
+    readonly between_accounts: {
+        readonly code: "between_accounts";
+        readonly categories: readonly ["between_accounts", "adjustment", "reward"];
+    };
+    readonly unclassified: {
+        readonly code: "unclassified";
+        readonly categories: readonly ["unclassified"];
+    };
+};
+export type FilterClassificationCategoryFamily = keyof typeof FILTER_CLASSIFICATION_CATEGORY_FAMILIES;
+export type FilterClassificationCategoryFamilyRecord = (typeof FILTER_CLASSIFICATION_CATEGORY_FAMILIES)[FilterClassificationCategoryFamily];
+export type FilterClassificationCategory = FilterClassificationCategoryFamilyRecord["categories"][number];

package/dist/cjs/filterClassification/categoryFamilies/catalog.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILTER_CLASSIFICATION_CATEGORY_FAMILIES = void 0;
+exports.FILTER_CLASSIFICATION_CATEGORY_FAMILIES = {
+    payments: { code: "payments", categories: ["payments"] },
+    collections: { code: "collections", categories: ["collections"] },
+    international: { code: "international", categories: ["international"] },
+    conversions: { code: "conversions", categories: ["conversions"] },
+    top_up: { code: "top_up", categories: ["top_up"] },
+    between_accounts: { code: "between_accounts", categories: ["between_accounts", "adjustment", "reward"] },
+    unclassified: { code: "unclassified", categories: ["unclassified"] },
+};

package/dist/cjs/filterClassification/categoryFamilies/locales/en.json

@@ -0,0 +1,11 @@
+{
+    "categoryFamilies": {
+        "payments": "Payments",
+        "collections": "Collections",
+        "international": "International",
+        "conversions": "Conversions",
+        "top_up": "Top-up",
+        "between_accounts": "Between accounts",
+        "unclassified": "Unclassified"
+    }
+}

package/dist/cjs/filterClassification/categoryFamilies/locales/es-mex.json

@@ -0,0 +1,11 @@
+{
+    "categoryFamilies": {
+        "payments": "Pagos",
+        "collections": "Recaudos",
+        "international": "Internacional",
+        "conversions": "Conversiones",
+        "top_up": "Recarga",
+        "between_accounts": "Entre cuentas",
+        "unclassified": "Sin clasificar"
+    }
+}

package/dist/cjs/filterClassification/categoryFamilies/utils/filter-classification-category-family.utils.d.ts

@@ -0,0 +1,8 @@
+import type { FilterClassificationCategory, FilterClassificationCategoryFamily } from "../catalog";
+import type { Locale } from "../../../lang";
+export type FilterClassificationCategoryFamilyOption = {
+    code: FilterClassificationCategoryFamily;
+    categories: readonly FilterClassificationCategory[];
+    label: string;
+};
+export declare const getFilterClassificationCategoryFamilies: (lang: Locale) => Record<FilterClassificationCategoryFamily, FilterClassificationCategoryFamilyOption>;

package/dist/cjs/filterClassification/categoryFamilies/utils/filter-classification-category-family.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.getFilterClassificationCategoryFamilies = 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 getFilterClassificationCategoryFamilies = (lang) => {
+    const locale = locales[lang];
+    const result = {};
+    for (const record of Object.values(catalog_1.FILTER_CLASSIFICATION_CATEGORY_FAMILIES)) {
+        result[record.code] = { ...record, label: locale.categoryFamilies[record.code] };
+    }
+    return result;
+};
+exports.getFilterClassificationCategoryFamilies = getFilterClassificationCategoryFamilies;

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

@@ -0,0 +1,7 @@
+export type { FilterClassificationRecord } from "./interfaces/filter-classification.interface";
+export type { FilterClassificationCategory, FilterClassificationCategoryFamily } from "./categoryFamilies/catalog";
+export * from "./categoryFamilies/utils/filter-classification-category-family.utils";
+export type { FilterClassificationSection } from "./sections/catalog";
+export * from "./sections/utils/filter-classification-section.utils";
+export * from "./utils/type-label.utils";
+export * from "./utils/type-group.utils";

package/dist/cjs/filterClassification/index.js

@@ -0,0 +1,20 @@
+"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("./categoryFamilies/utils/filter-classification-category-family.utils"), exports);
+__exportStar(require("./sections/utils/filter-classification-section.utils"), exports);
+__exportStar(require("./utils/type-label.utils"), exports);
+__exportStar(require("./utils/type-group.utils"), exports);

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

@@ -0,0 +1,14 @@
+import type { BusinessLine } from "../../businessLines/catalog";
+import type { FilterClassificationCategory } from "../categoryFamilies/catalog";
+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, Member extends string = Code> = {
+    readonly code: Code;
+    readonly members: readonly Member[];
+    readonly line: BusinessLine;
+    readonly category: FilterClassificationCategory;
+    readonly section: FilterClassificationSection;
+};

package/dist/cjs/filterClassification/interfaces/filter-classification.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/filterClassification/sections/catalog.d.ts

@@ -0,0 +1,28 @@
+export declare const FILTER_CLASSIFICATION_SECTIONS: {
+    readonly cop: {
+        readonly code: "cop";
+    };
+    readonly mxn: {
+        readonly code: "mxn";
+    };
+    readonly usd_global: {
+        readonly code: "usd_global";
+    };
+    readonly eur: {
+        readonly code: "eur";
+    };
+    readonly corridors: {
+        readonly code: "corridors";
+    };
+    readonly stablecoin: {
+        readonly code: "stablecoin";
+    };
+    readonly internal: {
+        readonly code: "internal";
+    };
+    readonly connected_account: {
+        readonly code: "connected_account";
+    };
+};
+export type FilterClassificationSection = keyof typeof FILTER_CLASSIFICATION_SECTIONS;
+export type FilterClassificationSectionRecord = (typeof FILTER_CLASSIFICATION_SECTIONS)[FilterClassificationSection];

package/dist/cjs/filterClassification/sections/catalog.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILTER_CLASSIFICATION_SECTIONS = void 0;
+exports.FILTER_CLASSIFICATION_SECTIONS = {
+    cop: { code: "cop" },
+    mxn: { code: "mxn" },
+    usd_global: { code: "usd_global" },
+    eur: { code: "eur" },
+    corridors: { code: "corridors" },
+    stablecoin: { code: "stablecoin" },
+    internal: { code: "internal" },
+    connected_account: { code: "connected_account" },
+};

package/dist/cjs/filterClassification/sections/locales/en.json

@@ -0,0 +1,12 @@
+{
+    "sections": {
+        "cop": "COP",
+        "mxn": "MXN",
+        "usd_global": "USD / Global",
+        "eur": "EUR",
+        "corridors": "Corridors",
+        "stablecoin": "Stablecoin",
+        "internal": "Internal",
+        "connected_account": "Connected account"
+    }
+}

package/dist/cjs/filterClassification/sections/locales/es-mex.json

@@ -0,0 +1,12 @@
+{
+    "sections": {
+        "cop": "COP",
+        "mxn": "MXN",
+        "usd_global": "USD / Global",
+        "eur": "EUR",
+        "corridors": "Corredores",
+        "stablecoin": "Stablecoin",
+        "internal": "Internas",
+        "connected_account": "Cuenta conectada"
+    }
+}

package/dist/cjs/filterClassification/sections/utils/filter-classification-section.utils.d.ts

@@ -0,0 +1,7 @@
+import type { FilterClassificationSection, FilterClassificationSectionRecord } from "../catalog";
+import type { Locale } from "../../../lang";
+export type FilterClassificationSectionOption = FilterClassificationSectionRecord & {
+    label: string;
+};
+/** The section headings indexed by code, each with its label. A section is a heading: never selectable, never sent to an API. */
+export declare const getFilterClassificationSections: (lang: Locale) => Record<FilterClassificationSection, FilterClassificationSectionOption>;

package/dist/cjs/filterClassification/sections/utils/filter-classification-section.utils.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilterClassificationSections = 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 };
+/** The section headings indexed by code, each with its label. A section is a heading: never selectable, never sent to an API. */
+const getFilterClassificationSections = (lang) => {
+    const locale = locales[lang];
+    const result = {};
+    for (const record of Object.values(catalog_1.FILTER_CLASSIFICATION_SECTIONS)) {
+        result[record.code] = { ...record, label: locale.sections[record.code] };
+    }
+    return result;
+};
+exports.getFilterClassificationSections = getFilterClassificationSections;

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

@@ -0,0 +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, 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, Member extends string = Code>(group: FilterClassificationRecord<Code, Member>, selected: readonly Member[]) => GroupSelectionState;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.
+ */
+const expandGroupSelection = (selected, groups) => {
+    const membersByGroup = new Map(groups.map(group => [group.code, group.members]));
+    const expanded = selected.flatMap(code => membersByGroup.get(code) ?? [code]);
+    return [...new Set(expanded)];
+};
+exports.expandGroupSelection = expandGroupSelection;
+/** checked = every member selected, indeterminate = some, unchecked = none (or a group without members). */
+const getGroupSelectionState = (group, selected) => {
+    const count = group.members.filter(member => selected.includes(member)).length;
+    if (count === 0)
+        return "unchecked";
+    return count === group.members.length ? "checked" : "indeterminate";
+};
+exports.getGroupSelectionState = getGroupSelectionState;

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

@@ -0,0 +1,9 @@
+export type SplitTypeLabel = {
+    title: string;
+    rail?: string;
+};
+/**
+ * Splits a type label ("Transfer · ACH") at its FIRST " · " into a title and a rail, for two-line options.
+ * A label without the separator, or with nothing after it, comes back as `{ title }` alone — never an empty `rail`.
+ */
+export declare const splitTypeLabel: (label: string) => SplitTypeLabel;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitTypeLabel = void 0;
+const SEPARATOR = " · ";
+/**
+ * Splits a type label ("Transfer · ACH") at its FIRST " · " into a title and a rail, for two-line options.
+ * A label without the separator, or with nothing after it, comes back as `{ title }` alone — never an empty `rail`.
+ */
+const splitTypeLabel = (label) => {
+    const index = label.indexOf(SEPARATOR);
+    if (index === -1)
+        return { title: label };
+    const title = label.slice(0, index);
+    const rail = label.slice(index + SEPARATOR.length);
+    return rail === "" ? { title } : { title, rail };
+};
+exports.splitTypeLabel = splitTypeLabel;

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

@@ -1,4 +1,4 @@
-export type { ClassificationCategory, ClassificationLine, MovementType, MovementTypeGroup, MovementTypeGroupLabel } from "./types/catalog";
+export type { MovementType } from "./types/catalog";
 export * from "./types/utils/movement-type.utils";
 export type { MovementStatus, MovementStatusType } from "./status/catalog";
 export * from "./status/utils/movement-status.utils";