lib-fints 1.4.8 → 1.5.0

package/README.md

@@ -201,6 +201,7 @@ The following table shows all transactions supported by the FinTSClient interfac
 | **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                      | ✓           | ✓                |
+| **Electronic Statements**  | `getElectronicStatements(accountNumber, options?)`                   | Fetches the statement document from the electronic mailbox, usually a PDF       | HKEKA                      | ✓           | ✓                |
 | **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                                     | -                          | ❌          | ❌               |
 
@@ -214,6 +215,7 @@ For each account-specific transaction, the client provides corresponding `can*`
 | `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          |
+| `canGetElectronicStatements(accountNumber?)` | Checks if electronic account statements fetching is supported   |
 
 ### Transaction Parameters
 

package/dist/client.js

@@ -2,11 +2,13 @@ import { FinTSConfig } from './config.js';
 import { Dialog } from './dialog.js';
 import { BalanceInteraction, } from './interactions/balanceInteraction.js';
 import { CreditCardStatementInteraction } from './interactions/creditcardStatementInteraction.js';
+import { ElectronicStatementInteraction, } from './interactions/electronicStatementInteraction.js';
 import { PortfolioInteraction, } from './interactions/portfolioInteraction.js';
 import { StatementInteractionCAMT } from './interactions/statementInteractionCAMT.js';
 import { StatementInteractionMT940 } from './interactions/statementInteractionMT940.js';
 import { DKKKU } from './segments/DKKKU.js';
 import { HKCAZ } from './segments/HKCAZ.js';
+import { HKEKA } from './segments/HKEKA.js';
 import { HKIDN } from './segments/HKIDN.js';
 import { HKKAZ } from './segments/HKKAZ.js';
 import { HKSAL } from './segments/HKSAL.js';
@@ -201,6 +203,41 @@ export class FinTSClient {
     async getCreditCardStatementsWithTan(tanReference, tan) {
         return (await this.continueCustomerInteractionWithTan([DKKKU.Id], tanReference, tan));
     }
+    /**
+     * Checks if the bank supports fetching electronic account statements in general or for the given account number
+     * @param accountNumber when the account number is provided, checks if the account supports fetching of electronic statements
+     * @returns true if the bank (and account) supports fetching electronic account statements
+     */
+    canGetElectronicStatements(accountNumber) {
+        return accountNumber
+            ? this.config.isAccountTransactionSupported(accountNumber, HKEKA.Id)
+            : this.config.isTransactionSupported(HKEKA.Id);
+    }
+    /**
+     * Fetches an electronic account statement (Elektronischer Kontoauszug) for the given account number
+     *
+     * This returns the statement document the bank files in the customer's electronic mailbox,
+     * usually a PDF, not a list of transactions. The bank hands out one statement per call and
+     * announces a waiting successor in `nextOffset`; pass that value back in `options.offset` to
+     * fetch the next one. Banks that set `receiptRequired` in their HIEKAS parameters keep
+     * offering a statement until it has been acknowledged with its receipt.
+     *
+     * @param accountNumber - the account number to fetch the statement for, must be an account available in the config.bankingInformation.upd.accounts
+     * @param options - optional format, statement number and year, entry limit and offset
+     * @returns a response containing the statement documents and the offset of a waiting successor
+     */
+    async getElectronicStatements(accountNumber, options) {
+        return (await this.startCustomerOrderInteraction(new ElectronicStatementInteraction(accountNumber, options)));
+    }
+    /**
+     * Continues the electronic account statement fetching when a TAN is required
+     * @param tanReference The TAN reference provided in the first call's response
+     * @param tan The TAN entered by the user, can be omitted if a decoupled TAN method is used
+     * @returns a response containing the statement documents
+     */
+    async getElectronicStatementsWithTan(tanReference, tan) {
+        return (await this.continueCustomerInteractionWithTan([HKEKA.Id], tanReference, tan));
+    }
     async startCustomerOrderInteraction(interaction) {
         this.currentDialog = new Dialog(this.config, false);
         this.currentDialog.addCustomerInteraction(interaction);

package/dist/dataElements/Binary.js

@@ -14,7 +14,24 @@ export class Binary extends DataElement {
         }
         return `@${value.length}@${value}`;
     }
+    /**
+     * A binary value arrives as `@<length>@<data>`. The length is authoritative: it is the
+     * only thing that tells data apart from the separators and escape characters that a
+     * binary payload — a PDF, for instance — is full of. Returning everything after the
+     * second `@` instead would hand out whatever the bank appended between the end of the
+     * data and the next separator.
+     */
     decode(text) {
-        return text.slice(text.indexOf('@', 1) + 1);
+        if (text[0] !== '@') {
+            // Not length-prefixed — nothing to go by, take it as it is.
+            return text;
+        }
+        const lengthEnd = text.indexOf('@', 1);
+        if (lengthEnd < 0) {
+            return text;
+        }
+        const dataStart = lengthEnd + 1;
+        const length = Number.parseInt(text.slice(1, lengthEnd), 10);
+        return Number.isNaN(length) ? text.slice(dataStart) : text.slice(dataStart, dataStart + length);
     }
 }

package/dist/dialog.js

@@ -180,39 +180,60 @@ export class Dialog {
         }
         return this.config.tanMediaName;
     }
+    /**
+     * Collects a response that the bank spreads over several messages.
+     *
+     * When the bank cannot fit a response into one message it answers with code 3040 plus
+     * a continuation mark. Repeating the order with that mark yields the next portion —
+     * as a COMPLETE, self-contained response segment, not as a byte-wise continuation of
+     * the previous one. A HICAZ follow-up, for example, repeats the account and the CAMT
+     * descriptor before carrying its own share of the statements.
+     *
+     * Every portion is therefore decoded on its own and all of them are placed into the
+     * response message the caller holds. Combining their payloads needs to know what the
+     * payload means — one MT940 stream continues, a list of CAMT documents is appended —
+     * so that step belongs to the interaction, which does it via `findAllSegments`.
+     */
     async handlePartedMessages(message, responseMessage, interaction) {
-        let partedSegment = responseMessage.findSegment(PARTED.Id);
-        if (partedSegment) {
-            while (responseMessage.hasReturnCode(3040)) {
-                const answers = responseMessage.getBankAnswers();
-                const segmentWithContinuation = message.segments.find((s) => s.header.segId === interaction.segId);
-                if (!segmentWithContinuation) {
-                    throw new Error(`Response contains segment with further information, but corresponding segment could not be found or is not specified`);
-                }
-                const answer = answers.find((a) => a.code === 3040);
-                if (!answer || !answer.params || answer.params.length === 0) {
-                    throw new Error('Expected bank answer to contain continuation mark parameters (code 3040)');
-                }
-                segmentWithContinuation.continuationMark = answer.params[0];
-                const hnhbkSegment = message.findSegment(HNHBK.Id);
-                if (!hnhbkSegment) {
-                    throw new Error('HNHBK segment not found in message');
-                }
-                hnhbkSegment.msgNr = ++this.lastMessageNumber;
-                const nextResponseMessage = await this.httpClient.sendMessage(message);
-                const nextPartedSegment = nextResponseMessage.findSegment(PARTED.Id);
-                if (nextPartedSegment) {
-                    nextPartedSegment.rawData =
-                        partedSegment.rawData +
-                            nextPartedSegment.rawData.slice(nextPartedSegment.rawData.indexOf('+') + 1);
-                    partedSegment = nextPartedSegment;
-                }
-                responseMessage = nextResponseMessage;
-            }
-            const completeSegment = decode(partedSegment.rawData);
-            const index = responseMessage.segments.indexOf(partedSegment);
-            responseMessage.segments.splice(index, 1, completeSegment);
+        // ALL of them, not just the first: one bank message may well carry several
+        // response segments. Taking only the first left the rest sitting in the tree as
+        // PARTED, where `findAllSegments` cannot see them — lost without a trace.
+        const partedSegments = responseMessage.findAllSegments(PARTED.Id);
+        if (partedSegments.length === 0) {
+            return;
         }
+        // The message the caller holds — every portion has to end up in THIS one, not in
+        // the last one we happen to receive.
+        const callersMessage = responseMessage;
+        const rawPortions = partedSegments.map((segment) => segment.rawData);
+        while (responseMessage.hasReturnCode(3040)) {
+            const answers = responseMessage.getBankAnswers();
+            const segmentWithContinuation = message.segments.find((s) => s.header.segId === interaction.segId);
+            if (!segmentWithContinuation) {
+                throw new Error(`Response contains segment with further information, but corresponding segment could not be found or is not specified`);
+            }
+            const answer = answers.find((a) => a.code === 3040);
+            if (!answer || !answer.params || answer.params.length === 0) {
+                throw new Error('Expected bank answer to contain continuation mark parameters (code 3040)');
+            }
+            segmentWithContinuation.continuationMark = answer.params[0];
+            const hnhbkSegment = message.findSegment(HNHBK.Id);
+            if (!hnhbkSegment) {
+                throw new Error('HNHBK segment not found in message');
+            }
+            hnhbkSegment.msgNr = ++this.lastMessageNumber;
+            const nextResponseMessage = await this.httpClient.sendMessage(message);
+            rawPortions.push(...nextResponseMessage
+                .findAllSegments(PARTED.Id)
+                .map((segment) => segment.rawData));
+            responseMessage = nextResponseMessage;
+        }
+        // Every PARTED placeholder gives way to the decoded portions, at the position of
+        // the first one so the segment order stays intact.
+        const index = callersMessage.segments.indexOf(partedSegments[0]);
+        const withoutPlaceholders = callersMessage.segments.filter((segment) => segment.header.segId !== PARTED.Id);
+        withoutPlaceholders.splice(index, 0, ...rawPortions.map((raw) => decode(raw)));
+        callersMessage.segments = withoutPlaceholders;
     }
     checkEnded(response) {
         if (response.bankAnswers.some((answer) => answer.code === 100) ||

package/dist/electronicStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/httpClient.js

@@ -10,7 +10,7 @@ export class HttpClient {
     }
     async sendMessage(message) {
         const encodedMessage = message.encode();
-        const requestBuffer = Buffer.from(encodedMessage);
+        const requestBuffer = Buffer.from(encodedMessage, 'latin1');
         if (this.debug) {
             console.log('Request Message:\n');
             if (this.debugRaw) {

package/dist/index.js

@@ -8,10 +8,12 @@ export * from './bpd.js';
 export * from './client.js';
 export * from './config.js';
 export * from './dialog.js';
+export * from './electronicStatement.js';
 export * from './httpClient.js';
 export * from './message.js';
 export * from './mt535parser.js';
 export * from './mt940parser.js';
 export * from './segment.js';
+export { StatementFormat } from './segments/HKEKA.js';
 export * from './statement.js';
 export * from './upd.js';

package/dist/interactions/creditcardStatementInteraction.js

@@ -30,7 +30,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);

package/dist/interactions/electronicStatementInteraction.js

@@ -0,0 +1,88 @@
+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 {
+    accountNumber;
+    options;
+    constructor(accountNumber, options = {}) {
+        super(HKEKA.Id, HIEKA.Id);
+        this.accountNumber = accountNumber;
+        this.options = options;
+    }
+    createSegments(init) {
+        const bankAccount = init.getBankAccount(this.accountNumber);
+        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: 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

@@ -40,17 +40,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

@@ -29,9 +29,11 @@ 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;
             });

package/dist/interactions/statementInteractionCAMT.js

@@ -34,12 +34,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

@@ -29,10 +29,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),

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/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());