lib-fints 1.3.1 → 1.4.1

package/dist/client.js

@@ -1,22 +1,22 @@
 import { Dialog } from './dialog.js';
-import { HKTAB } from './segments/HKTAB.js';
-import { StatementInteraction } from './interactions/statementInteraction.js';
+import { StatementInteractionMT940 } from './interactions/statementInteractionMT940.js';
+import { StatementInteractionCAMT } from './interactions/statementInteractionCAMT.js';
 import { BalanceInteraction } from './interactions/balanceInteraction.js';
 import { PortfolioInteraction } from './interactions/portfolioInteraction.js';
 import { FinTSConfig } from './config.js';
-import { TanMediaInteraction } from './interactions/tanMediaInteraction.js';
 import { HKSAL } from './segments/HKSAL.js';
 import { HKKAZ } from './segments/HKKAZ.js';
+import { HKCAZ } from './segments/HKCAZ.js';
 import { HKWPD } from './segments/HKWPD.js';
 import { DKKKU } from './segments/DKKKU.js';
-import { InitDialogInteraction } from './interactions/initDialogInteraction.js';
-import { CreditCardStatementInteraction } from "./interactions/creditcardStatementInteraction.js";
+import { CreditCardStatementInteraction } from './interactions/creditcardStatementInteraction.js';
+import { HKIDN } from './segments/HKIDN.js';
 /**
  * A client to communicate with a bank over the FinTS protocol
  */
 export class FinTSClient {
     config;
-    openCustomerInteractions = new Map();
+    currentDialog;
     /**
      * Creates a new FinTS client
      * @param config - the configuration for the client, use the static factory methods FinTSConfig.forFirstTimeUse or FinTSConfig.fromBankingInformation to create a configuration
@@ -51,21 +51,9 @@ export class FinTSClient {
      * @returns the synchronization response
      */
     async synchronize() {
-        const dialog = new Dialog(this.config);
-        const syncResponse = await this.initDialog(dialog, true);
-        if (!syncResponse.success || syncResponse.requiresTan) {
-            return syncResponse;
-        }
-        if (this.config.selectedTanMethod && this.config.isTransactionSupported(HKTAB.Id)) {
-            const tanMediaResponse = await dialog.startCustomerOrderInteraction(new TanMediaInteraction());
-            let tanMethod = this.config.selectedTanMethod;
-            if (tanMethod) {
-                tanMethod.activeTanMedia = tanMediaResponse.tanMediaList;
-            }
-            syncResponse.bankAnswers.push(...tanMediaResponse.bankAnswers);
-        }
-        await dialog.end();
-        return syncResponse;
+        this.currentDialog = new Dialog(this.config, true);
+        const responses = await this.currentDialog.start();
+        return responses.get(HKIDN.Id);
     }
     /**
      * Continues the synchronization transaction when a TAN is required
@@ -74,7 +62,7 @@ export class FinTSClient {
      * @returns the synchronization response
      */
     async synchronizeWithTan(tanReference, tan) {
-        return this.continueCustomerInteractionWithTan(tanReference, tan);
+        return await this.continueCustomerInteractionWithTan([HKIDN.Id], tanReference, tan);
     }
     /**
      * Checks if the bank supports fetching an account balance in general or for the given account number when provided
@@ -92,7 +80,8 @@ export class FinTSClient {
      * @returns the account balance response
      */
     async getAccountBalance(accountNumber) {
-        return this.startCustomerOrderInteraction(new BalanceInteraction(accountNumber));
+        const response = await this.startCustomerOrderInteraction(new BalanceInteraction(accountNumber));
+        return response;
     }
     /**
      * Continues the account balance fetching when a TAN is required
@@ -101,7 +90,7 @@ export class FinTSClient {
      * @returns the account balance response
      */
     async getAccountBalanceWithTan(tanReference, tan) {
-        return this.continueCustomerInteractionWithTan(tanReference, tan);
+        return (await this.continueCustomerInteractionWithTan([HKSAL.Id], tanReference, tan));
     }
     /**
      * Checks if the bank supports fetching account statements in general or for the given account number when provided
@@ -109,19 +98,39 @@ export class FinTSClient {
      * @returns true if the bank (and account) supports fetching account statements
      */
     canGetAccountStatements(accountNumber) {
-        return accountNumber
-            ? this.config.isAccountTransactionSupported(accountNumber, HKKAZ.Id)
-            : this.config.isTransactionSupported(HKKAZ.Id);
+        if (accountNumber) {
+            // Check if either CAMT or MT940 is supported for this account
+            return (this.config.isAccountTransactionSupported(accountNumber, HKCAZ.Id) ||
+                this.config.isAccountTransactionSupported(accountNumber, HKKAZ.Id));
+        }
+        else {
+            // Check if either CAMT or MT940 is supported by the bank
+            return this.config.isTransactionSupported(HKCAZ.Id) || this.config.isTransactionSupported(HKKAZ.Id);
+        }
     }
     /**
      * Fetches the account statements for the given account number
      * @param accountNumber - the account number to fetch the statements for, must be an account available in the config.baningInformation.UPD.accounts
      * @param from - an optional start date of the period to fetch the statements for
      * @param to - an optional end date of the period to fetch the statements for
+     * @param preferCamt - whether to prefer CAMT format over MT940 when both are supported (default: true)
      * @returns an account statements response containing an array of statements
      */
-    async getAccountStatements(accountNumber, from, to) {
-        return this.startCustomerOrderInteraction(new StatementInteraction(accountNumber, from, to));
+    async getAccountStatements(accountNumber, from, to, preferCamt = true) {
+        // Check what formats the bank supports
+        const camtSupported = this.config.isAccountTransactionSupported(accountNumber, 'HKCAZ');
+        const mt940Supported = this.config.isAccountTransactionSupported(accountNumber, 'HKKAZ');
+        if (!camtSupported && !mt940Supported) {
+            throw Error(`Account ${accountNumber} does not support account statements`);
+        }
+        // Choose format based on support and preference
+        const useCAMT = (preferCamt && camtSupported) || (!mt940Supported && camtSupported);
+        if (useCAMT) {
+            return (await this.startCustomerOrderInteraction(new StatementInteractionCAMT(accountNumber, from, to)));
+        }
+        else {
+            return (await this.startCustomerOrderInteraction(new StatementInteractionMT940(accountNumber, from, to)));
+        }
     }
     /**
      * Continues the account statements fetching when a TAN is required
@@ -130,7 +139,7 @@ export class FinTSClient {
      * @returns an account statements response containing an array of statements
      */
     async getAccountStatementsWithTan(tanReference, tan) {
-        return this.continueCustomerInteractionWithTan(tanReference, tan);
+        return (await this.continueCustomerInteractionWithTan([HKCAZ.Id, HKKAZ.Id], tanReference, tan));
     }
     /**
      * Checks if the bank supports fetching portfolio information in general or for the given account number when provided
@@ -151,17 +160,17 @@ export class FinTSClient {
      * @returns a portfolio response containing holdings and total value
      */
     async getPortfolio(accountNumber, currency, priceQuality, maxEntries) {
-        return this.startCustomerOrderInteraction(new PortfolioInteraction(accountNumber, currency, priceQuality, maxEntries));
+        return (await this.startCustomerOrderInteraction(new PortfolioInteraction(accountNumber, currency, priceQuality, maxEntries)));
     }
     /**
-     * Continues the portfolio 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 portfolio response containing holdings and total value
-     */
+       * Continues the portfolio 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 portfolio response containing holdings and total value
+       */
     async getPortfolioWithTan(tanReference, tan) {
-        return this.continueCustomerInteractionWithTan(tanReference, tan);
+        return (await this.continueCustomerInteractionWithTan([HKWPD.Id], tanReference, tan));
     }
     /**
      * Checks if the bank supports fetching credit card statements in general or for the given account number
@@ -182,7 +191,7 @@ export class FinTSClient {
      * @returns an account statements response containing an array of statements
      */
     async getCreditCardStatements(accountNumber, from) {
-        return this.startCustomerOrderInteraction(new CreditCardStatementInteraction(accountNumber, from));
+        return (await this.startCustomerOrderInteraction(new CreditCardStatementInteraction(accountNumber, from)));
     }
     /**
      * Continues the credit card statements fetching when a TAN is required
@@ -191,57 +200,31 @@ export class FinTSClient {
      * @returns a credit card statements response containing an array of statements
      */
     async getCreditCardStatementsWithTan(tanReference, tan) {
-        return this.continueCustomerInteractionWithTan(tanReference, tan);
+        return (await this.continueCustomerInteractionWithTan([DKKKU.Id], tanReference, tan));
     }
     async startCustomerOrderInteraction(interaction) {
-        const dialog = new Dialog(this.config);
-        const syncResponse = await this.initDialog(dialog, false, interaction);
-        if (!syncResponse.success || syncResponse.requiresTan) {
-            return syncResponse;
-        }
-        const clientResponse = await dialog.startCustomerOrderInteraction(interaction);
-        if (clientResponse.requiresTan) {
-            this.openCustomerInteractions.set(clientResponse.tanReference, interaction);
+        this.currentDialog = new Dialog(this.config, false);
+        this.currentDialog.addCustomerInteraction(interaction);
+        const responses = await this.currentDialog.start();
+        const response = responses.get(interaction.segId);
+        if (response) {
+            return response;
         }
         else {
-            await dialog.end();
+            return [...responses.values()].at(-1);
         }
-        return clientResponse;
     }
-    async continueCustomerInteractionWithTan(tanReference, tan) {
-        const interaction = this.openCustomerInteractions.get(tanReference);
-        if (!interaction) {
-            throw new Error('No open customer interaction found for TAN reference: ' + tanReference);
-        }
-        const dialog = interaction.dialog;
-        let responseMessage = await dialog.sendTanMessage(interaction.segId, tanReference, tan);
-        let clientResponse = interaction.getClientResponse(responseMessage);
-        this.openCustomerInteractions.delete(tanReference);
-        if (!clientResponse.success) {
-            await dialog.end();
-            return clientResponse;
+    async continueCustomerInteractionWithTan(segIds, tanReference, tan) {
+        if (!this.currentDialog) {
+            throw new Error('no customer dialog was started which can continue');
         }
-        if (clientResponse.requiresTan) {
-            this.openCustomerInteractions.set(clientResponse.tanReference, interaction);
-            return clientResponse;
-        }
-        const initDialogInteraction = interaction;
-        if (initDialogInteraction.followUpInteraction) {
-            clientResponse = await dialog.startCustomerOrderInteraction(initDialogInteraction.followUpInteraction);
-            if (clientResponse.requiresTan) {
-                this.openCustomerInteractions.set(clientResponse.tanReference, initDialogInteraction.followUpInteraction);
-                return clientResponse;
+        const responses = await this.currentDialog.continue(tanReference, tan);
+        for (const segId of segIds) {
+            const response = responses.get(segId);
+            if (response) {
+                return response;
             }
         }
-        await dialog.end();
-        return clientResponse;
-    }
-    async initDialog(dialog, syncSystemId = false, followUpInteraction) {
-        const interaction = new InitDialogInteraction(this.config, syncSystemId, followUpInteraction);
-        const initResponse = await dialog.initialize(interaction);
-        if (initResponse.requiresTan) {
-            this.openCustomerInteractions.set(initResponse.tanReference, interaction);
-        }
-        return initResponse;
+        return [...responses.values()].at(-1);
     }
 }

package/dist/dataGroups/SepaAccount.js

@@ -0,0 +1,17 @@
+import { AlphaNumeric } from '../dataElements/AlphaNumeric.js';
+import { DataGroup } from './DataGroup.js';
+import { Identification } from '../dataElements/Identification.js';
+import { BankIdentification } from './BankIdentification.js';
+import { YesNo } from '../dataElements/YesNo.js';
+export class SepaAccountGroup extends DataGroup {
+    constructor(name, minCount = 0, maxCount = 1, minVersion, maxVersion) {
+        super(name, [
+            new YesNo('isSepaAccount', 1, 1),
+            new AlphaNumeric('iban', 0, 1, 34),
+            new AlphaNumeric('bic', 0, 1, 11),
+            new Identification('accountNumber', 1, 1),
+            new Identification('subAccountId', 0, 1),
+            new BankIdentification('bank', 1, 1),
+        ], minCount, maxCount, minVersion, maxVersion);
+    }
+}

package/dist/dataGroups/SepaAccountParameters.js

@@ -0,0 +1,16 @@
+import { YesNo } from '../dataElements/YesNo.js';
+import { Numeric } from '../dataElements/Numeric.js';
+import { AlphaNumeric } from '../dataElements/AlphaNumeric.js';
+import { DataGroup } from './DataGroup.js';
+export class SepaAccountParametersGroup extends DataGroup {
+    constructor(name, minCount = 1, maxCount = 1, minVersion, maxVersion) {
+        super(name, [
+            new YesNo('individualAccountRetrievalAllowed', 1, 1),
+            new YesNo('nationalAccountAllowed', 1, 1),
+            new YesNo('structuredPurposeAllowed', 1, 1),
+            new YesNo('maxEntriesAllowed', 1, 1, 2), // version 2+
+            new Numeric('reservedPurposePositions', 1, 1, 2, 3), // version 3+
+            new AlphaNumeric('supportedSepaFormats', 0, 99, 256), // optional, up to 99 entries
+        ], minCount, maxCount, minVersion, maxVersion);
+    }
+}

package/dist/dialog.js

@@ -1,47 +1,142 @@
 import { TanMediaRequirement, TanProcess } from './codes.js';
 import { HttpClient } from './httpClient.js';
 import { CustomerMessage, CustomerOrderMessage } from './message.js';
-import { HKEND } from './segments/HKEND.js';
 import { HKIDN } from './segments/HKIDN.js';
 import { HKTAN } from './segments/HKTAN.js';
 import { HNHBK } from './segments/HNHBK.js';
 import { decode } from './segment.js';
 import { PARTED } from './partedSegment.js';
+import { CustomerOrderInteraction } from './interactions/customerInteraction.js';
+import { InitDialogInteraction } from './interactions/initDialogInteraction.js';
+import { EndDialogInteraction } from './interactions/endDialogInteraction.js';
 export class Dialog {
     config;
     dialogId = '0';
     lastMessageNumber = 0;
+    interactions = [];
+    responses = new Map();
+    currentInteractionIndex = 0;
     isInitialized = false;
     hasEnded = false;
     httpClient;
-    constructor(config) {
+    constructor(config, syncSystemId = false) {
         this.config = config;
         if (!this.config) {
             throw new Error('configuration must be provided');
         }
         this.httpClient = this.getHttpClient();
+        this.interactions.push(new InitDialogInteraction(this.config, syncSystemId));
+        this.interactions.push(new EndDialogInteraction());
+        this.interactions.forEach((interaction) => {
+            interaction.dialog = this;
+        });
     }
-    async initialize(interaction) {
+    get currentInteraction() {
+        return this.interactions[this.currentInteractionIndex];
+    }
+    async start() {
         if (this.isInitialized) {
             throw new Error('dialog has already been initialized');
         }
         if (this.hasEnded) {
-            throw Error('cannot initialize a dialog that has already ended');
+            throw Error('cannot start a dialog that has already ended');
         }
         if (this.lastMessageNumber > 0) {
-            throw new Error('dialog initialization must be the first message in a dialog');
+            throw new Error('dialog start can only be called on a new dialog');
+        }
+        let clientResponse;
+        do {
+            const message = this.createCurrentCustomerMessage();
+            const responseMessage = await this.httpClient.sendMessage(message);
+            await this.handlePartedMessages(message, responseMessage, this.currentInteraction);
+            clientResponse = this.currentInteraction.handleClientResponse(responseMessage);
+            this.checkEnded(clientResponse);
+            this.dialogId = clientResponse.dialogId;
+            this.responses.set(this.currentInteraction.segId, clientResponse);
+            if (clientResponse.success && !clientResponse.requiresTan) {
+                this.currentInteractionIndex++;
+                if (this.currentInteractionIndex > 0) {
+                    this.isInitialized = true;
+                }
+            }
+        } while (!this.hasEnded &&
+            this.currentInteractionIndex < this.interactions.length &&
+            clientResponse.success &&
+            !clientResponse.requiresTan);
+        return this.responses;
+    }
+    async continue(tanOrderReference, tan) {
+        if (!tanOrderReference) {
+            throw Error('tanOrderReference must be provided to continue a customer order with a TAN');
+        }
+        if (!this.config.selectedTanMethod?.isDecoupled && !tan) {
+            throw Error('TAN must be provided for non-decoupled TAN methods');
+        }
+        if (this.hasEnded) {
+            throw Error('cannot continue a customer order when dialog has already ended');
+        }
+        if (!this.currentInteraction) {
+            throw new Error('there is no running customer interaction in this dialog to continue');
+        }
+        let clientResponse;
+        let isFirstMessage = true;
+        do {
+            const message = isFirstMessage
+                ? this.createCurrentTanMessage(tanOrderReference, tan)
+                : this.createCurrentCustomerMessage();
+            const responseMessage = await this.httpClient.sendMessage(message);
+            await this.handlePartedMessages(message, responseMessage, this.currentInteraction);
+            clientResponse = this.currentInteraction.handleClientResponse(responseMessage);
+            this.checkEnded(clientResponse);
+            this.dialogId = clientResponse.dialogId;
+            this.responses.set(this.currentInteraction.segId, clientResponse);
+            if (clientResponse.success && !clientResponse.requiresTan) {
+                this.currentInteractionIndex++;
+                if (this.currentInteractionIndex > 0) {
+                    this.isInitialized = true;
+                }
+            }
+            isFirstMessage = false;
+        } while (!this.hasEnded &&
+            this.currentInteractionIndex < this.interactions.length &&
+            clientResponse.success &&
+            !clientResponse.requiresTan);
+        return this.responses;
+    }
+    addCustomerInteraction(interaction, afterCurrent = false) {
+        if (this.hasEnded) {
+            throw Error('cannot queue another customer interaction when dialog has already ended');
+        }
+        const isCustomerOrder = interaction instanceof CustomerOrderInteraction;
+        if (isCustomerOrder && !this.config.isTransactionSupported(interaction.segId)) {
+            throw Error(`customer order transaction ${interaction.segId} is not supported according to the BPD`);
         }
         interaction.dialog = this;
+        if (afterCurrent) {
+            this.interactions.splice(this.currentInteractionIndex + 1, 0, interaction);
+            return;
+        }
+        this.interactions.splice(this.interactions.length - 1, 0, interaction);
+    }
+    createCurrentCustomerMessage() {
         this.lastMessageNumber++;
-        const message = new CustomerMessage(this.dialogId, this.lastMessageNumber);
+        const isCustomerOrder = this.currentInteraction instanceof CustomerOrderInteraction;
+        const message = isCustomerOrder
+            ? new CustomerOrderMessage(this.currentInteraction.segId, this.currentInteraction.responseSegId, this.dialogId, this.lastMessageNumber)
+            : new CustomerMessage(this.dialogId, this.lastMessageNumber);
         const tanMethod = this.config.selectedTanMethod;
-        const isScaSupported = tanMethod && tanMethod.version >= 6;
+        let isScaSupported = tanMethod && tanMethod.version >= 6;
+        let isTanMethodNeeded = isScaSupported;
+        if (isCustomerOrder) {
+            const bankTransaction = this.config.bankingInformation.bpd?.allowedTransactions.find((t) => t.transId === this.currentInteraction.segId);
+            isTanMethodNeeded = isScaSupported && bankTransaction?.tanRequired;
+        }
         if (this.config.userId && this.config.pin) {
             message.sign(this.config.countryCode, this.config.bankId, this.config.userId, this.config.pin, this.config.bankingInformation.systemId, isScaSupported ? this.config.tanMethodId : undefined);
         }
-        const segments = interaction.getSegments(this.config);
+        const segments = this.currentInteraction.getSegments(this.config);
         segments.forEach((segment) => message.addSegment(segment));
-        if (this.config.userId && this.config.pin && isScaSupported) {
+        if (this.config.userId && this.config.pin && isTanMethodNeeded) {
             const hktan = {
                 header: { segId: HKTAN.Id, segNr: 0, version: tanMethod.version },
                 tanProcess: TanProcess.Process4,
@@ -49,76 +144,35 @@ export class Dialog {
             };
             message.addSegment(hktan);
         }
-        const initResponse = await this.httpClient.sendMessage(message);
-        const clientResponse = interaction.getClientResponse(initResponse);
-        this.dialogId = clientResponse.dialogId;
-        if (clientResponse.success) {
-            this.isInitialized = true;
-        }
-        this.checkEnded(initResponse);
-        return clientResponse;
+        return message;
     }
-    async end() {
-        if (!this.isInitialized || this.hasEnded) {
-            return true;
-        }
-        const tanMethod = this.config.selectedTanMethod;
-        const isScaSupported = tanMethod && tanMethod.version >= 6;
-        if (this.config.tanMethodId && !tanMethod) {
-            throw new Error('given tanMethodId is not available according to the BPD');
-        }
+    createCurrentTanMessage(tanOrderReference, tan) {
         this.lastMessageNumber++;
         const message = new CustomerMessage(this.dialogId, this.lastMessageNumber);
         if (this.config.userId && this.config.pin) {
-            message.sign(this.config.countryCode, this.config.bankId, this.config.userId, this.config.pin, this.config.bankingInformation.systemId, isScaSupported ? this.config.tanMethodId : undefined);
-        }
-        const hkend = {
-            header: { segId: HKEND.Id, segNr: 0, version: HKEND.Version },
-            dialogId: this.dialogId,
-        };
-        message.addSegment(hkend);
-        const responseMessage = await this.httpClient.sendMessage(message);
-        this.checkEnded(responseMessage);
-        return this.hasEnded;
-    }
-    async startCustomerOrderInteraction(interaction) {
-        if (!this.isInitialized) {
-            throw Error('dialog must be initialized before sending a customer order');
-        }
-        if (this.hasEnded) {
-            throw Error('cannot send a customer message when dialog has already ended');
-        }
-        const bankTransaction = this.config.bankingInformation.bpd?.allowedTransactions.find((t) => t.transId === interaction.segId);
-        if (!bankTransaction) {
-            throw Error(`transaction ${interaction.segId} is not supported according to the BPD`);
-        }
-        interaction.dialog = this;
-        this.lastMessageNumber++;
-        const message = new CustomerOrderMessage(interaction.segId, interaction.responseSegId, this.dialogId, this.lastMessageNumber);
-        if (this.config.userId && this.config.pin) {
-            message.sign(this.config.countryCode, this.config.bankId, this.config.userId, this.config.pin, this.config.bankingInformation.systemId, this.config.selectedTanMethod && (bankTransaction.tanRequired || this.config.selectedTanMethod.version >= 6)
-                ? this.config.tanMethodId
-                : undefined);
+            message.sign(this.config.countryCode, this.config.bankId, this.config.userId, this.config.pin, this.config.bankingInformation.systemId, this.config.tanMethodId, tan);
         }
-        const segments = interaction.getSegments(this.config);
-        segments.forEach((segment) => message.addSegment(segment));
-        if (bankTransaction.tanRequired) {
-            if (this.config.userId && this.config.pin && this.config.tanMethodId) {
-                const hktan = {
-                    header: { segId: HKTAN.Id, segNr: 0, version: this.config.selectedTanMethod.version },
-                    tanProcess: TanProcess.Process4,
-                    segId: interaction.segId,
-                    tanMedia: this.config.tanMediaName,
-                };
-                message.addSegment(hktan);
-            }
+        if (this.config.userId && this.config.pin && this.config.tanMethodId) {
+            const hktan = {
+                header: { segId: HKTAN.Id, segNr: 0, version: this.config.selectedTanMethod.version },
+                tanProcess: this.config.selectedTanMethod?.isDecoupled ? TanProcess.Status : TanProcess.Process2,
+                segId: this.currentInteraction.segId,
+                orderRef: tanOrderReference,
+                nextTan: false,
+                tanMedia: this.config.selectedTanMethod.tanMediaRequirement >= TanMediaRequirement.Optional
+                    ? this.config.tanMediaName
+                    : undefined,
+            };
+            message.addSegment(hktan);
         }
-        let responseMessage = await this.httpClient.sendMessage(message);
+        return message;
+    }
+    async handlePartedMessages(message, responseMessage, interaction) {
         let partedSegment = responseMessage.findSegment(PARTED.Id);
         if (partedSegment) {
             while (responseMessage.hasReturnCode(3040)) {
                 const answers = responseMessage.getBankAnswers();
-                const segmentWithContinuation = segments.find((s) => s.header.segId === interaction.segId);
+                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`);
                 }
@@ -137,46 +191,10 @@ export class Dialog {
             const index = responseMessage.segments.indexOf(partedSegment);
             responseMessage.segments.splice(index, 1, completeSegment);
         }
-        this.checkEnded(responseMessage);
-        return interaction.getClientResponse(responseMessage);
-    }
-    async sendTanMessage(refSegId, tanOrderReference, tan) {
-        if (!refSegId || !tanOrderReference) {
-            throw Error('refSegId and tanOrderReference must be provided to send a TAN message');
-        }
-        if (!this.config.selectedTanMethod?.isDecoupled && !tan) {
-            throw Error('TAN must be provided for non-decoupled TAN methods');
-        }
-        if (!this.isInitialized) {
-            throw Error('dialog must be initialized before sending a TAN message');
-        }
-        if (this.hasEnded) {
-            throw Error('cannot send a TAN message when dialog has alreay ended');
-        }
-        this.lastMessageNumber++;
-        const message = new CustomerMessage(this.dialogId, this.lastMessageNumber);
-        if (this.config.userId && this.config.pin) {
-            message.sign(this.config.countryCode, this.config.bankId, this.config.userId, this.config.pin, this.config.bankingInformation.systemId, this.config.tanMethodId, tan);
-        }
-        if (this.config.userId && this.config.pin && this.config.tanMethodId) {
-            const hktan = {
-                header: { segId: HKTAN.Id, segNr: 0, version: this.config.selectedTanMethod.version },
-                tanProcess: this.config.selectedTanMethod?.isDecoupled ? TanProcess.Status : TanProcess.Process2,
-                segId: refSegId,
-                orderRef: tanOrderReference,
-                nextTan: false,
-                tanMedia: this.config.selectedTanMethod.tanMediaRequirement >= TanMediaRequirement.Optional
-                    ? this.config.tanMediaName
-                    : undefined,
-            };
-            message.addSegment(hktan);
-        }
-        const responseMessage = await this.httpClient.sendMessage(message);
-        this.checkEnded(responseMessage);
-        return responseMessage;
     }
-    checkEnded(initResponse) {
-        if (initResponse.hasReturnCode(100) || initResponse.hasReturnCode(9800)) {
+    checkEnded(response) {
+        if (response.bankAnswers.some((answer) => answer.code === 100) ||
+            response.bankAnswers.some((answer) => answer.code === 9000)) {
             this.hasEnded = true;
         }
     }

package/dist/httpClient.js

@@ -2,15 +2,23 @@ import { Message } from './message.js';
 export class HttpClient {
     url;
     debug;
-    constructor(url, debug = false) {
+    debugRaw;
+    constructor(url, debug = false, debugRaw = false) {
         this.url = url;
         this.debug = debug;
+        this.debugRaw = debugRaw;
     }
     async sendMessage(message) {
         const encodedMessage = message.encode();
         const requestBuffer = Buffer.from(encodedMessage);
         if (this.debug) {
-            console.log('Request Message:\n' + message.toString());
+            console.log('Request Message:\n');
+            if (this.debugRaw) {
+                console.log(encodedMessage.split("'").join('\n'));
+            }
+            else {
+                console.log(message.toString());
+            }
         }
         const response = await fetch(this.url, {
             method: 'POST',
@@ -24,7 +32,13 @@ export class HttpClient {
                 const customerOrderMessage = message;
                 const responseMessage = Message.decode(responseText, customerOrderMessage.supportsPartedResponseSegments ? customerOrderMessage.orderResponseSegId : undefined);
                 if (this.debug) {
-                    console.log('Response Message:\n' + responseMessage.toString(true) + '\n');
+                    console.log('Response Message:\n');
+                    if (this.debugRaw) {
+                        console.log(responseText.split("'").join('\n'));
+                    }
+                    else {
+                        console.log('Response Message:\n' + responseMessage.toString(true) + '\n');
+                    }
                 }
                 return responseMessage;
             }

package/dist/index.js

@@ -12,5 +12,6 @@ export * from './bankingInformation.js';
 export * from './accountBalance.js';
 export * from './bpd.js';
 export * from './upd.js';
+export * from './statement.js';
 export * from './mt940parser.js';
 export * from './mt535parser.js';

package/dist/interactions/balanceInteraction.js

@@ -13,11 +13,11 @@ export class BalanceInteraction extends CustomerOrderInteraction {
         if (!init.isAccountTransactionSupported(this.accountNumber, this.segId)) {
             throw Error(`Account ${this.accountNumber} does not support business transaction '${this.segId}'`);
         }
-        const account = { ...bankAccount, iban: undefined };
         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 hksal = {
             header: { segId: HKSAL.Id, segNr: 0, version: version },
             account,