lib-fints 1.3.1 → 1.4.1

package/README.md

@@ -28,12 +28,14 @@ In theory the library is compatible with a browser environment, but communicatin
 
 ### Installing
 
-Installation is straight forward by simply adding the npm package. The package has no further dependencies on other packages.
+Installation is straight forward by simply adding the npm package.
 
 ```
 npm i lib-fints
 ```
 
+**Dependencies**: The library includes the `fast-xml-parser` package for robust CAMT statement parsing but has no other runtime dependencies.
+
 ### Sample Usage
 
 The main public API of this library is the `FinTSClient` class and `FinTSConfig` class. In order to instantiate the client you need to provide a configuration instance. There are basically two ways to initialize a configuration object, one is when you communicate with a bank for the first time and the other when you already have banking information from a prevous session available (more on that later).
@@ -59,10 +61,10 @@ If the call is successfull the response will contain a `bankingInformation` obje
 
 ```typescript
 export type BankingInformation = {
-	systemId: string;
-	bpd?: BPD;
-	upd?: UPD;
-	bankMessages: BankMessage[];
+  systemId: string;
+  bpd?: BPD;
+  upd?: UPD;
+  bankMessages: BankMessage[];
 };
 ```
 
@@ -104,22 +106,22 @@ Most transactions may require authorization with a two step TAN process. As ment
 ```typescript
 // we use the node readline interface later to ask the user for a TAN
 const rl = readline.createInterface({
-	input: process.stdin,
-	output: process.stdout,
+  input: process.stdin,
+  output: process.stdout,
 });
 
 let response = await client.getAccountStatements(account.accountNumber);
 
 if (!response.success) {
-	return;
+  return;
 }
 
 // need to check if a TAN is required to continue the transaction
 if (response.requiresTan) {
-	// asking the user for the TAN, using the tanChallenge property
-	const tan = await rl.question(response.tanChallenge + ': ');
-	// continue the transaction by providing the tanReference from the response and the entered TAN
-	response = await client.getAccountStatementsWithTan(response.tanReference!, tan);
+  // asking the user for the TAN, using the tanChallenge property
+  const tan = await rl.question(response.tanChallenge + ': ');
+  // continue the transaction by providing the tanReference from the response and the entered TAN
+  response = await client.getAccountStatementsWithTan(response.tanReference!, tan);
 }
 ```
 
@@ -140,13 +142,13 @@ This not only saves you from making the same synchronization requests every time
 
 ```typescript
 const config = FinTSConfig.fromBankingInformation(
-	productId,
-	productVersion,
-	bankingInformation,
-	userId,
-	pin,
-	tanMethodId,
-	tanMediaName // when also needed (see below)
+  productId,
+  productVersion,
+  bankingInformation,
+  userId,
+  pin,
+  tanMethodId,
+  tanMediaName // when also needed (see below)
 );
 const client = new FinTSClient(config);
 ```
