lib-fints 1.3.1 → 1.4.0

package/dist/interactions/endDialogInteraction.js

@@ -0,0 +1,17 @@
+import { CustomerInteraction } from './customerInteraction.js';
+import { HKEND } from '../segments/HKEND.js';
+export class EndDialogInteraction extends CustomerInteraction {
+    constructor() {
+        super(HKEND.Id);
+    }
+    createSegments(init) {
+        const hkend = {
+            header: { segId: HKEND.Id, segNr: 0, version: HKEND.Version },
+            dialogId: this.dialog.dialogId,
+        };
+        return [hkend];
+    }
+    handleResponse(response, clientResponse) {
+        // no special response handling needed
+    }
+}

package/dist/interactions/initDialogInteraction.js

@@ -1,7 +1,7 @@
 import { CustomerInteraction } from './customerInteraction.js';
 import { HKIDN } from '../segments/HKIDN.js';
 import { HKVVB } from '../segments/HKVVB.js';
-import { Language, SyncMode } from '../codes.js';
+import { Language, SyncMode, TanMediaRequirement } from '../codes.js';
 import { HKSYN } from '../segments/HKSYN.js';
 import { HISYN } from '../segments/HISYN.js';
 import { HIBPA } from '../segments/HIBPA.js';
@@ -12,15 +12,17 @@ import { HIUPA } from '../segments/HIUPA.js';
 import { finTsAccountTypeToEnum } from '../bankAccount.js';
 import { HIKIM } from '../segments/HIKIM.js';
 import { HIUPD } from '../segments/HIUPD.js';
