@develit-services/bank 0.0.3 → 0.0.4

package/dist/shared/bank.BU2_AKRG.cjs

@@ -0,0 +1,724 @@
+'use strict';
+
+const backendSdk = require('@develit-io/backend-sdk');
+const database_schema = require('./bank.CrAQe4PH.cjs');
+const drizzleOrm = require('drizzle-orm');
+const dateFns = require('date-fns');
+const jose = require('jose');
+const generalCodes = require('@develit-io/general-codes');
+const zod = require('zod');
+
+const tables = database_schema.schema;
+
+const PAYMENT_TYPES = ["SEPA", "SWIFT", "IFSC", "DOMESTIC"];
+const PAYMENT_STATUSES = [
+  "PREPARED",
+  "INITIALIZED",
+  "FAILED",
+  "PENDING",
+  "COMPLETED",
+  "CREATED"
+];
+const PAYMENT_DIRECTIONS = ["INCOMING", "OUTGOING"];
+const BATCH_STATUSES = [
+  "OPEN",
+  "WAITING_FOR_PROCESSING",
+  "PROCESSING",
+  "READY_TO_SIGN",
+  "PREPARED",
+  "COMPLETED",
+  "FAILED"
+];
+const COUNTRY_CODES = generalCodes.COUNTRY_CODES_2;
+
+class IBankConnector {
+}
+
+const isDeposit = (payment, creditorIban) => {
+  return payment.creditorIban === creditorIban;
+};
+const getPaymentDirection = (payment, iban) => {
+  if (isDeposit(payment, iban)) return "INCOMING";
+  return "OUTGOING";
+};
+
+const mapReferencesToPayment = (reference) => {
+  const symbols = {
+    vs: void 0,
+    ss: void 0,
+    ks: void 0
+  };
+  if (!reference) return symbols;
+  if (Array.isArray(reference) && reference.length > 0) {
+    symbols.vs = reference.find((ref) => ref.includes("VS")) || void 0;
+    symbols.ss = reference.find((ref) => ref.includes("SS")) || void 0;
+    symbols.ks = reference.find((ref) => ref.includes("KS")) || void 0;
+  }
+  if (typeof reference === "string") {
+    const vsMatch = reference.match(/VS[:\s]*(\d+)/i);
+    const ssMatch = reference.match(/SS[:\s]*(\d+)/i);
+    const ksMatch = reference.match(/KS[:\s]*(\d+)/i);
+    if (vsMatch) symbols.vs = vsMatch[1];
+    if (ssMatch) symbols.ss = ssMatch[1];
+    if (ksMatch) symbols.ks = ksMatch[1];
+  }
+  return symbols;
+};
+
+class ErsteConnector extends IBankConnector {
+  constructor(config) {
+    super();
+    this.connectorKey = "ERSTE";
+    this.accessToken = null;
+    this.API_KEY = config.API_KEY;
+    this.CLIENT_ID = config.CLIENT_ID;
+    this.CLIENT_SECRET = config.CLIENT_SECRET;
+    this.REDIRECT_URI = config.REDIRECT_URI;
+    this.AUTH_URI = config.AUTH_URI;
+    this.PAYMENTS_URI = config.PAYMENTS_URI;
+    this.ACCOUNTS_URI = config.ACCOUNTS_URI;
+  }
+  static {
+    this.FETCH_INTERVAL = 60 * 60 * 5;
+  }
+  get adminCodeCreationURI() {
+    const params = new URLSearchParams({
+      redirect_uri: `${this.REDIRECT_URI}`,
+      client_id: this.CLIENT_ID,
+      response_type: "code",
+      access_type: "offline",
+      state: "csas-auth",
+      prompt: "consent"
+    });
+    return `${this.AUTH_URI}/auth?${params.toString()}`;
+  }
+  async authenticate({ token, refreshToken }) {
+    const grantType = refreshToken ? "refresh_token" : "authorization_code";
+    let bodyParams = {
+      client_id: this.CLIENT_ID,
+      client_secret: this.CLIENT_SECRET,
+      grant_type: grantType
+    };
+    if (token) {
+      bodyParams = {
+        ...bodyParams,
+        code: token,
+        redirect_uri: this.REDIRECT_URI
+      };
+    }
+    if (refreshToken) bodyParams.refresh_token = refreshToken;
+    const body = new URLSearchParams(bodyParams);
+    const result = await fetch(`${this.AUTH_URI}/token`, {
+      method: "POST",
+      body: body.toString(),
+      headers: { "Content-Type": "application/x-www-form-urlencoded" }
+    });
+    if (result.status !== 200) {
+      throw backendSdk.createInternalError(null, {
+        message: await result.text()
+      });
+    }
+    const json = await result.json();
+    this.accessToken = json.access_token;
+    return json.refresh_token || "";
+  }
+  async preparePayment(payment) {
+    if (!this.accessToken) {
+      throw backendSdk.createInternalError(null, {
+        message: "Internal authentication failed",
+        status: 500
+      });
+    }
+    const paymentBody = {
+      paymentIdentification: {
+        endToEndIdentification: payment.id,
+        instructionIdentification: payment.id
+      },
+      paymentTypeInformation: { instructionPriority: "NORM" },
+      amount: {
+        instructedAmount: { value: payment.amount, currency: payment.currency }
+      },
+      debtorAccount: { identification: { iban: payment.debtorIban } },
+      creditorAccount: { identification: { iban: payment.creditorIban } },
+      creditor: {
+        name: payment.creditorHolderName
+      }
+    };
+    const [data, error] = await backendSdk.useResult(
+      fetch(`${this.PAYMENTS_URI}/my/payments`, {
+        method: "POST",
+        headers: {
+          "WEB-API-key": this.API_KEY,
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.accessToken}`
+        },
+        body: JSON.stringify(paymentBody)
+      })
+    );
+    if (error || !data) {
+      throw error;
+    }
+    const erstePayment = await data.json();
+    return {
+      ...payment,
+      id: backendSdk.uuidv4(),
+      bankRefId: erstePayment.signInfo?.signId,
+      refId: payment.refId,
+      direction: "OUTGOING",
+      paymentType: "DOMESTIC",
+      status: "PREPARED",
+      initiatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async initiateBatchFromPayments({
+    payments
+  }) {
+    const allRefIds = payments.map((payment) => payment.bankRefId);
+    const batchId = backendSdk.uuidv4();
+    if (allRefIds.length === 0) {
+      throw backendSdk.createInternalError(null, {
+        message: "No valid payments to include in batch",
+        status: 400
+      });
+    }
+    const [signInfo, signError] = await backendSdk.useResult(
+      this.sendBatchPaymentForAuthorization(allRefIds)
+    );
+    if (signError) {
+      throw backendSdk.createInternalError(signError);
+    }
+    const [authUri, authUriError] = await backendSdk.useResult(
+      this.getBatchAuthorizationURI(signInfo)
+    );
+    if (authUriError) {
+      throw backendSdk.createInternalError(authUriError);
+    }
+    return {
+      id: batchId,
+      authorizationUrls: [authUri || ""],
+      payments: payments.map((payment) => ({
+        ...payment,
+        status: "INITIALIZED"
+      })),
+      metadata: signInfo
+    };
+  }
+  initiateSinglePayment() {
+    throw new Error("Method not implemented.");
+  }
+  async sendBatchPaymentForAuthorization(paymentIds) {
+    const [data, error] = await backendSdk.useResult(
+      fetch(`${this.PAYMENTS_URI}/my/batchpayments`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.accessToken}`,
+          "WEB-API-key": this.CLIENT_SECRET
+        },
+        body: JSON.stringify({
+          exchangeIdentification: "658576010faf0a23dc",
+          payments: paymentIds
+        })
+      })
+    );
+    if (error) throw error;
+    const batch = await data.json();
+    return {
+      signHash: batch.signInfo.hash,
+      signId: batch.signInfo.signId
+    };
+  }
+  async getBatchAuthorizationURI({
+    signId,
+    signHash
+  }) {
+    const [data, error] = await backendSdk.useResult(
+      fetch(
+        `${this.PAYMENTS_URI}/my/batchpayments/federate/sign/${signId}/hash/${signHash}`,
+        {
+          method: "GET",
+          headers: {
+            "Callback-Uri": `${this.REDIRECT_URI}/payment-authorization-complete`,
+            Authorization: `Bearer ${this.accessToken}`,
+            "WEB-API-key": this.CLIENT_SECRET
+          }
+        }
+      )
+    );
+    if (error) {
+      throw error;
+    }
+    return (await data.json()).signingUrl;
+  }
+  async getAllAccountPayments({
+    account,
+    lastSync
+  }) {
+    const erstePayments = [];
+    const dateFormat = "yyyy-MM-dd";
+    const fromDate = dateFns.format(lastSync.lastSyncedAt, dateFormat);
+    const toDate = dateFns.format(/* @__PURE__ */ new Date(), dateFormat);
+    let page = 0;
+    const pageSize = 200;
+    const pageCount = 1;
+    while (page < pageCount) {
+      const response = await fetch(
+        `${this.ACCOUNTS_URI}/my/accounts/${account.id}/transactions?fromDate=${fromDate}&toDate=${toDate}&size=${pageSize}&page=${page}&sort=bookingDate&order=desc`,
+        {
+          headers: {
+            "WEB-API-key": this.API_KEY,
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        }
+      );
+      const data = await response.json();
+      erstePayments.push(...data.transactions);
+      page += 1;
+    }
+    const payments = erstePayments.map((payment) => {
+      const reference = payment.entryDetails.transactionDetails.remittanceInformation?.structured.creditorReferenceInformation?.reference || [];
+      const symbols = mapReferencesToPayment(reference);
+      const paymentInsert = {
+        id: backendSdk.uuidv4(),
+        bankRefId: payment.entryReference,
+        amount: payment.amount.value,
+        currency: payment.amount.currency.code,
+        debtorHolderName: payment.entryDetails.transactionDetails.relatedParties.debtor?.name,
+        debtorIban: payment.entryDetails.transactionDetails.relatedParties.debtorAccount?.identification.iban,
+        debtorAccountNumberWithBankCode: payment.entryDetails.transactionDetails.relatedParties.debtorAccount?.identification.other?.identification,
+        creditorHolderName: payment.entryDetails.transactionDetails.relatedParties.creditor?.name || "",
+        creditorIban: payment.entryDetails.transactionDetails.relatedParties.creditorAccount?.identification.iban,
+        creditorAccountNumberWithBankCode: payment.entryDetails.transactionDetails.relatedParties.creditorAccount?.identification.other?.identification,
+        paymentType: "DOMESTIC",
+        direction: "INCOMING",
+        message: payment.entryDetails.transactionDetails.remittanceInformation?.unstructured,
+        vs: symbols.vs,
+        ss: symbols.ss,
+        ks: symbols.ks,
+        processedAt: dateFns.parseISO(payment.bookingDate.date),
+        status: "COMPLETED"
+      };
+      return {
+        ...paymentInsert,
+        direction: getPaymentDirection(
+          paymentInsert,
+          account.identification.iban
+        )
+      };
+    });
+    return payments;
+  }
+}
+
+const mapFinbricksStatus = (status) => {
+  switch (status) {
+    case "BOOK":
+      return "COMPLETED";
+    case "PDNG":
+      return "PENDING";
+    case "CANCL":
+      return "FAILED";
+    case "RJCT":
+      return "FAILED";
+    case "SCHDL":
+      return "PENDING";
+    case "HOLD":
+      return "PENDING";
+    case "INFO":
+      return "PENDING";
+    default:
+      return "PENDING";
+  }
+};
+
+class FinbricksConnector extends IBankConnector {
+  constructor(PROVIDER, { BASE_URI, MERCHANT_ID, PRIVATE_KEY_PEM }) {
+    super();
+    this.connectorKey = "FINBRICKS";
+    this.apiDictionary = /* @__PURE__ */ new Map([
+      ["single-payment-domestic", "/transaction/platform/init"],
+      ["batch-payment-domestic", "/transaction/platform/batchPayment/init"],
+      ["get-accounts", "/account/list"],
+      ["get-account-transactions", "/account/transactions"],
+      ["authenticate-client", "/v2/auth/authenticate"],
+      ["expiration", "/auth/token"]
+    ]);
+    this.PROVIDER = PROVIDER;
+    this.BASE_URI = BASE_URI;
+    this.MERCHANT_ID = MERCHANT_ID;
+    this.PRIVATE_KEY_PEM = PRIVATE_KEY_PEM;
+  }
+  static {
+    this.FETCH_INTERVAL = 60 * 60 * 5;
+  }
+  async signFinbricksJws({ jwsData }) {
+    const privateKey = await jose.importPKCS8(this.PRIVATE_KEY_PEM, "RS256");
+    const payload = JSON.stringify(jwsData);
+    const jws = await new jose.SignJWT(JSON.parse(payload)).setProtectedHeader({
+      alg: "RS256",
+      kid: this.MERCHANT_ID,
+      typ: "JWT"
+    }).sign(privateKey);
+    return jws;
+  }
+  async authenticate({ token }) {
+    this.lastValidClientId = token;
+    return this.lastValidClientId;
+  }
+  async isClientIdExpired(clientId) {
+    const query = new URLSearchParams({
+      merchantId: this.MERCHANT_ID,
+      provider: this.PROVIDER,
+      clientId
+    });
+    const uri = this.apiDictionary.get("expiration");
+    const fullUri = `${uri}?${query.toString()}`;
+    const signature = await this.signFinbricksJws({
+      jwsData: {
+        body: "",
+        uri: fullUri
+      }
+    });
+    const [data, error] = await backendSdk.useResult(
+      fetch(`${this.BASE_URI}${fullUri}`, {
+        method: "POST",
+        headers: {
+          "JWS-Signature": signature,
+          "Content-Type": "application/json"
+        },
+        body: ""
+      })
+    );
+    if (error) {
+      const body = await data?.json();
+      throw backendSdk.createInternalError(error, {
+        message: body?.message || "Finbricks API error"
+      });
+    }
+    if (!data?.ok) {
+      const body = await data.json();
+      throw backendSdk.createInternalError(null, {
+        message: body.message || "Finbricks API error",
+        code: "FINBRICKS_API_ERROR",
+        status: data?.status || 500
+      });
+    }
+    const tokens = await data.json();
+    return !!tokens.find((token) => token.clientId === clientId);
+  }
+  async preparePayment(payment) {
+    const bankRefId = backendSdk.uuidv4();
+    return {
+      ...payment,
+      id: backendSdk.uuidv4(),
+      bankRefId,
+      direction: "OUTGOING",
+      paymentType: "DOMESTIC",
+      status: "PREPARED",
+      initiatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async initiateBatchFromPayments({
+    payments
+  }) {
+    const uri = this.apiDictionary.get("batch-payment-domestic");
+    const batchId = backendSdk.uuidv4();
+    const batchBody = {
+      batchPaymentIdentification: {
+        merchantId: this.MERCHANT_ID,
+        debtorAccountIban: payments[0].debtorIban,
+        clientId: this.lastValidClientId,
+        callbackUrl: "https://example.com/callback",
+        merchantBatchId: batchId
+      },
+      payments: payments.map((payment) => ({
+        merchantTransactionId: payment.bankRefId,
+        creditorAccountIban: payment.creditorIban,
+        amount: payment.amount
+      }))
+    };
+    const payload = JSON.stringify(batchBody);
+    const jwsData = {
+      uri,
+      body: payload
+    };
+    const signature = await this.signFinbricksJws({
+      jwsData
+    });
+    const [data, error] = await backendSdk.useResult(
+      fetch(`${this.BASE_URI}${uri}`, {
+        method: "POST",
+        headers: {
+          "JWS-Signature": signature,
+          "Content-Type": "application/json"
+        },
+        body: payload
+      })
+    );
+    const body = await data?.json();
+    if (error) {
+      throw backendSdk.createInternalError(error, {
+        message: body?.message || "Finbricks API error"
+      });
+    }
+    if (!data?.ok) {
+      console.log("FINBRICKSBODY", body);
+      throw backendSdk.createInternalError(null, {
+        message: body?.message || "Finbricks API error",
+        code: "FINBRICKS_API_ERROR",
+        status: data?.status || 500
+      });
+    }
+    const { redirectUrl } = body;
+    return {
+      id: batchId,
+      authorizationUrls: [redirectUrl],
+      payments: payments.map((payment) => ({
+        ...payment,
+        status: "INITIALIZED"
+      }))
+    };
+  }
+  async initiateSinglePayment(payment) {
+    const uri = this.apiDictionary.get("single-payment-domestic");
+    const paymentBody = {
+      merchantId: this.MERCHANT_ID,
+      merchantTransactionId: payment.bankRefId,
+      totalPrice: payment.amount,
+      creditorAccountIban: payment.creditorIban,
+      debtorAccountIban: payment.debtorIban,
+      creditorName: payment.creditorHolderName,
+      description: payment.message || "",
+      variableSymbol: payment.vs || "",
+      callbackUrl: "example.com",
+      paymentProvider: this.PROVIDER
+    };
+    const signature = await this.signFinbricksJws({
+      jwsData: {
+        body: JSON.stringify(paymentBody),
+        uri
+      }
+    });
+    const [data, error] = await backendSdk.useResult(
+      fetch(`${this.BASE_URI}${uri}`, {
+        method: "POST",
+        headers: {
+          "JWS-Signature": signature,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(paymentBody)
+      })
+    );
+    const body = await data?.json();
+    if (error) {
+      throw backendSdk.createInternalError(error, {
+        message: body?.message || "Finbricks API error"
+      });
+    }
+    if (!data?.ok) {
+      console.log("FINBRICKSBODY", body);
+      throw backendSdk.createInternalError(null, {
+        message: body?.message || "Finbricks API error",
+        code: "FINBRICKS_API_ERROR",
+        status: data?.status || 500
+      });
+    }
+    const redirectUrl = (await data.json()).redirectUrl;
+    return {
+      authorizationUrl: redirectUrl,
+      payment: { ...payment, status: "INITIALIZED" }
+    };
+  }
+  async getAllAccountPayments({
+    account,
+    lastSync
+  }) {
+    const uri = this.apiDictionary.get("get-account-transactions");
+    const dateFormat = "yyyy-MM-dd";
+    let cursor = null;
+    let allPayments = [];
+    const dateFrom = dateFns.format(lastSync.lastSyncedAt, dateFormat);
+    const dateTo = dateFns.format(/* @__PURE__ */ new Date(), dateFormat);
+    do {
+      const query = new URLSearchParams({
+        merchantId: this.MERCHANT_ID,
+        clientId: this.lastValidClientId,
+        paymentProvider: this.PROVIDER,
+        bankAccountId: account.identification.number,
+        dateFrom,
+        dateTo,
+        currency: account.currency,
+        size: "20"
+      });
+      console.log("query", query);
+      if (cursor) query.set("cursor", cursor);
+      const fullUri = `${uri}?${query.toString()}`;
+      const jwsData = {
+        uri: fullUri,
+        body: ""
+      };
+      const signature = await this.signFinbricksJws({ jwsData });
+      console.log("signature ready", signature);
+      const [data, error] = await backendSdk.useResult(
+        fetch(`${this.BASE_URI}${fullUri}`, {
+          method: "GET",
+          headers: {
+            "JWS-Signature": signature,
+            "Content-Type": "application/json"
+          }
+        })
+      );
+      if (error) {
+        const body = await data?.json();
+        throw backendSdk.createInternalError(error, {
+          message: body?.message || "Finbricks API error"
+        });
+      }
+      if (!data?.ok) {
+        const body = await data.json();
+        throw backendSdk.createInternalError(null, {
+          message: body.message || "Finbricks API error",
+          code: "FINBRICKS_API_ERROR",
+          status: data?.status || 500
+        });
+      }
+      const { transactions, links } = await data.json();
+      cursor = links?.[0]?.value || null;
+      allPayments = [
+        ...allPayments,
+        ...transactions.map((tx) => {
+          const isIncoming = tx.creditDebitIndicator === "CRDT";
+          const relatedParties = tx.entryDetails?.transactionDetails?.relatedParties;
+          const paymentInsert = {
+            id: backendSdk.uuidv4(),
+            bankRefId: tx.entryReference || tx.fbxReference,
+            amount: tx.amount?.value || 0,
+            currency: tx.amount?.currency || "CZK",
+            debtorHolderName: isIncoming ? relatedParties?.debtor?.name || "Unknown" : "Unknown",
+            debtorIban: isIncoming ? relatedParties?.debtorAccount?.identification?.iban || account.identification.iban : account.identification.iban,
+            debtorAccountNumberWithBankCode: isIncoming ? relatedParties?.debtorAccount?.identification?.other?.identification || `${account.identification.number}/${account.identification.bankCode}` : `${account.identification.number}/${account.identification.bankCode}`,
+            creditorHolderName: isIncoming ? "Unknown" : relatedParties?.creditor?.name || "Unknown",
+            creditorIban: isIncoming ? account.identification.iban : relatedParties?.creditorAccount?.identification?.iban || account.identification.iban,
+            creditorAccountNumberWithBankCode: isIncoming ? `${account.identification.number}/${account.identification.bankCode}` : relatedParties?.creditorAccount?.identification?.other?.identification || `${account.identification.number}/${account.identification.bankCode}`,
+            paymentType: "DOMESTIC",
+            direction: isIncoming ? "INCOMING" : "OUTGOING",
+            message: tx.entryDetails?.transactionDetails?.remittanceInformation?.unstructured || tx.entryDetails?.transactionDetails?.additionalRemittanceInformation || null,
+            ...mapReferencesToPayment(
+              tx.entryDetails?.transactionDetails?.remittanceInformation?.structured?.creditorReferenceInformation?.reference || tx.entryDetails?.transactionDetails?.references?.endToEndIdentification
+            ),
+            processedAt: new Date(tx.bookingDate.date),
+            status: "COMPLETED"
+          };
+          return {
+            ...paymentInsert,
+            direction: getPaymentDirection(
+              paymentInsert,
+              account.identification.iban
+            ),
+            status: mapFinbricksStatus(tx.status)
+          };
+        })
+      ];
+    } while (cursor != null);
+    return allPayments;
+  }
+}
+
+class MockConnector extends IBankConnector {
+  constructor() {
+    super(...arguments);
+    this.connectorKey = "MOCK";
+  }
+  static {
+    this.FETCH_INTERVAL = 60 * 60 * 5;
+  }
+  async authenticate() {
+    return "";
+  }
+  async preparePayment(payment) {
+    const bankRefId = backendSdk.uuidv4();
+    return {
+      ...payment,
+      id: backendSdk.uuidv4(),
+      bankRefId,
+      direction: "OUTGOING",
+      paymentType: "DOMESTIC",
+      status: "PREPARED",
+      initiatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async initiateSinglePayment(payment) {
+    return {
+      payment: {
+        ...payment,
+        status: "INITIALIZED"
+      },
+      authorizationUrl: "http://mock.com"
+    };
+  }
+  async initiateBatchFromPayments({
+    payments
+  }) {
+    return {
+      id: backendSdk.uuidv4(),
+      authorizationUrls: ["http://mock.com"],
+      payments: payments.map((payment) => ({
+        ...payment,
+        status: "INITIALIZED"
+      }))
+    };
+  }
+  async getAllAccountPayments({
+    db
+  }) {
+    const payments = await db.select().from(tables.payment).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(tables.payment.status, "INITIALIZED"),
+        drizzleOrm.eq(tables.payment.direction, "OUTGOING")
+      )
+    );
+    return payments.map((payment) => ({
+      ...payment,
+      status: "COMPLETED"
+    }));
+  }
+}
+
+class MockCobsConnector extends FinbricksConnector {
+  constructor(config) {
+    super("MOCK_COBS", config);
+  }
+}
+
+const paymentInsertTypeZod = zod.z.object({
+  refId: zod.z.string(),
+  bankRefId: zod.z.string(),
+  amount: zod.z.number(),
+  direction: zod.z.enum(PAYMENT_DIRECTIONS),
+  paymentType: zod.z.enum(PAYMENT_TYPES),
+  currency: zod.z.enum(generalCodes.CURRENCY_CODES),
+  status: zod.z.enum(PAYMENT_STATUSES),
+  batchId: zod.z.string(),
+  bankPaymentInitiatedAt: zod.z.coerce.date(),
+  bankPaymentProcessedAt: zod.z.coerce.date(),
+  bankingVs: zod.z.string().max(10),
+  message: zod.z.string(),
+  creditorIban: zod.z.string().max(34),
+  creditorHolderName: zod.z.string(),
+  debtorIban: zod.z.string().max(34),
+  debtorHolderName: zod.z.string().nullable()
+});
+
+exports.BATCH_STATUSES = BATCH_STATUSES;
+exports.COUNTRY_CODES = COUNTRY_CODES;
+exports.ErsteConnector = ErsteConnector;
+exports.FinbricksConnector = FinbricksConnector;
+exports.IBankConnector = IBankConnector;
+exports.MockCobsConnector = MockCobsConnector;
+exports.MockConnector = MockConnector;
+exports.PAYMENT_DIRECTIONS = PAYMENT_DIRECTIONS;
+exports.PAYMENT_STATUSES = PAYMENT_STATUSES;
+exports.PAYMENT_TYPES = PAYMENT_TYPES;
+exports.getPaymentDirection = getPaymentDirection;
+exports.paymentInsertTypeZod = paymentInsertTypeZod;
+exports.tables = tables;