lib-fints 1.4.8 → 1.5.1

package/dist/interactions/balanceInteraction.js

@@ -1,26 +1,28 @@
+import { internationalAccount, nationalAccount } from '../accountDescriptor.js';
+import { describeAccount } from '../bankAccount.js';
 import { CreditDebit } from '../codes.js';
 import { HISAL } from '../segments/HISAL.js';
 import { HKSAL } from '../segments/HKSAL.js';
 import { CustomerOrderInteraction } from './customerInteraction.js';
 export class BalanceInteraction extends CustomerOrderInteraction {
-    accountNumber;
-    constructor(accountNumber) {
+    account;
+    constructor(account) {
         super(HKSAL.Id, HISAL.Id);
-        this.accountNumber = accountNumber;
+        this.account = account;
     }
     createSegments(init) {
-        const bankAccount = init.getBankAccount(this.accountNumber);
-        if (!init.isAccountTransactionSupported(this.accountNumber, this.segId)) {
-            throw Error(`Account ${this.accountNumber} does not support business transaction '${this.segId}'`);
+        const bankAccount = init.getBankAccount(this.account);
+        if (!init.isAccountTransactionSupported(this.account, this.segId)) {
+            throw Error(`Account ${describeAccount(this.account)} does not support business transaction '${this.segId}'`);
         }
         const version = init.getMaxSupportedTransactionVersion(HKSAL.Id);
         if (!version) {
             throw Error(`There is no supported version for business transaction '${HKSAL.Id}`);
         }
-        const account = version <= 6 ? { ...bankAccount, iban: undefined, bic: undefined } : bankAccount;
+        const account = version <= 6 ? nationalAccount(bankAccount) : internationalAccount(init, bankAccount);
         const hksal = {
             header: { segId: HKSAL.Id, segNr: 0, version: version },
-            account,
+            account: account,
             allAccounts: false,
         };
         return [hksal];

package/dist/interactions/creditcardStatementInteraction.js

@@ -1,18 +1,19 @@
+import { describeAccount } from '../bankAccount.js';
 import { DIKKU } from '../segments/DIKKU.js';
 import { DKKKU } from '../segments/DKKKU.js';
 import { CustomerOrderInteraction } from './customerInteraction.js';
 export class CreditCardStatementInteraction extends CustomerOrderInteraction {
-    accountNumber;
+    account;
     from;
-    constructor(accountNumber, from) {
+    constructor(account, from) {
         super(DKKKU.Id, DIKKU.Id);
-        this.accountNumber = accountNumber;
+        this.account = account;
         this.from = from;
     }
     createSegments(init) {
-        const bankAccount = init.getBankAccount(this.accountNumber);
-        if (!init.isAccountTransactionSupported(this.accountNumber, this.segId)) {
-            throw Error(`Account ${this.accountNumber} does not support business transaction '${this.segId}'`);
+        const bankAccount = init.getBankAccount(this.account);
+        if (!init.isAccountTransactionSupported(this.account, this.segId)) {
+            throw Error(`Account ${describeAccount(this.account)} does not support business transaction '${this.segId}'`);
         }
         const account = { ...bankAccount, iban: undefined };
         const version = 2;
@@ -30,7 +31,15 @@ export class CreditCardStatementInteraction extends CustomerOrderInteraction {
             const valueFloatStr = value.replaceAll('.', '').replaceAll(',', '.');
             return parseFloat(valueFloatStr);
         }
-        const dikku = response.findSegment(DIKKU.Id);
+        // A response the bank spread over several messages arrives as several DIKKU
+        // segments. The balance is the same in each, the transactions are not.
+        const dikkuSegments = response.findAllSegments(DIKKU.Id);
+        const dikku = dikkuSegments[0]
+            ? {
+                ...dikkuSegments[0],
+                transactions: dikkuSegments.flatMap((segment) => segment.transactions ?? []),
+            }
+            : undefined;
         if (dikku) {
             const creditDebit = dikku.balance.creditDebit;
             const balanceAmount = dikku.balance.amount.value * (creditDebit === 'D' ? -1 : 1);
@@ -50,7 +59,7 @@ export class CreditCardStatementInteraction extends CustomerOrderInteraction {
             if (dikku.transactions) {
                 for (let i = 0; i < dikku.transactions.length; i++) {
                     const parts = dikku.transactions[i].split(':');
-                    // const accountNumber = parts[0];
+                    // const account = parts[0];
                     const transactionDateStr = parts[1];
                     const valueDateStr = parts[2];
                     const currencyOrig = parts[5];

package/dist/interactions/electronicStatementInteraction.js

@@ -0,0 +1,89 @@
+import { internationalAccount, nationalAccount } from '../accountDescriptor.js';
+import { HIEKA } from '../segments/HIEKA.js';
+import { HKEKA } from '../segments/HKEKA.js';
+import { CustomerOrderInteraction } from './customerInteraction.js';
+/**
+ * Turns the latin1 string the parser produced back into the bytes the bank sent.
+ */
+function toBytes(binary) {
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i) & 0xff;
+    }
+    return bytes;
+}
+const PDF_MAGIC = '%PDF';
+/**
+ * Some banks base64-encode the document although the field is declared binary — a known
+ * quirk of HIEKP v1 that may apply here as well.
+ *
+ * This only unwraps when it can prove the result: the payload must consist of base64
+ * characters only AND decode to something that actually starts with a PDF header.
+ * Anything else is passed through untouched, so a document is never silently mangled.
+ */
+function unwrapBase64(bytes) {
+    const text = new TextDecoder('latin1').decode(bytes);
+    if (text.startsWith(PDF_MAGIC) || !/^[A-Za-z0-9+/\s]+={0,2}\s*$/.test(text)) {
+        return bytes;
+    }
+    try {
+        const decoded = Buffer.from(text, 'base64');
+        return decoded.subarray(0, PDF_MAGIC.length).toString('latin1') === PDF_MAGIC
+            ? new Uint8Array(decoded)
+            : bytes;
+    }
+    catch {
+        return bytes;
+    }
+}
+export class ElectronicStatementInteraction extends CustomerOrderInteraction {
+    account;
+    options;
+    constructor(account, options = {}) {
+        super(HKEKA.Id, HIEKA.Id);
+        this.account = account;
+        this.options = options;
+    }
+    createSegments(init) {
+        const bankAccount = init.getBankAccount(this.account);
+        const version = init.getMaxSupportedTransactionVersion(HKEKA.Id);
+        if (!version) {
+            throw Error(`There is no supported version for business transaction '${HKEKA.Id}'`);
+        }
+        const params = init.getTransactionParameters(HKEKA.Id);
+        const format = this.options.format ?? params?.supportedFormats?.[0];
+        const hkeka = {
+            header: { segId: HKEKA.Id, segNr: 0, version: version },
+            account: version <= 3 ? nationalAccount(bankAccount) : internationalAccount(init, bankAccount),
+            statementFormat: format,
+            statementNumber: this.options.number,
+            statementYear: this.options.year,
+            maxEntries: this.options.maxEntries,
+            offset: this.options.offset,
+        };
+        return [hkeka];
+    }
+    handleResponse(response, clientResponse) {
+        const segments = response.findAllSegments(HIEKA.Id);
+        clientResponse.statements = segments.map((hieka) => {
+            const names = [hieka.name, hieka.name2, hieka.name3].filter((name) => !!name);
+            return {
+                format: hieka.format,
+                from: hieka.timeRange?.from,
+                to: hieka.timeRange?.to,
+                date: hieka.date,
+                year: hieka.year,
+                number: hieka.number,
+                document: unwrapBase64(toBytes(hieka.booked ?? '')),
+                closingInfo: hieka.closingInfo,
+                conditionsInfo: hieka.conditionsInfo,
+                advertisement: hieka.advertisement,
+                iban: hieka.iban,
+                bic: hieka.bic,
+                accountName: names.length > 0 ? names.join(' ') : undefined,
+                receipt: hieka.receipt,
+            };
+        });
+        clientResponse.nextOffset = clientResponse.bankAnswers.find((answer) => answer.code === 3040)?.params?.[0];
+    }
+}

package/dist/interactions/portfolioInteraction.js

@@ -1,3 +1,5 @@
+import { nationalAccount } from '../accountDescriptor.js';
+import { describeAccount } from '../bankAccount.js';
 import { Mt535Parser } from '../mt535parser.js';
 import { HIWPD } from '../segments/HIWPD.js';
 import { HKWPD } from '../segments/HKWPD.js';
@@ -6,25 +8,25 @@ import { CustomerOrderInteraction } from './customerInteraction.js';
  * Interaction for requesting and parsing stock portfolio information (HKWPD/HIWPD)
  */
 export class PortfolioInteraction extends CustomerOrderInteraction {
-    accountNumber;
+    account;
     currency;
     priceQuality;
     maxEntries;
     paginationMarker;
-    constructor(accountNumber, currency, priceQuality, maxEntries, paginationMarker) {
+    constructor(account, currency, priceQuality, maxEntries, paginationMarker) {
         super(HKWPD.Id, HIWPD.Id);
-        this.accountNumber = accountNumber;
+        this.account = account;
         this.currency = currency;
         this.priceQuality = priceQuality;
         this.maxEntries = maxEntries;
         this.paginationMarker = paginationMarker;
     }
     createSegments(config) {
-        const bankAccount = config.getBankAccount(this.accountNumber);
-        if (!config.isAccountTransactionSupported(this.accountNumber, this.segId)) {
-            throw Error(`Account ${this.accountNumber} does not support business transaction '${this.segId}'`);
+        const bankAccount = config.getBankAccount(this.account);
+        if (!config.isAccountTransactionSupported(this.account, this.segId)) {
+            throw Error(`Account ${describeAccount(this.account)} does not support business transaction '${this.segId}'`);
         }
-        const depotAccount = { ...bankAccount, iban: undefined }; // HKWPD uses KTV which doesn't have IBAN
+        const depotAccount = nationalAccount(bankAccount); // HKWPD uses KTV, which has no IBAN
         const version = config.getMaxSupportedTransactionVersion(HKWPD.Id);
         if (!version) {
             throw Error(`There is no supported version for business transaction '${HKWPD.Id}'`);
@@ -40,17 +42,23 @@ export class PortfolioInteraction extends CustomerOrderInteraction {
         return [hkwpd];
     }
     handleResponse(response, clientResponse) {
-        const hiwpdSegment = response.findSegment(HIWPD.Id);
-        if (hiwpdSegment?.portfolioStatement) {
+        // A response the bank spread over several messages arrives as several HIWPD
+        // segments carrying one continuous MT535 stream, so their payloads are joined.
+        const portfolioStatement = response
+            .findAllSegments(HIWPD.Id)
+            .map((segment) => segment.portfolioStatement)
+            .filter((statement) => !!statement)
+            .join('');
+        if (portfolioStatement) {
             try {
                 // Parse the MT535 data
-                const parser = new Mt535Parser(hiwpdSegment.portfolioStatement);
+                const parser = new Mt535Parser(portfolioStatement);
                 clientResponse.portfolioStatement = parser.parse();
             }
             catch (error) {
                 console.warn('Failed to parse MT535 portfolio statement:', error);
                 // Fallback: provide raw data if parsing fails
-                clientResponse.rawMT535Data = hiwpdSegment.portfolioStatement;
+                clientResponse.rawMT535Data = portfolioStatement;
             }
         }
     }

package/dist/interactions/sepaAccountInteraction.js

@@ -4,7 +4,7 @@ import { CustomerOrderInteraction } from './customerInteraction.js';
 export class SepaAccountInteraction extends CustomerOrderInteraction {
     accounts;
     maxEntries;
-    constructor(accounts, // optional specific account numbers
+    constructor(accounts, // optional: only these accounts
     maxEntries) {
         super(HKSPA.Id, HISPA.Id);
         this.accounts = accounts;
@@ -18,9 +18,7 @@ export class SepaAccountInteraction extends CustomerOrderInteraction {
         if (!version) {
             throw Error(`There is no supported version for business transaction '${HKSPA.Id}'`);
         }
-        const accounts = this.accounts?.map((accountNumber) => {
-            return init.getBankAccount(accountNumber);
-        });
+        const accounts = this.accounts?.map((account) => init.getBankAccount(account));
         const hkspa = {
             header: { segId: HKSPA.Id, segNr: 0, version: version },
             accounts: accounts,
@@ -29,14 +27,19 @@ export class SepaAccountInteraction extends CustomerOrderInteraction {
         return [hkspa];
     }
     handleResponse(response, clientResponse) {
-        const hispa = response.findSegment(HISPA.Id);
-        if (hispa) {
-            clientResponse.sepaAccounts = hispa.sepaAccounts || [];
+        // A response the bank spread over several messages arrives as several HISPA
+        // segments, each carrying its own share of the accounts.
+        const hispaSegments = response.findAllSegments(HISPA.Id);
+        if (hispaSegments.length > 0) {
+            clientResponse.sepaAccounts = hispaSegments.flatMap((segment) => segment.sepaAccounts ?? []);
             this.dialog?.config.bankingInformation.upd?.bankAccounts.forEach((bankAccount) => {
                 bankAccount.isSepaAccount = false;
             });
             clientResponse.sepaAccounts.forEach((sepaAccount) => {
-                const bankAccount = this.dialog?.config.getBankAccount(sepaAccount.accountNumber);
+                // Matched, not resolved: this is the bank listing its own accounts, and at an
+                // institution where two of them share a number, demanding an unambiguous
+                // answer here would fail every dialog before it reached its order.
+                const bankAccount = this.dialog?.config.matchBankAccount(sepaAccount);
                 if (bankAccount && !bankAccount.isSepaAccount) {
                     bankAccount.isSepaAccount = sepaAccount.isSepaAccount;
                     bankAccount.iban = sepaAccount.iban;

package/dist/interactions/statementInteractionCAMT.js

@@ -1,19 +1,20 @@
+import { internationalAccount } from '../accountDescriptor.js';
 import { CamtParser } from '../camtParser.js';
 import { HICAZ } from '../segments/HICAZ.js';
 import { HKCAZ } from '../segments/HKCAZ.js';
 import { CustomerOrderInteraction } from './customerInteraction.js';
 export class StatementInteractionCAMT extends CustomerOrderInteraction {
-    accountNumber;
+    account;
     from;
     to;
-    constructor(accountNumber, from, to) {
+    constructor(account, from, to) {
         super(HKCAZ.Id, HICAZ.Id);
-        this.accountNumber = accountNumber;
+        this.account = account;
         this.from = from;
         this.to = to;
     }
     createSegments(init) {
-        const bankAccount = init.getBankAccount(this.accountNumber);
+        const bankAccount = init.getBankAccount(this.account);
         const version = init.getMaxSupportedTransactionVersion(HKCAZ.Id);
         if (!version) {
             throw Error(`There is no supported version for business transaction '${HKCAZ.Id}'`);
@@ -25,7 +26,7 @@ export class StatementInteractionCAMT extends CustomerOrderInteraction {
         }
         const hkcaz = {
             header: { segId: HKCAZ.Id, segNr: 0, version: version },
-            account: bankAccount,
+            account: internationalAccount(init, bankAccount),
             acceptedCamtFormats: acceptedCamtFormats,
             allAccounts: false,
             from: this.from,
@@ -34,12 +35,17 @@ export class StatementInteractionCAMT extends CustomerOrderInteraction {
         return [hkcaz];
     }
     handleResponse(response, clientResponse) {
-        const hicaz = response.findSegment(HICAZ.Id);
-        if (hicaz?.bookedTransactions && hicaz.bookedTransactions.length > 0) {
+        // A response the bank spread over several messages arrives as several HICAZ
+        // segments, each carrying its own share of the CAMT documents. Taking only the
+        // first one would silently drop everything after it.
+        const camtMessages = response
+            .findAllSegments(HICAZ.Id)
+            .flatMap((segment) => segment.bookedTransactions ?? []);
+        if (camtMessages.length > 0) {
             try {
                 // Parse all CAMT messages (one per booking day) and combine statements
                 const allStatements = [];
-                for (const camtMessage of hicaz.bookedTransactions) {
+                for (const camtMessage of camtMessages) {
                     // The regex looks for the XML declaration `<?xml ... ?>`
                     // and checks if it contains the attribute encoding="UTF-8".
                     // The 'i' flag makes the match case-insensitive (e.g., for "utf-8").

package/dist/interactions/statementInteractionMT940.js

@@ -1,27 +1,28 @@
+import { internationalAccount, nationalAccount } from '../accountDescriptor.js';
 import { Mt940Parser } from '../mt940parser.js';
 import { HIKAZ } from '../segments/HIKAZ.js';
 import { HKKAZ } from '../segments/HKKAZ.js';
 import { CustomerOrderInteraction } from './customerInteraction.js';
 export class StatementInteractionMT940 extends CustomerOrderInteraction {
-    accountNumber;
+    account;
     from;
     to;
-    constructor(accountNumber, from, to) {
+    constructor(account, from, to) {
         super(HKKAZ.Id, HIKAZ.Id);
-        this.accountNumber = accountNumber;
+        this.account = account;
         this.from = from;
         this.to = to;
     }
     createSegments(init) {
-        const bankAccount = init.getBankAccount(this.accountNumber);
-        const account = { ...bankAccount, iban: undefined };
+        const bankAccount = init.getBankAccount(this.account);
         const version = init.getMaxSupportedTransactionVersion(HKKAZ.Id);
         if (!version) {
             throw Error(`There is no supported version for business transaction '${HKKAZ.Id}'`);
         }
+        const account = version <= 6 ? nationalAccount(bankAccount) : internationalAccount(init, bankAccount);
         const hkkaz = {
             header: { segId: HKKAZ.Id, segNr: 0, version: version },
-            account,
+            account: account,
             allAccounts: false,
             from: this.from,
             to: this.to,
@@ -29,10 +30,17 @@ export class StatementInteractionMT940 extends CustomerOrderInteraction {
         return [hkkaz];
     }
     handleResponse(response, clientResponse) {
-        const hikaz = response.findSegment(HIKAZ.Id);
-        if (hikaz?.bookedTransactions) {
+        // A response the bank spread over several messages arrives as several HIKAZ
+        // segments. Unlike CAMT these carry one continuous MT940 stream, so their
+        // payloads are joined rather than listed.
+        const bookedTransactions = response
+            .findAllSegments(HIKAZ.Id)
+            .map((segment) => segment.bookedTransactions)
+            .filter((booked) => !!booked)
+            .join('');
+        if (bookedTransactions) {
             try {
-                const parser = new Mt940Parser(hikaz.bookedTransactions);
+                const parser = new Mt940Parser(bookedTransactions);
                 clientResponse.statements = parser.parse();
             }
             catch (error) {

package/dist/message.js

@@ -80,7 +80,11 @@ export class Message {
         return message;
     }
     static decodeSegment(text, partedResponseSegId) {
-        if (partedResponseSegId && text.startsWith(partedResponseSegId)) {
+        // The colon matters: a segment starts with `SEGID:number:version`, so a plain
+        // `startsWith` would also catch the parameter segment whose id merely begins the
+        // same way — HIEKAS when looking for HIEKA, HICAZS for HICAZ. Those would then be
+        // held back as PARTED and never decoded.
+        if (partedResponseSegId && text.startsWith(`${partedResponseSegId}:`)) {
             const partedSegment = {
                 header: {
                     ...SegmentDefinition.header.decode(text, 1),
@@ -139,9 +143,13 @@ export class CustomerMessage extends Message {
                 throw new Error('no signature segment found in message');
             }
             const now = new Date();
+            // The encryption header carries the same security profile as the
+            // signature: PIN version 2 for a two-step TAN method, 1 for one-step.
+            // Some banks (Consorsbank, BLZ 76030080) reject a two-step dialog whose
+            // HNVSK still says PIN:1 with "9010 Ungültiger Signaturaufbau".
             const hnvsk = {
                 header: { segId: HNVSK.Id, segNr: 998, version: HNVSK.Version },
-                secProfile: { secMethod: 'PIN', secVersion: 1 },
+                secProfile: { secMethod: 'PIN', secVersion: firstSignature.secProfile.secVersion },
                 secFunc: 998,
                 secRole: 1,
                 secId: { partyType: 1, partyId: firstSignature.secId.partyId },

package/dist/segments/HIEKA.js

@@ -0,0 +1,45 @@
+import { AlphaNumeric } from '../dataElements/AlphaNumeric.js';
+import { Binary } from '../dataElements/Binary.js';
+import { Dat } from '../dataElements/Dat.js';
+import { Numeric } from '../dataElements/Numeric.js';
+import { DataGroup } from '../dataGroups/DataGroup.js';
+import { SegmentDefinition } from '../segmentDefinition.js';
+/**
+ * Electronic account statement response (Elektronischer Kontoauszug)
+ *
+ * The element order follows the FinTS 3.0 specification, and two details of it are easy
+ * to get wrong:
+ *
+ * - `booked` sits AFTER date/year/number, not before them. HIEKP v2 orders the same
+ *   fields the other way round — the order is specific to each segment and cannot be
+ *   carried over from one to the other.
+ * - Only version 5 carries date/year/number at all; up to version 4 `booked` follows
+ *   the time range directly, and version 1 has no iban/bic/name either. Decoding an
+ *   older response with the version 5 layout does not fail, it silently shifts every
+ *   field by three positions and hands out the advertisement text as the document.
+ */
+export class HIEKA extends SegmentDefinition {
+    static Id = 'HIEKA';
+    static Version = 5;
+    constructor() {
+        super(HIEKA.Id);
+    }
+    version = HIEKA.Version;
+    elements = [
+        new AlphaNumeric('format', 1, 1, 1),
+        new DataGroup('timeRange', [new Dat('from', 0, 1), new Dat('to', 0, 1)], 1, 1),
+        new Dat('date', 0, 1, 5),
+        new Numeric('year', 0, 1, 4, 5),
+        new Numeric('number', 0, 1, 5, 5),
+        new Binary('booked', 1, 1),
+        new AlphaNumeric('closingInfo', 0, 1, 65536),
+        new AlphaNumeric('conditionsInfo', 0, 1, 65536),
+        new AlphaNumeric('advertisement', 0, 1, 65536),
+        new AlphaNumeric('iban', 0, 1, 34, 2),
+        new AlphaNumeric('bic', 0, 1, 11, 2),
+        new AlphaNumeric('name', 0, 1, 35, 2),
+        new AlphaNumeric('name2', 0, 1, 35, 2),
+        new AlphaNumeric('name3', 0, 1, 35, 2),
+        new Binary('receipt', 0, 1),
+    ];
+}

package/dist/segments/HIEKAS.js

@@ -0,0 +1,18 @@
+import { AlphaNumeric } from '../dataElements/AlphaNumeric.js';
+import { YesNo } from '../dataElements/YesNo.js';
+import { BusinessTransactionParameter, } from './businessTransactionParameter.js';
+/**
+ * Parameters for the HKEKA business transaction (electronic account statements)
+ */
+export class HIEKAS extends BusinessTransactionParameter {
+    static Id = 'HIEKAS';
+    version = 5;
+    constructor() {
+        super(HIEKAS.Id, [
+            new YesNo('indexAllowed', 1, 1),
+            new YesNo('receiptRequired', 1, 1),
+            new YesNo('maxEntryCountAllowed', 1, 1),
+            new AlphaNumeric('supportedFormats', 1, 9, 1),
+        ]);
+    }
+}

package/dist/segments/HKEKA.js

@@ -0,0 +1,43 @@
+import { AlphaNumeric } from '../dataElements/AlphaNumeric.js';
+import { Numeric } from '../dataElements/Numeric.js';
+import { AccountGroup } from '../dataGroups/Account.js';
+import { InternationalAccountGroup, } from '../dataGroups/InternationalAccount.js';
+import { SegmentDefinition } from '../segmentDefinition.js';
+/**
+ * Format of the electronic account statement.
+ * The bank announces the formats it supports in the HIEKAS parameters.
+ */
+export var StatementFormat;
+(function (StatementFormat) {
+    StatementFormat["MT940"] = "1";
+    StatementFormat["ISO8583"] = "2";
+    StatementFormat["PDF"] = "3";
+})(StatementFormat || (StatementFormat = {}));
+/**
+ * Request an electronic account statement (Elektronischer Kontoauszug)
+ *
+ * Unlike HKKAZ/HKCAZ this does not return individual transactions but the statement
+ * document the bank files in the customer's electronic mailbox — for most banks a PDF.
+ *
+ * A statement is handed out once: the bank keeps track of which statements have already
+ * been fetched and announces remaining ones with answer code 3040 plus an offset. Banks
+ * that set `receiptRequired` in their HIEKAS parameters expect each statement to be
+ * acknowledged before they consider it delivered.
+ */
+export class HKEKA extends SegmentDefinition {
+    static Id = 'HKEKA';
+    static Version = 5;
+    constructor() {
+        super(HKEKA.Id);
+    }
+    version = HKEKA.Version;
+    elements = [
+        new AccountGroup('account', 1, 1, 1, 3),
+        new InternationalAccountGroup('account', 1, 1, 4),
+        new AlphaNumeric('statementFormat', 0, 1, 1),
+        new Numeric('statementNumber', 0, 1, 5),
+        new Numeric('statementYear', 0, 1, 4, 3),
+        new Numeric('maxEntries', 0, 1, 4),
+        new AlphaNumeric('offset', 0, 1, 35),
+    ];
+}

package/dist/segments/HKKAZ.js

@@ -3,7 +3,7 @@ import { Dat } from '../dataElements/Dat.js';
 import { Numeric } from '../dataElements/Numeric.js';
 import { YesNo } from '../dataElements/YesNo.js';
 import { AccountGroup } from '../dataGroups/Account.js';
-import { InternationalAccountGroup } from '../dataGroups/InternationalAccount.js';
+import { InternationalAccountGroup, } from '../dataGroups/InternationalAccount.js';
 import { SegmentDefinition } from '../segmentDefinition.js';
 /**
  * Request account transactions in a given period

package/dist/segments/registry.js

@@ -5,6 +5,8 @@ import { DKKKU } from './DKKKU.js';
 import { HIBPA } from './HIBPA.js';
 import { HICAZ } from './HICAZ.js';
 import { HICAZS } from './HICAZS.js';
+import { HIEKA } from './HIEKA.js';
+import { HIEKAS } from './HIEKAS.js';
 import { HIKAZ } from './HIKAZ.js';
 import { HIKAZS } from './HIKAZS.js';
 import { HIKIM } from './HIKIM.js';
@@ -23,6 +25,7 @@ import { HIUPA } from './HIUPA.js';
 import { HIUPD } from './HIUPD.js';
 import { HIWPD } from './HIWPD.js';
 import { HKCAZ } from './HKCAZ.js';
+import { HKEKA } from './HKEKA.js';
 import { HKEND } from './HKEND.js';
 import { HKIDN } from './HKIDN.js';
 import { HKKAZ } from './HKKAZ.js';
@@ -75,6 +78,9 @@ export function registerSegments() {
     registerSegmentDefinition(new HKCAZ());
     registerSegmentDefinition(new HICAZ());
     registerSegmentDefinition(new HICAZS());
+    registerSegmentDefinition(new HKEKA());
+    registerSegmentDefinition(new HIEKA());
+    registerSegmentDefinition(new HIEKAS());
     registerSegmentDefinition(new HKWPD());
     registerSegmentDefinition(new HIWPD());
     registerSegmentDefinition(new HKWPD());