+import { HKTAB } from '../segments/HKTAB.js';
+import { TanMediaInteraction } from './tanMediaInteraction.js';
+import { HKSPA } from '../segments/HKSPA.js';
+import { SepaAccountInteraction } from './sepaAccountInteraction.js';
 export class InitDialogInteraction extends CustomerInteraction {
     config;
     syncSystemId;
-    followUpInteraction;
-    constructor(config, syncSystemId = false, followUpInteraction) {
+    constructor(config, syncSystemId = false) {
         super(HKIDN.Id);
         this.config = config;
         this.syncSystemId = syncSystemId;
-        this.followUpInteraction = followUpInteraction;
     }
     createSegments(init) {
         const segments = [];
@@ -51,7 +53,6 @@ export class InitDialogInteraction extends CustomerInteraction {
         return segments;
     }
     handleResponse(response, clientResponse) {
-        const currentBankingInformationSnapshot = JSON.stringify(this.config.bankingInformation);
         const hisyn = response.findSegment(HISYN.Id);
         if (hisyn && hisyn.systemId) {
             this.config.bankingInformation.systemId = hisyn.systemId;
@@ -129,7 +130,6 @@ export class InitDialogInteraction extends CustomerInteraction {
             this.config.bankingInformation.bpd = bpd;
         }
         const tanMethodMessaqe = bankAnswers.find((answer) => answer.code === 3920);
-        let availableTanMethodIds = [];
         if (tanMethodMessaqe && this.config.bankingInformation.bpd) {
             this.config.bankingInformation.bpd.availableTanMethodIds =
                 tanMethodMessaqe.params?.map((p) => Number.parseInt(p)) ?? [];
@@ -164,8 +164,18 @@ export class InitDialogInteraction extends CustomerInteraction {
         const bankMessages = hikimSegments.map((s) => ({ subject: s.subject, text: s.text }));
         this.config.bankingInformation.bankMessages = bankMessages;
         clientResponse.bankingInformation = this.config.bankingInformation;
-        clientResponse.bankingInformationUpdated =
-            currentBankingInformationSnapshot !== JSON.stringify(this.config.bankingInformation);
+        if (this.config.selectedTanMethod &&
+            this.config.selectedTanMethod.tanMediaRequirement > TanMediaRequirement.NotAllowed &&
+            this.config.isTransactionSupported(HKTAB.Id)) {
+            this.dialog.addCustomerInteraction(new TanMediaInteraction(), true);
+        }
+        const bankAccounts = this.config.bankingInformation?.upd?.bankAccounts;
+        if (bankAccounts) {
+            if (bankAccounts.some((account) => account.isSepaAccount === undefined) &&
+                this.config.isTransactionSupported(HKSPA.Id)) {
+                this.dialog.addCustomerInteraction(new SepaAccountInteraction(), true);
+            }
+        }
     }
 }
 function isDecoupledTanMethod(tanMethod) {

package/dist/interactions/sepaAccountInteraction.js

@@ -0,0 +1,48 @@
+import { CustomerOrderInteraction } from './customerInteraction.js';
+import { HISPA } from '../segments/HISPA.js';
+import { HKSPA } from '../segments/HKSPA.js';
+export class SepaAccountInteraction extends CustomerOrderInteraction {
+    accounts;
+    maxEntries;
+    constructor(accounts, // optional specific account numbers
+    maxEntries) {
+        super(HKSPA.Id, HISPA.Id);
+        this.accounts = accounts;
+        this.maxEntries = maxEntries;
+    }
+    createSegments(init) {
+        if (!init.isTransactionSupported(this.segId)) {
+            throw Error(`Business transaction '${this.segId}' is not supported by this bank`);
+        }
+        const version = init.getMaxSupportedTransactionVersion(HKSPA.Id);
+        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 hkspa = {
+            header: { segId: HKSPA.Id, segNr: 0, version: version },
+            accounts: accounts,
+            maxEntries: this.maxEntries,
+        };
+        return [hkspa];
+    }
+    handleResponse(response, clientResponse) {
+        const hispa = response.findSegment(HISPA.Id);
+        if (hispa) {
+            clientResponse.sepaAccounts = hispa.sepaAccounts || [];
+            this.dialog.config.bankingInformation.upd.bankAccounts.forEach((bankAccount) => {
+                bankAccount.isSepaAccount = false;
+            });
+            clientResponse.sepaAccounts.forEach((sepaAccount) => {
+                const bankAccount = this.dialog.config.getBankAccount(sepaAccount.accountNumber);
+                if (bankAccount) {
+                    bankAccount.isSepaAccount = sepaAccount.isSepaAccount;
+                    bankAccount.iban = sepaAccount.iban;
+                    bankAccount.bic = sepaAccount.bic;
+                }
+            });
+        }
+    }
+}

package/dist/interactions/statementInteractionCAMT.js

@@ -0,0 +1,54 @@
+import { CustomerOrderInteraction } from './customerInteraction.js';
+import { HKCAZ } from '../segments/HKCAZ.js';
+import { HICAZ } from '../segments/HICAZ.js';
+import { CamtParser } from '../camtParser.js';
+export class StatementInteractionCAMT extends CustomerOrderInteraction {
+    accountNumber;
+    from;
+    to;
+    acceptedCamtFormats = ['urn:iso:std:iso:20022:tech:xsd:camt.052.001.08'];
+    constructor(accountNumber, from, to) {
+        super(HKCAZ.Id, HICAZ.Id);
+        this.accountNumber = accountNumber;
+        this.from = from;
+        this.to = to;
+    }
+    createSegments(init) {
+        const bankAccount = init.getBankAccount(this.accountNumber);
+        const version = init.getMaxSupportedTransactionVersion(HKCAZ.Id);
+        if (!version) {
+            throw Error(`There is no supported version for business transaction '${HKCAZ.Id}'`);
+        }
+        const hkcaz = {
+            header: { segId: HKCAZ.Id, segNr: 0, version: version },
+            account: bankAccount,
+            acceptedCamtFormats: this.acceptedCamtFormats,
+            allAccounts: false,
+            from: this.from,
+            to: this.to,
+        };
+        return [hkcaz];
+    }
+    handleResponse(response, clientResponse) {
+        const hicaz = response.findSegment(HICAZ.Id);
+        if (hicaz && hicaz.bookedTransactions && hicaz.bookedTransactions.length > 0) {
+            try {
+                // Parse all CAMT messages (one per booking day) and combine statements
+                const allStatements = [];
+                for (const camtMessage of hicaz.bookedTransactions) {
+                    const parser = new CamtParser(camtMessage);
+                    const statements = parser.parse();
+                    allStatements.push(...statements);
+                }
+                clientResponse.statements = allStatements;
+            }
+            catch (error) {
+                console.warn('CAMT parsing failed:', error);
+                clientResponse.statements = [];
+            }
+        }
+        else {
+            clientResponse.statements = [];
+        }
+    }
+}

package/dist/interactions/{statementInteraction.js → statementInteractionMT940.js}

@@ -2,7 +2,7 @@ import { CustomerOrderInteraction } from './customerInteraction.js';
 import { HKKAZ } from '../segments/HKKAZ.js';
 import { HIKAZ } from '../segments/HIKAZ.js';
 import { Mt940Parser } from '../mt940parser.js';
-export class StatementInteraction extends CustomerOrderInteraction {
+export class StatementInteractionMT940 extends CustomerOrderInteraction {
     accountNumber;
     from;
     to;
@@ -14,13 +14,10 @@ export class StatementInteraction extends CustomerOrderInteraction {
     }
     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 account = { ...bankAccount, iban: undefined };
         const version = init.getMaxSupportedTransactionVersion(HKKAZ.Id);
         if (!version) {
-            throw Error(`There is no supported version for business transaction '${HKKAZ.Id}`);
+            throw Error(`There is no supported version for business transaction '${HKKAZ.Id}'`);
         }
         const hkkaz = {
             header: { segId: HKKAZ.Id, segNr: 0, version: version },
@@ -33,9 +30,15 @@ export class StatementInteraction extends CustomerOrderInteraction {
     }
     handleResponse(response, clientResponse) {
         const hikaz = response.findSegment(HIKAZ.Id);
-        if (hikaz) {
-            const parser = new Mt940Parser(hikaz.bookedTransactions);
-            clientResponse.statements = parser.parse();
+        if (hikaz && hikaz.bookedTransactions) {
+            try {
+                const parser = new Mt940Parser(hikaz.bookedTransactions);
+                clientResponse.statements = parser.parse();
+            }
+            catch (error) {
+                console.warn('MT940 parsing failed:', error);
+                clientResponse.statements = [];
+            }
         }
         else {
             clientResponse.statements = [];

package/dist/interactions/tanMediaInteraction.js

@@ -24,6 +24,10 @@ export class TanMediaInteraction extends CustomerOrderInteraction {
             clientResponse.tanMediaList = (hitab.mediaList ?? [])
                 .map((media) => media.name)
                 .filter((name) => name);
+            let tanMethod = this.dialog.config.selectedTanMethod;
+            if (tanMethod) {
+                tanMethod.activeTanMedia = clientResponse.tanMediaList;
+            }
         }
     }
 }

package/dist/segments/HICAZ.js

@@ -0,0 +1,22 @@
+import { Binary } from '../dataElements/Binary.js';
+import { Text } from '../dataElements/Text.js';
+import { InternationalAccountGroup } from '../dataGroups/InternationalAccount.js';
+import { DataGroup } from '../dataGroups/DataGroup.js';
+import { SegmentDefinition } from '../segmentDefinition.js';
+/**
+ * Account transactions within period response (CAMT format)
+ */
+export class HICAZ extends SegmentDefinition {
+    static Id = 'HICAZ';
+    static Version = 1;
+    constructor() {
+        super(HICAZ.Id);
+    }
+    version = HICAZ.Version;
+    elements = [
+        new InternationalAccountGroup('account', 1, 1),
+        new Text('camtDescriptor', 1, 1), // camt-Descriptor (single format used)
+        new DataGroup('bookedTransactions', [new Binary('camtMessage', 1, 99)], 1, 1), // Booked CAMT transactions
+        new DataGroup('notedTransactions', [new Binary('camtMessage', 1, 99)], 0, 1), // Noted CAMT transactions
+    ];
+}

package/dist/segments/HICAZS.js

@@ -0,0 +1,19 @@
+import { YesNo } from '../dataElements/YesNo.js';
+import { Numeric } from '../dataElements/Numeric.js';
+import { BusinessTransactionParameter } from './businessTransactionParameter.js';
+import { AlphaNumeric } from '../dataElements/AlphaNumeric.js';
+/**
+ * Parameters for HKCAZ business transaction (CAMT format statement retrieval)
+ */
+export class HICAZS extends BusinessTransactionParameter {
+    static Id = 'HICAZS';
+    version = 1;
+    constructor() {
+        super(HICAZS.Id, [
+            new Numeric('maxDays', 1, 1, 4),
+            new YesNo('maxEntryCountAllowed', 1, 1),
+            new YesNo('allAccountsAllowed', 1, 1),
+            new AlphaNumeric('supportedCamtFormats', 1, 99),
+        ]);
+    }
+}

package/dist/segments/HISPA.js

@@ -0,0 +1,14 @@
+import { SepaAccountGroup } from '../dataGroups/SepaAccount.js';
+import { SegmentDefinition } from '../segmentDefinition.js';
+/**
+ * SEPA account connection response - returns IBAN/BIC information
+ * Version 3 - returns SEPA account data in ktz format
+ */
+export class HISPA extends SegmentDefinition {
+    static Id = 'HISPA';
+    version = 3;
+    constructor() {
+        super(HISPA.Id);
+    }
+    elements = [new SepaAccountGroup('sepaAccounts', 0, 999)];
+}

package/dist/segments/HISPAS.js

@@ -0,0 +1,14 @@
+import { BusinessTransactionParameter } from './businessTransactionParameter.js';
+import { SepaAccountParametersGroup } from '../dataGroups/SepaAccountParameters.js';
+/**
+ * Parameters for HKSPA business transaction - SEPA account connection request
+ * Version 3 supports all parameters including reserved purpose positions
+ */
+export class HISPAS extends BusinessTransactionParameter {
+    static Id = 'HISPAS';
+    version = 3;
+    constructor() {
+        super(HISPAS.Id, [new SepaAccountParametersGroup('sepaAccountParams', 1, 1)], 1 // secClassMinVersion
+        );
+    }
+}

package/dist/segments/HKCAZ.js

@@ -0,0 +1,28 @@
+import { Dat } from '../dataElements/Dat.js';
+import { YesNo } from '../dataElements/YesNo.js';
+import { Numeric } from '../dataElements/Numeric.js';
+import { AlphaNumeric } from '../dataElements/AlphaNumeric.js';
+import { Text } from '../dataElements/Text.js';
+import { InternationalAccountGroup } from '../dataGroups/InternationalAccount.js';
+import { DataGroup } from '../dataGroups/DataGroup.js';
+import { SegmentDefinition } from '../segmentDefinition.js';
+/**
+ * Request account transactions in a given period (CAMT format)
+ */
+export class HKCAZ extends SegmentDefinition {
+    static Id = 'HKCAZ';
+    static Version = 1;
+    constructor() {
+        super(HKCAZ.Id);
+    }
+    version = HKCAZ.Version;
+    elements = [
+        new InternationalAccountGroup('account', 1, 1),
+        new DataGroup('acceptedCamtFormats', [new Text('camtFormat', 1, 99)], 1, 1), // Support multiple camt-formats
+        new YesNo('allAccounts', 1, 1),
+        new Dat('from', 0, 1),
+        new Dat('to', 0, 1),
+        new Numeric('maxEntries', 0, 1, 4),
+        new AlphaNumeric('continuationMark', 0, 1, 35),
+    ];
+}

package/dist/segments/HKSPA.js

@@ -0,0 +1,21 @@
+import { Numeric } from '../dataElements/Numeric.js';
+import { AlphaNumeric } from '../dataElements/AlphaNumeric.js';
+import { AccountGroup } from '../dataGroups/Account.js';
+import { SegmentDefinition } from '../segmentDefinition.js';
+/**
+ * Request SEPA account connections (IBAN/BIC information)
+ * Version 3 - supports account specification, max entries and continuation
+ */
+export class HKSPA extends SegmentDefinition {
+    static Id = 'HKSPA';
+    static Version = 3;
+    constructor() {
+        super(HKSPA.Id);
+    }
+    version = HKSPA.Version;
+    elements = [
+        new AccountGroup('accounts', 0, 999),
+        new Numeric('maxEntries', 0, 1, 4, 2),
+        new AlphaNumeric('continuationMark', 0, 1, 35, 2),
+    ];
+}

package/dist/segments/registry.js

@@ -26,11 +26,17 @@ import { HISAL } from './HISAL.js';
 import { HKKAZ } from './HKKAZ.js';
 import { HIKAZ } from './HIKAZ.js';
 import { HIKAZS } from './HIKAZS.js';
+import { HKCAZ } from './HKCAZ.js';
+import { HICAZ } from './HICAZ.js';
+import { HICAZS } from './HICAZS.js';
 import { HITAB } from './HITAB.js';
 import { HKWPD } from './HKWPD.js';
 import { HIWPD } from './HIWPD.js';
-import { DIKKU } from "./DIKKU.js";
-import { DKKKU } from "./DKKKU.js";
+import { HKSPA } from './HKSPA.js';
+import { HISPA } from './HISPA.js';
+import { HISPAS } from './HISPAS.js';
+import { DIKKU } from './DIKKU.js';
+import { DKKKU } from './DKKKU.js';
 import { UNKNOW } from '../unknownSegment.js';
 import { PARTED } from '../partedSegment.js';
 const registry = new Map();
@@ -66,8 +72,16 @@ export function registerSegments() {
     registerSegmentDefinition(new DIKKU());
     registerSegmentDefinition(new HIKAZ());
     registerSegmentDefinition(new HIKAZS());
+    registerSegmentDefinition(new HKCAZ());
+    registerSegmentDefinition(new HICAZ());
+    registerSegmentDefinition(new HICAZS());
     registerSegmentDefinition(new HKWPD());
     registerSegmentDefinition(new HIWPD());
+    registerSegmentDefinition(new HKWPD());
+    registerSegmentDefinition(new HIWPD());
+    registerSegmentDefinition(new HKSPA());
+    registerSegmentDefinition(new HISPA());
+    registerSegmentDefinition(new HISPAS());
     registerSegmentDefinition(new UNKNOW());
     registerSegmentDefinition(new PARTED());
 }

package/dist/statement.js

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

package/dist/tests/HICAZS.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { registerSegments } from '../segments/registry.js';
+import { decode, encode } from '../segment.js';
+registerSegments();
+describe('HICAZS', () => {
+    it('decode and encode roundtrip matches', () => {
+        const text = "HICAZS:16:1:4+1+1+0+450:N:N:urn?:iso?:std?:iso?:20022?:tech?:xsd?:camt.052.001.08:urn?:iso?:std?:iso?:20022?:tech?:xsd?:camt.052.001.08'";
+        const segment = decode(text);
+        expect(segment.params.maxDays).toBe(450);
+        expect(segment.params.entryCountAllowed).toBeFalsy();
+        expect(segment.params.allAccountsAllowed).toBeFalsy();
+        expect(segment.params.supportedCamtFormats).toEqual([
+            'urn:iso:std:iso:20022:tech:xsd:camt.052.001.08',
+            'urn:iso:std:iso:20022:tech:xsd:camt.052.001.08',
+        ]);
+        expect(encode(segment)).toBe(text);
+    });
+});

package/dist/tests/HKCAZ.test.js

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { registerSegments } from '../segments/registry.js';
+import { HKCAZ } from '../segments/HKCAZ.js';
+import { decode, encode } from '../segment.js';
+registerSegments();
+describe('HKCAZ v1', () => {
+    it('encode', () => {
+        const segment = {
+            header: { segId: HKCAZ.Id, segNr: 1, version: 1 },
+            account: {
+                iban: 'DE991234567123456',
+                bic: 'BANK12',
+                accountNumber: '123456',
+                bank: { country: 280, bankId: '12030000' },
+            },
+            acceptedCamtFormats: ['urn:iso:std:iso:20022:tech:xsd:camt.052.001.08'],
+            allAccounts: false,
+            from: new Date('2023-01-01'),
+            to: new Date('2023-12-31'),
+        };
+        expect(encode(segment)).toBe("HKCAZ:1:1+DE991234567123456:BANK12:123456::280:12030000+urn?:iso?:std?:iso?:20022?:tech?:xsd?:camt.052.001.08+N+20230101+20231231'");
+    });
+    it('encode without optional dates', () => {
+        const segment = {
+            header: { segId: HKCAZ.Id, segNr: 2, version: 1 },
+            account: {
+                iban: 'DE991234567123456',
+                bic: 'BANK12',
+                accountNumber: '123456',
+                bank: { country: 280, bankId: '12030000' },
+            },
+            acceptedCamtFormats: ['urn:iso:std:iso:20022:tech:xsd:camt.052.001.08'],
+            allAccounts: true,
+        };
+        expect(encode(segment)).toBe("HKCAZ:2:1+DE991234567123456:BANK12:123456::280:12030000+urn?:iso?:std?:iso?:20022?:tech?:xsd?:camt.052.001.08+J'");
+    });
+    it('decode and encode roundtrip matches', () => {
+        const text = "HKCAZ:0:1+DE991234567123456:BANK12:123456::280:12030000+urn?:iso?:std?:iso?:20022?:tech?:xsd?:camt.052.001.08+N+20230101+20231231'";
+        const segment = decode(text);
+        expect(encode(segment)).toBe(text);
+    });
+    it('decode and encode roundtrip without dates', () => {
+        const text = "HKCAZ:0:1+DE991234567123456:BANK12+urn?:iso?:std?:iso?:20022?:tech?:xsd?:camt.052.001.08+J'";
+        const segment = decode(text);
+        expect(encode(segment)).toBe(text);
+    });
+});