@@ -161,12 +163,12 @@ You can get a list of all available TAN methods from the `config.availableTanMet
 
 ```typescript
 export type TanMethod = {
-	id: number;
-	name: string;
-	version: number;
-	activeTanMediaCount: number;
-	activeTanMedia: string[];
-	tanMediaRequirement: TanMediaRequirement;
+  id: number;
+  name: string;
+  version: number;
+  activeTanMediaCount: number;
+  activeTanMedia: string[];
+  tanMediaRequirement: TanMediaRequirement;
 };
 ```
 
@@ -192,26 +194,26 @@ This will print out all sent messages and received responses to the console in a
 
 The following table shows all transactions supported by the FinTSClient interface:
 
-| Transaction                | Method                                                               | Description                                                                   | FinTS Segment(s)           | TAN Support | Account-Specific |
-| -------------------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------- | ----------- | ---------------- |
-| **Synchronization**        | `synchronize()`                                                      | Synchronizes bank and account information, updating config.bankingInformation | HKIDN, HKVVB, HKSYN, HKTAB | ✓           | ❌               |
-| **Account Balance**        | `getAccountBalance(accountNumber)`                                   | Fetches the current balance for a specific account                            | HKSAL                      | ✓           | ✓                |
-| **Account Statements**     | `getAccountStatements(accountNumber, from?, to?)`                    | Fetches account transactions/statements for a date range                      | HKKAZ                      | ✓           | ✓                |
-| **Portfolio**              | `getPortfolio(accountNumber, currency?, priceQuality?, maxEntries?)` | Fetches securities portfolio information for depot accounts                   | HKWPD                      | ✓           | ✓                |
-| **Credit Card Statements** | `getCreditCardStatements(accountNumber, from?)`                      | Fetches credit card statements for credit card accounts                       | DKKKU                      | ✓           | ✓                |
-| **TAN Method Selection**   | `selectTanMethod(tanMethodId)`                                       | Selects a TAN method by ID from available methods                             | -                          | ❌          | ❌               |
-| **TAN Media Selection**    | `selectTanMedia(tanMediaName)`                                       | Selects a specific TAN media device by name                                   | -                          | ❌          | ❌               |
+| Transaction                | Method                                                               | Description                                                                     | FinTS Segment(s)           | TAN Support | Account-Specific |
+| -------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------- | -------------------------- | ----------- | ---------------- |
+| **Synchronization**        | `synchronize()`                                                      | Synchronizes bank and account information, updating config.bankingInformation   | HKIDN, HKVVB, HKSYN, HKTAB | ✓           | ❌               |
+| **Account Balance**        | `getAccountBalance(accountNumber)`                                   | Fetches the current balance for a specific account                              | HKSAL                      | ✓           | ✓                |
+| **Account Statements**     | `getAccountStatements(accountNumber, from?, to?)`                    | Fetches account transactions/statements for a date range (MT940 or CAMT format) | HKKAZ, HKCAZ               | ✓           | ✓                |
+| **Portfolio**              | `getPortfolio(accountNumber, currency?, priceQuality?, maxEntries?)` | Fetches securities portfolio information for depot accounts                     | HKWPD                      | ✓           | ✓                |
+| **Credit Card Statements** | `getCreditCardStatements(accountNumber, from?)`                      | Fetches credit card statements for credit card accounts                         | DKKKU                      | ✓           | ✓                |
+| **TAN Method Selection**   | `selectTanMethod(tanMethodId)`                                       | Selects a TAN method by ID from available methods                               | -                          | ❌          | ❌               |
+| **TAN Media Selection**    | `selectTanMedia(tanMediaName)`                                       | Selects a specific TAN media device by name                                     | -                          | ❌          | ❌               |
 
 ### Transaction Support Checking
 
 For each account-specific transaction, the client provides corresponding `can*` methods to check if the bank or specific account supports the transaction:
 
-| Support Check Method                         | Purpose                                                |
-| -------------------------------------------- | ------------------------------------------------------ |
-| `canGetAccountBalance(accountNumber?)`       | Checks if account balance fetching is supported        |
-| `canGetAccountStatements(accountNumber?)`    | Checks if account statements fetching is supported     |
-| `canGetPortfolio(accountNumber?)`            | Checks if portfolio information fetching is supported  |
-| `canGetCreditCardStatements(accountNumber?)` | Checks if credit card statements fetching is supported |
+| Support Check Method                         | Purpose                                                         |
+| -------------------------------------------- | --------------------------------------------------------------- |
+| `canGetAccountBalance(accountNumber?)`       | Checks if account balance fetching is supported                 |
+| `canGetAccountStatements(accountNumber?)`    | Checks if account statements fetching is supported (MT940/CAMT) |
+| `canGetPortfolio(accountNumber?)`            | Checks if portfolio information fetching is supported           |
+| `canGetCreditCardStatements(accountNumber?)` | Checks if credit card statements fetching is supported          |
 
 ### TAN Continuation Methods
 
@@ -242,6 +244,7 @@ Implementing further transactions should be straight forward and contributions a
 ## Built With
 
 - [Typescript](https://www.typescriptlang.org/) - Programming Language
+- [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser) - XML parsing for CAMT statements
 - [Vitest](https://vitest.dev/) - Testing Framework
 - [pnpm](https://pnpm.io/) - Package manager
 

package/dist/camtParser.js

@@ -0,0 +1,412 @@
+import { XMLParser, XMLValidator } from 'fast-xml-parser';
+export class CamtParsingError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'CamtParsingError';
+    }
+}
+export class CamtParser {
+    xmlData;
+    parser;
+    constructor(xmlData) {
+        this.xmlData = xmlData;
+        this.parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '@',
+            textNodeName: '#text',
+            removeNSPrefix: true,
+            parseAttributeValue: true,
+            trimValues: true,
+            parseTagValue: false, // Don't auto-parse values to preserve strings like "00001"
+            processEntities: true,
+            allowBooleanAttributes: false,
+            numberParseOptions: {
+                hex: false,
+                leadingZeros: true,
+                eNotation: true,
+            },
+        });
+    }
+    parse() {
+        try {
+            // Pre-validate XML
+            const validationResult = XMLValidator.validate(this.xmlData);
+            if (validationResult !== true) {
+                throw new CamtParsingError(`Invalid CAMT XML structure: ${validationResult.err.msg}`);
+            }
+            // Parse XML to JavaScript object
+            const document = this.parser.parse(this.xmlData);
+            // Navigate to Document/BkToCstmrStmt/Stmt array
+            const statements = [];
+            const docObj = this.getDocumentObject(document);
+            const reports = this.getReports(docObj);
+            if (!reports || reports.length === 0) {
+                return statements;
+            }
+            for (let i = 0; i < reports.length; i++) {
+                try {
+                    const statement = this.parseReport(reports[i], i + 1);
+                    if (statement) {
+                        statements.push(statement);
+                    }
+                }
+                catch (error) {
+                    throw new CamtParsingError(`Failed to parse CAMT report ${i + 1}: ${error instanceof Error ? error.message : 'Unknown error'}`, error instanceof Error ? error : undefined);
+                }
+            }
+            return statements;
+        }
+        catch (error) {
+            if (error instanceof CamtParsingError) {
+                throw error;
+            }
+            throw new CamtParsingError(`Failed to parse CAMT document: ${error instanceof Error ? error.message : 'Unknown error'}`, error instanceof Error ? error : undefined);
+        }
+    }
+    getDocumentObject(document) {
+        // Handle different possible XML root structures
+        if (document.Document) {
+            return document.Document;
+        }
+        if (document.camt) {
+            return document.camt;
+        }
+        // Look for any object with BkToCstmrAcctRpt property
+        for (const key in document) {
+            if (document[key] && document[key].BkToCstmrAcctRpt) {
+                return document[key];
+            }
+        }
+        throw new CamtParsingError('No valid CAMT document structure found');
+    }
+    getReports(docObj) {
+        const bkToCstmrAcctRpt = docObj.BkToCstmrAcctRpt;
+        if (!bkToCstmrAcctRpt) {
+            throw new CamtParsingError('No BkToCstmrAcctRpt element found in CAMT document');
+        }
+        const rpt = bkToCstmrAcctRpt.Rpt;
+        if (!rpt) {
+            return [];
+        }
+        // Handle both single report and array of reports
+        return Array.isArray(rpt) ? rpt : [rpt];
+    }
+    parseReport(report, reportNumber) {
+        try {
+            // Extract account information
+            const account = this.getValueFromPath(report, 'Acct.Id.IBAN');
+            // Extract statement number/ID
+            const number = this.getValueFromPath(report, 'Id');
+            // Extract transaction reference
+            const transactionReference = this.getValueFromPath(report, 'ElctrncSeqNb');
+            // Parse balances
+            const balances = this.parseBalances(report, reportNumber);
+            // Be more flexible with balance requirements - some banks only provide one balance
+            let openingBalance = balances.openingBalance;
+            let closingBalance = balances.closingBalance;
+            // If we don't have both opening and closing, try to use what we have
+            if (!openingBalance && !closingBalance) {
+                // If we have available balance, use it as closing balance
+                if (balances.availableBalance) {
+                    closingBalance = balances.availableBalance;
+                }
+                else {
+                    throw new CamtParsingError(`No balance information found in CAMT report ${reportNumber}`);
+                }
+            }
+            // If missing opening balance, create a zero balance for the same date as closing
+            if (!openingBalance && closingBalance) {
+                openingBalance = {
+                    date: closingBalance.date,
+                    currency: closingBalance.currency,
+                    value: 0,
+                };
+            }
+            // If missing closing balance, use opening balance as closing
+            if (!closingBalance && openingBalance) {
+                closingBalance = openingBalance;
+            }
+            // Parse transactions
+            const transactions = this.parseTransactions(report, reportNumber);
+            return {
+                account,
+                number,
+                transactionReference,
+                openingBalance: openingBalance,
+                closingBalance: closingBalance,
+                availableBalance: balances.availableBalance,
+                transactions,
+            };
+        }
+        catch (error) {
+            if (error instanceof CamtParsingError) {
+                throw error;
+            }
+            throw new CamtParsingError(`Failed to parse report ${reportNumber} content: ${error instanceof Error ? error.message : 'Unknown error'}`, error instanceof Error ? error : undefined);
+        }
+    }
+    getValueFromPath(obj, path) {
+        const pathParts = path.split('.');
+        let current = obj;
+        for (const part of pathParts) {
+            if (current && typeof current === 'object' && current[part] !== undefined) {
+                current = current[part];
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (typeof current === 'string' || typeof current === 'number') {
+            return String(current);
+        }
+        if (current && typeof current === 'object' && current['#text'] !== undefined) {
+            return String(current['#text']);
+        }
+        return undefined;
+    }
+    parseBalances(report, reportNumber) {
+        try {
+            let openingBalance;
+            let closingBalance;
+            let availableBalance;
+            // Get balance array from report
+            const balances = report.Bal;
+            if (!balances) {
+                return { openingBalance, closingBalance, availableBalance };
+            }
+            const balanceArray = Array.isArray(balances) ? balances : [balances];
+            for (const balanceObj of balanceArray) {
+                const typeCode = this.getValueFromPath(balanceObj, 'Tp.CdOrPrtry.Cd');
+                // Extract amount and currency
+                const currency = balanceObj.Amt?.['@Ccy'] || 'EUR';
+                const value = parseFloat(this.getValueFromPath(balanceObj, 'Amt') || '0');
+                const creditDebitInd = this.getValueFromPath(balanceObj, 'CdtDbtInd');
+                const finalValue = creditDebitInd === 'DBIT' ? -value : value;
+                const dateStr = this.getValueFromPath(balanceObj, 'Dt.Dt') || this.getValueFromPath(balanceObj, 'Dt');
+                const date = dateStr ? this.parseDate(dateStr) : new Date();
+                const balance = {
+                    date,
+                    currency,
+                    value: finalValue,
+                };
+                switch (typeCode) {
+                    case 'PRCD': // Previous closing date
+                    case 'OPBD': // Opening booked
+                    case 'OPAV': // Opening available
+                        openingBalance = balance;
+                        break;
+                    case 'CLBD': // Closing booked
+                    case 'CLAV': // Closing available
+                        closingBalance = balance;
+                        break;
+                    case 'ITBD': // Interim booked
+                    case 'ITAV': // Interim available
+                    case 'FWAV': // Forward available
+                    case 'BOOK': // Booked balance
+                        // Use as available balance, or as closing if we don't have one
+                        if (!availableBalance) {
+                            availableBalance = balance;
+                        }
+                        // If we don't have a closing balance, use this as closing
+                        if (!closingBalance && (typeCode === 'BOOK' || typeCode === 'ITBD')) {
+                            closingBalance = balance;
+                        }
+                        break;
+                    default:
+                        // Handle unknown balance types by using them as closing balance if we don't have one
+                        if (!closingBalance) {
+                            closingBalance = balance;
+                        }
+                        break;
+                }
+            }
+            return { openingBalance, closingBalance, availableBalance };
+        }
+        catch (error) {
+            throw new CamtParsingError(`Failed to parse balances in report ${reportNumber}: ${error instanceof Error ? error.message : 'Unknown error'}`, error instanceof Error ? error : undefined);
+        }
+    }
+    parseTransactions(report, reportNumber) {
+        const transactions = [];
+        const entries = report.Ntry;
+        if (!entries) {
+            return transactions;
+        }
+        const entryArray = Array.isArray(entries) ? entries : [entries];
+        for (let i = 0; i < entryArray.length; i++) {
+            try {
+                const transaction = this.parseTransaction(entryArray[i], reportNumber, i + 1);
+                if (transaction) {
+                    transactions.push(transaction);
+                }
+            }
+            catch (error) {
+                throw new CamtParsingError(`Failed to parse transaction ${i + 1} in report ${reportNumber}: ${error instanceof Error ? error.message : 'Unknown error'}`, error instanceof Error ? error : undefined);
+            }
+        }
+        return transactions;
+    }
+    parseTransaction(entry, reportNumber, transactionNumber) {
+        try {
+            // Extract amount and credit/debit indicator
+            const amountValue = parseFloat(this.getValueFromPath(entry, 'Amt') || '0');
+            const creditDebitInd = this.getValueFromPath(entry, 'CdtDbtInd');
+            const isDebit = creditDebitInd === 'DBIT';
+            const amount = isDebit ? -amountValue : amountValue;
+            // Extract dates
+            const bookingDate = this.getValueFromPath(entry, 'BookgDt.Dt') || this.getValueFromPath(entry, 'BookgDt');
+            const valueDate = this.getValueFromPath(entry, 'ValDt.Dt') || this.getValueFromPath(entry, 'ValDt');
+            const entryDate = bookingDate ? this.parseDate(bookingDate) : new Date();
+            const parsedValueDate = valueDate ? this.parseDate(valueDate) : entryDate;
+            // Extract references
+            const accountServicerRef = this.getValueFromPath(entry, 'AcctSvcrRef') || '';
+            const endToEndId = this.getValueFromPath(entry, 'NtryDtls.TxDtls.Refs.EndToEndId') || '';
+            const mandateId = this.getValueFromPath(entry, 'NtryDtls.TxDtls.Refs.MndtId') || '';
+            // Extract transaction details
+            const additionalEntryInfo = this.getValueFromPath(entry, 'AddtlNtryInf') || '';
+            const remittanceInfo = this.getValueFromPath(entry, 'NtryDtls.TxDtls.RmtInf.Ustrd') || '';
+            // Extract remote party information based on transaction type
+            let remoteName = '';
+            let remoteIBAN = '';
+            let remoteBankId = '';
+            const txDtls = entry.NtryDtls?.TxDtls;
+            if (txDtls) {
+                if (isDebit) {
+                    // For debit transactions, we want the creditor (receiving party)
+                    remoteName = this.extractPartyName(txDtls, 'RltdPties.Cdtr');
+                    remoteIBAN = this.getValueFromPath(txDtls, 'RltdPties.CdtrAcct.Id.IBAN') || '';
+                    remoteBankId = this.extractBankId(txDtls, 'RltdAgts.CdtrAgt.FinInstnId');
+                }
+                else {
+                    // For credit transactions, we want the debtor (sending party)
+                    remoteName = this.extractPartyName(txDtls, 'RltdPties.Dbtr');
+                    remoteIBAN = this.getValueFromPath(txDtls, 'RltdPties.DbtrAcct.Id.IBAN') || '';
+                    remoteBankId = this.extractBankId(txDtls, 'RltdAgts.DbtrAgt.FinInstnId');
+                }
+            }
+            // Extract bank transaction code structure (BkTxCd) - can be at entry level or TxDtls level
+            let bkTxCd = this.parseBankTransactionCode(entry);
+            if (!bkTxCd.domainCode && !bkTxCd.familyCode && !bkTxCd.subFamilyCode && txDtls) {
+                bkTxCd = this.parseBankTransactionCode(txDtls);
+            }
+            return {
+                valueDate: parsedValueDate,
+                entryDate,
+                fundsCode: bkTxCd.domainCode || creditDebitInd || '',
+                amount,
+                transactionType: bkTxCd.familyCode || '',
+                customerReference: endToEndId,
+                bankReference: accountServicerRef,
+                transactionCode: bkTxCd.subFamilyCode || '',
+                purpose: remittanceInfo,
+                remoteName,
+                remoteAccountNumber: remoteIBAN,
+                remoteBankId,
+                e2eReference: endToEndId,
+                mandateReference: mandateId,
+                additionalInformation: additionalEntryInfo,
+                bookingText: additionalEntryInfo,
+            };
+        }
+        catch (error) {
+            throw new CamtParsingError(`Failed to parse transaction details: ${error instanceof Error ? error.message : 'Unknown error'}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Extract party name from various possible CAMT structures
+     * Handles both direct name (<Dbtr><Nm>) and party structure (<Dbtr><Pty><Nm>)
+     */
+    extractPartyName(txDtls, partyPath) {
+        // Strategy 1: Direct name structure (e.g., RltdPties.Dbtr.Nm)
+        let name = this.getValueFromPath(txDtls, `${partyPath}.Nm`);
+        if (name) {
+            return name;
+        }
+        // Strategy 2: Party structure (e.g., RltdPties.Dbtr.Pty.Nm)
+        name = this.getValueFromPath(txDtls, `${partyPath}.Pty.Nm`);
+        if (name) {
+            return name;
+        }
+        // Strategy 3: Organization ID structure (e.g., RltdPties.Dbtr.Id.OrgId.Nm)
+        name = this.getValueFromPath(txDtls, `${partyPath}.Id.OrgId.Nm`);
+        if (name) {
+            return name;
+        }
+        // Strategy 4: Private ID structure (e.g., RltdPties.Dbtr.Id.PrvtId.Nm)
+        name = this.getValueFromPath(txDtls, `${partyPath}.Id.PrvtId.Nm`);
+        if (name) {
+            return name;
+        }
+        // Strategy 5: Try postal address line as fallback
+        name = this.getValueFromPath(txDtls, `${partyPath}.PstlAdr.AdrLine`);
+        if (name) {
+            return name;
+        }
+        // Strategy 6: Try organization identification other
+        name = this.getValueFromPath(txDtls, `${partyPath}.Id.OrgId.Othr.Id`);
+        if (name) {
+            return name;
+        }
+        return '';
+    }
+    /**
+     * Extract bank identification code from various possible CAMT structures
+     * Handles both BIC and BICFI elements
+     */
+    extractBankId(txDtls, bankPath) {
+        // Strategy 1: Standard BIC element
+        let bankId = this.getValueFromPath(txDtls, `${bankPath}.BIC`);
+        if (bankId) {
+            return bankId;
+        }
+        // Strategy 2: BICFI element (used by some banks)
+        bankId = this.getValueFromPath(txDtls, `${bankPath}.BICFI`);
+        if (bankId) {
+            return bankId;
+        }
+        // Strategy 3: Try ClrSysMmbId (clearing system member identification)
+        bankId = this.getValueFromPath(txDtls, `${bankPath}.ClrSysMmbId.MmbId`);
+        if (bankId) {
+            return bankId;
+        }
+        // Strategy 4: Try other identification
+        bankId = this.getValueFromPath(txDtls, `${bankPath}.Othr.Id`);
+        if (bankId) {
+            return bankId;
+        }
+        return '';
+    }
+    parseDate(dateStr) {
+        // Parse ISO date format (YYYY-MM-DD)
+        if (dateStr.length === 10 && dateStr.includes('-')) {
+            return new Date(dateStr + 'T12:00:00'); // Set time to noon to avoid timezone issues
+        }
+        // Parse CAMT date format (YYYYMMDD)
+        if (dateStr.length === 8) {
+            const year = parseInt(dateStr.substring(0, 4), 10);
+            const month = parseInt(dateStr.substring(4, 6), 10) - 1; // Month is 0-based
+            const day = parseInt(dateStr.substring(6, 8), 10);
+            return new Date(year, month, day, 12);
+        }
+        return new Date(dateStr);
+    }
+    parseBankTransactionCode(entry) {
+        const bkTxCd = entry.BkTxCd;
+        if (!bkTxCd) {
+            return {};
+        }
+        // Extract Domain Code (first level - e.g., "PMNT")
+        const domainCode = this.getValueFromPath(bkTxCd, 'Domn.Cd');
+        // Extract Family Code (second level - e.g., "CCRD")
+        const familyCode = this.getValueFromPath(bkTxCd, 'Domn.Fmly.Cd');
+        // Extract SubFamily Code (third level - e.g., "POSD")
+        const subFamilyCode = this.getValueFromPath(bkTxCd, 'Domn.Fmly.SubFmlyCd');
+        return {
+            domainCode,
+            familyCode,
+            subFamilyCode,
+        };
+    }
+}