@develit-services/bank 0.0.28 → 0.0.30

package/dist/shared/{bank.DnDcNEvX.mjs → bank.YCUhOduX.mjs}

@@ -1,34 +1,13 @@
-import { uuidv4, useResult, createInternalError } from '@develit-io/backend-sdk';
-import { s as schema, C as CONNECTOR_KEYS } from './bank.C9jAvwna.mjs';
+import { uuidv4, useResult, createInternalError, bankAccount, base } from '@develit-io/backend-sdk';
 import { and, eq } from 'drizzle-orm';
-import { z } from 'zod';
 import { COUNTRY_CODES_2, CURRENCY_CODES } from '@develit-io/general-codes';
+import { z } from 'zod';
 import { importPKCS8, SignJWT } from 'jose';
-import 'superjson';
+import { createInsertSchema, createUpdateSchema, createSelectSchema } from 'drizzle-zod';
+import { sqliteTable, integer, text, unique, real } from 'drizzle-orm/sqlite-core';
 import { format, parseISO } from 'date-fns';
-
-const tables = 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 = COUNTRY_CODES_2;
+import { relations } from 'drizzle-orm/relations';
+import 'superjson';
 
 class IBankConnector {
 }
@@ -128,6 +107,7 @@ const FINBRICKS_ENDPOINTS = {
   ACCOUNT_TRANSACTIONS: "/account/transactions",
   TRANSACTION_INIT: "/transaction/platform/init",
   TRANSACTION_STATUS: "/transaction/platform/status",
+  TRANSACTION_SEPA_INIT: "/transaction/platform/sepa/init",
   TRANSACTION_BATCH_INIT: "/transaction/platform/batchPayment/init",
   BATCH_STATUS: "/transaction/platform/batchPayment/status"
 };
@@ -201,6 +181,7 @@ const mapFinbricksTransactionToPayment = (tx, account) => {
   const related = tx.entryDetails?.transactionDetails?.relatedParties;
   const base = {
     id: uuidv4(),
+    connectorKey: account.connectorKey,
     bankRefId: tx.entryReference || tx.fbxReference,
     amount: tx.amount?.value || 0,
     currency: tx.amount?.currency || "CZK",
@@ -213,49 +194,65 @@ const mapFinbricksTransactionToPayment = (tx, account) => {
     ),
     debtorHolderName: isIncoming ? related?.debtor?.name || "Unknown" : "Unknown",
     creditorHolderName: isIncoming ? "Unknown" : related?.creditor?.name || "Unknown",
-    debtorIban: isIncoming ? related?.debtorAccount?.identification?.iban || account.identification.iban : account.identification.iban,
-    creditorIban: isIncoming ? account.identification.iban : related?.creditorAccount?.identification?.iban || account.identification.iban,
+    debtorIban: isIncoming ? related.debtorAccount?.identification?.iban || account.iban : account.iban,
+    creditorIban: isIncoming ? account.iban : related.creditorAccount?.identification?.iban || account.iban,
     direction: "INCOMING"
     // přepíšeme správným směrem níže
   };
-  base.direction = getPaymentDirection(base, account.identification.iban);
+  base.direction = getPaymentDirection(base, account.iban);
   return base;
 };
 
+const mapFinbricksAccountInsert = ({
+  account,
+  connectorKey,
+  status
+}) => ({
+  id: account.id,
+  connectorKey,
+  status,
+  sync: false,
+  currency: account.currency,
+  number: account.identification.accountNumber,
+  bankCode: account.servicer.bankCode,
+  // For now we are using CZE as fallback because finbricks does not provide country code 100% of the time
+  countryCode: account.servicer.countryCode || "CZE",
+  holderName: account.ownersNames.join(", "),
+  iban: account.identification.iban
+});
+
 class FinbricksConnector extends IBankConnector {
   constructor(provider, {
     BASE_URI,
     MERCHANT_ID,
     PRIVATE_KEY_PEM,
     REDIRECT_URI,
-    KV
+    connectedAccounts
   }) {
     super();
     this.connectorKey = "FINBRICKS";
-    this._clientIds = {};
+    this.connectedAccounts = [];
     this.PROVIDER = provider;
-    this.kv = KV;
     this.finbricks = new FinbricksClient(
       BASE_URI,
       MERCHANT_ID,
       PRIVATE_KEY_PEM,
       REDIRECT_URI
     );
+    this.connectedAccounts = connectedAccounts;
   }
   static {
     this.FETCH_INTERVAL = 60 * 60 * 5;
   }
-  async getAuthUri({
-    accountId,
-    ott
-  }) {
+  async getAuthUri({ ott }) {
     const clientId = uuidv4();
     const body = {
       merchantId: this.finbricks.MERCHANT_ID,
       clientId,
       paymentProvider: this.PROVIDER,
       scope: "AISP_PISP",
-      callbackUrl: `${this.finbricks.REDIRECT_URI}?clientId=${clientId}&accountId=${accountId}&ott=${ott}`
+      // finbricks automatically adds the clientId to the callbackUrl
+      callbackUrl: `${this.finbricks.REDIRECT_URI}?ott=${ott}`
     };
     const [response, error] = await useResult(
       this.finbricks.request({
@@ -271,35 +268,13 @@ class FinbricksConnector extends IBankConnector {
     }
     return response.redirectUrl;
   }
-  get storageKey() {
-    return `${this.connectorKey}:auth`;
-  }
-  async getClientIds() {
-    let saved = await this.kv.get(this.storageKey);
-    if (!saved) {
-      const empty = Object.fromEntries(CONNECTOR_KEYS.map((v) => [v, ""]));
-      empty["FIO"] = "d32a83cf-d352-41f3-96d7-4d2961336ddc";
-      await this.kv.put(this.storageKey, JSON.stringify(empty));
-      saved = JSON.stringify(empty);
-    }
-    this._clientIds = JSON.parse(saved);
-    return this._clientIds;
-  }
-  async setClientIds(value) {
-    this._clientIds = value;
-    void this.kv.put(this.storageKey, JSON.stringify(value));
-  }
-  async authorizeAccount({
-    urlParams
-  }) {
+  async authorizeAccount({ urlParams }) {
     const params = new URLSearchParams(urlParams);
     const clientId = params.get("clientId");
     if (!clientId)
       throw createInternalError(null, {
         message: "Finbricks: clientId is missing"
       });
-    let savedClientIds = await this.getClientIds();
-    await this.setClientIds({ ...savedClientIds, [this.PROVIDER]: clientId });
     const expired = await this.isClientIdExpired({ clientId });
     if (expired) {
       throw createInternalError(null, {
@@ -308,7 +283,34 @@ class FinbricksConnector extends IBankConnector {
         status: 401
       });
     }
-    return true;
+    const accounts = await this.getAccountsForClient({ clientId });
+    console.log(accounts, "accs finbricks");
+    const credentials = accounts.map((acc) => ({
+      accountId: acc.id,
+      connectorKey: this.PROVIDER,
+      expiresAt: new Date(Date.now() + 36e5),
+      type: "CLIENT_ID",
+      value: clientId
+    }));
+    this.connectedAccounts.push(
+      ...accounts.map((acc) => ({
+        connectorKey: this.PROVIDER,
+        currency: acc.currency,
+        iban: acc.identification.iban,
+        id: acc.id,
+        token: clientId
+      }))
+    );
+    return {
+      credentials,
+      accounts: accounts.map(
+        (account) => mapFinbricksAccountInsert({
+          account,
+          connectorKey: this.PROVIDER,
+          status: "AUTHORIZED"
+        })
+      )
+    };
   }
   async authenticate(code) {
     return "";
@@ -356,13 +358,9 @@ class FinbricksConnector extends IBankConnector {
     const validTo = new Date(record.validTo);
     return validTo.getTime() < Date.now();
   }
-  async listAccounts() {
-    if (!this._clientIds) {
-      throw createInternalError(null, {
-        message: "Finbricks: missing valid clientId",
-        code: "FINBRICKS_CLIENT_ID_MISSING"
-      });
-    }
+  async getAccountsForClient({
+    clientId
+  }) {
     const [response, error] = await useResult(
       this.finbricks.request({
         endpoint: FINBRICKS_ENDPOINTS.ACCOUNT_LIST,
@@ -370,17 +368,40 @@ class FinbricksConnector extends IBankConnector {
         query: {
           merchantId: this.finbricks.MERCHANT_ID,
           paymentProvider: this.PROVIDER,
-          clientId: this._clientIds[this.PROVIDER]
+          clientId
         }
       })
     );
     if (error || !response) {
+      console.log(error, "err");
+      console.log(response, "res");
       throw createInternalError(error, {
         message: "Finbricks: failed to list accounts"
       });
     }
     return response.accounts;
   }
+  async listAccounts() {
+    const accounts = (await Promise.all(
+      this.connectedAccounts.map(
+        (acc) => this.getAccountsForClient({ clientId: acc.token })
+      )
+    )).flat();
+    const uniqueAccounts = Array.from(
+      new Map(accounts.map((acc) => [acc.identification.iban, acc])).values()
+    );
+    return uniqueAccounts.map((acc) => ({
+      connectorKey: this.connectorKey,
+      currency: acc.currency,
+      sync: false,
+      status: "AUTHORIZED",
+      countryCode: acc.servicer.countryCode,
+      bankCode: acc.servicer.bankCode,
+      number: acc.identification.accountNumber,
+      iban: acc.identification.iban,
+      holderName: acc.ownersNames.join(", ")
+    }));
+  }
   async preparePayment(payment) {
     const bankRefId = uuidv4();
     return {
@@ -397,6 +418,13 @@ class FinbricksConnector extends IBankConnector {
     payments
   }) {
     const batchId = uuidv4();
+    const authorizedClient = this.connectedAccounts.find(
+      (acc) => acc.iban === payments[0].debtorIban
+    );
+    if (!authorizedClient)
+      throw createInternalError(null, {
+        message: `Batch for unauthorized client with iban: ${payments[0].debtorIban}`
+      });
     const [response, error] = await useResult(
       this.finbricks.request({
         endpoint: FINBRICKS_ENDPOINTS.TRANSACTION_BATCH_INIT,
@@ -405,7 +433,7 @@ class FinbricksConnector extends IBankConnector {
           batchPaymentIdentification: {
             merchantId: this.finbricks.MERCHANT_ID,
             debtorAccountIban: payments[0].debtorIban,
-            clientId: this._clientIds[this.PROVIDER],
+            clientId: authorizedClient.token,
             callbackUrl: "https://example.com/callback",
             merchantBatchId: batchId
           },
@@ -428,6 +456,47 @@ class FinbricksConnector extends IBankConnector {
       payments: payments.map((p) => ({ ...p, status: "INITIALIZED" }))
     };
   }
+  async initiateSEPAPayment(payment) {
+    const [response, error] = await useResult(
+      this.finbricks.request({
+        endpoint: FINBRICKS_ENDPOINTS.TRANSACTION_SEPA_INIT,
+        method: "POST",
+        body: {
+          merchantIdentification: {
+            merchantId: this.finbricks.MERCHANT_ID,
+            clientId: this.connectedAccounts.find(
+              (acc) => acc.iban === payment.debtorIban
+            ).token
+          },
+          paymentIdentification: {
+            merchantTransactionId: payment.bankRefId
+          },
+          amount: payment.amount,
+          debtor: {
+            debtorAccountIban: payment.debtorIban,
+            debtorName: payment.debtorHolderName || "Devizov\xE1 burza",
+            paymentProvider: this.PROVIDER
+          },
+          creditor: {
+            creditorAccountIban: payment.creditorIban,
+            creditorName: payment.creditorHolderName
+          },
+          callbackUrl: "https://www.example.com"
+        }
+      })
+    );
+    if (error || !response) {
+      console.log(error, "err");
+      console.log(response, "res");
+      throw createInternalError(error, {
+        message: "Finbricks: failed to initiate SEPA payment"
+      });
+    }
+    return {
+      authorizationUrl: response.redirectUrl,
+      payment: { ...payment, status: "INITIALIZED" }
+    };
+  }
   async initiateSinglePayment(payment) {
     const [response, error] = await useResult(
       this.finbricks.request({
@@ -440,14 +509,16 @@ class FinbricksConnector extends IBankConnector {
           debtorAccountIban: payment.debtorIban,
           creditorAccountIban: payment.creditorIban,
           creditorName: payment.creditorHolderName,
-          description: payment.message || "",
-          variableSymbol: payment.vs || "",
+          description: payment.message,
+          variableSymbol: payment.vs,
           callbackUrl: "https://example.com/callback",
           paymentProvider: this.PROVIDER
         }
       })
     );
     if (error || !response) {
+      console.log(error, "err");
+      console.log(response, "res");
       throw createInternalError(error, {
         message: "Finbricks: failed to initiate payment"
       });
@@ -473,11 +544,11 @@ class FinbricksConnector extends IBankConnector {
           endpoint: FINBRICKS_ENDPOINTS.ACCOUNT_TRANSACTIONS,
           query: {
             merchantId: this.finbricks.MERCHANT_ID,
-            // TODO: Desperate times require desperate solution. Don't forget to remove this.
-            clientId: "d32a83cf-d352-41f3-96d7-4d2961336ddc",
-            // clientId: this._clientIds[this.PROVIDER],
+            clientId: this.connectedAccounts.find(
+              (acc) => acc.iban === account.iban
+            ).token,
             paymentProvider: this.PROVIDER,
-            bankAccountId: account.identification.number,
+            bankAccountId: account.id,
             dateFrom,
             dateTo,
             currency: account.currency,
@@ -564,17 +635,17 @@ class ErsteConnector extends IBankConnector {
     this.AUTH_URI = config.AUTH_URI;
     this.PAYMENTS_URI = config.PAYMENTS_URI;
     this.ACCOUNTS_URI = config.ACCOUNTS_URI;
-    this.kv = config.KV;
+    this.connectedAccounts = config.connectedAccounts;
+  }
+  initiateSEPAPayment(payment) {
+    throw new Error("Method not implemented.");
   }
   static {
     this.FETCH_INTERVAL = 60 * 60 * 5;
   }
-  async getAuthUri({
-    accountId,
-    ott
-  }) {
+  async getAuthUri({ ott }) {
     const params = new URLSearchParams({
-      redirect_uri: `${this.REDIRECT_URI}?accountId=${accountId}&ott=${ott}`,
+      redirect_uri: `${this.REDIRECT_URI}?&ott=${ott}`,
       client_id: this.CLIENT_ID,
       response_type: "code",
       access_type: "offline",
@@ -583,17 +654,25 @@ class ErsteConnector extends IBankConnector {
     });
     return `${this.AUTH_URI}/auth?${params.toString()}`;
   }
-  async authorizeAccount({
-    urlParams
-  }) {
+  async authorizeAccount({ urlParams }) {
     const params = new URLSearchParams(urlParams);
     const code = params.get("code");
     if (!code)
       throw createInternalError(null, {
         message: "Missing code in params"
       });
-    await this.kv.put(`${this.connectorKey}:auth`, code);
-    return true;
+    return {
+      accounts: [],
+      credentials: [
+        {
+          accountId: "",
+          connectorKey: this.connectorKey,
+          type: "AUTH_TOKEN",
+          expiresAt: new Date(Date.now() + 1e3 * 60 * 60 * 24 * 30),
+          value: code
+        }
+      ]
+    };
   }
   async authenticate(tokens) {
     const grantType = tokens?.refreshToken ? "refresh_token" : "authorization_code";
@@ -602,11 +681,10 @@ class ErsteConnector extends IBankConnector {
       client_secret: this.CLIENT_SECRET,
       grant_type: grantType
     };
-    const token = await this.kv.get(`${this.connectorKey}:auth`);
-    if (token) {
+    if (tokens?.token) {
       bodyParams = {
         ...bodyParams,
-        code: token,
+        code: tokens.token,
         redirect_uri: this.REDIRECT_URI
       };
     }
@@ -787,6 +865,7 @@ class ErsteConnector extends IBankConnector {
       const symbols = mapReferencesToPayment(reference);
       const paymentInsert = {
         id: uuidv4(),
+        connectorKey: "ERSTE",
         bankRefId: payment.entryReference,
         amount: payment.amount.value,
         currency: payment.amount.currency.code,
@@ -807,10 +886,7 @@ class ErsteConnector extends IBankConnector {
       };
       return {
         ...paymentInsert,
-        direction: getPaymentDirection(
-          paymentInsert,
-          account.identification.iban
-        )
+        direction: getPaymentDirection(paymentInsert, account.iban)
       };
     });
     return payments;
@@ -824,10 +900,13 @@ class ErsteConnector extends IBankConnector {
 }
 
 class MockConnector extends IBankConnector {
-  constructor(kv) {
+  constructor() {
     super();
     this.connectorKey = "MOCK";
-    this.kv = kv;
+    this.connectedAccounts = [];
+  }
+  initiateSEPAPayment(payment) {
+    throw new Error("Method not implemented.");
   }
   static {
     this.FETCH_INTERVAL = 60 * 60 * 5;
@@ -839,13 +918,15 @@ class MockConnector extends IBankConnector {
     return [];
   }
   async getAuthUri({
-    accountId,
-    ott
+    accountId
   }) {
     return `<base-uri>/auth?ott=ott&accountId=${accountId}`;
   }
-  async authorizeAccount() {
-    return true;
+  async authorizeAccount({}) {
+    return {
+      credentials: [],
+      accounts: []
+    };
   }
   async preparePayment(payment) {
     const bankRefId = uuidv4();
@@ -902,11 +983,27 @@ class MockConnector extends IBankConnector {
   }
 }
 
-class MockCobsConnector extends FinbricksConnector {
-  constructor(config) {
-    super("MOCK_COBS", config);
-  }
-}
+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",
+  "PROCESSING",
+  "READY_TO_SIGN",
+  "WAITING_FOR_PROCESSING",
+  "PREPARED",
+  "COMPLETED",
+  "FAILED"
+];
+const ACCOUNT_STATUSES = ["AUTHORIZED", "DISABLED", "EXPIRED"];
+const COUNTRY_CODES = COUNTRY_CODES_2;
 
 const paymentInsertTypeZod = z.object({
   refId: z.string(),
@@ -929,4 +1026,130 @@ const paymentInsertTypeZod = z.object({
   debtorHolderName: z.string().nullable()
 });
 
-export { BATCH_STATUSES as B, COUNTRY_CODES as C, ErsteConnector as E, FinbricksConnector as F, IBankConnector as I, MockConnector as M, PAYMENT_TYPES as P, MockCobsConnector as a, FinbricksClient as b, FINBRICKS_ENDPOINTS as c, PAYMENT_STATUSES as d, PAYMENT_DIRECTIONS as e, getPaymentDirection as g, paymentInsertTypeZod as p, signFinbricksJws as s, tables as t, useFinbricksFetch as u };
+const CONNECTOR_KEYS = [
+  "ERSTE",
+  "FINBRICKS",
+  "MOCK",
+  "CREDITAS",
+  "MOCK_COBS",
+  "FIO",
+  "MONETA"
+];
+const CREDENTIALS_TYPES = [
+  "AUTH_TOKEN",
+  "REFRESH_TOKEN",
+  "CLIENT_ID",
+  "API_KEY"
+];
+const TOKEN_TYPES = ["ACCOUNT_AUTHORIZATION"];
+
+const account = sqliteTable(
+  "account",
+  {
+    ...base,
+    ...bankAccount,
+    connectorKey: text("connector_key", {
+      enum: CONNECTOR_KEYS
+    }).$type().notNull(),
+    status: text("status", { enum: ACCOUNT_STATUSES }).$type().notNull(),
+    sync: integer("sync", { mode: "boolean" }).default(false).notNull(),
+    syncPeriod: integer("sync_period"),
+    lastSyncedAt: integer("last_synced_at", { mode: "timestamp_ms" })
+  },
+  (t) => [unique().on(t.iban)]
+);
+
+const accountInsertSchema = createInsertSchema(account);
+const accountUpdateSchema = createUpdateSchema(account);
+const accountSelectSchema = createSelectSchema(account);
+
+const accountCredentials = sqliteTable("account_credentials", {
+  ...base,
+  accountId: text("account_id").references(() => account.id).notNull(),
+  connectorKey: text("connector_key", {
+    enum: CONNECTOR_KEYS
+  }).$type().notNull(),
+  type: text("type", {
+    enum: CREDENTIALS_TYPES
+  }).$type().notNull(),
+  value: text("value").notNull(),
+  expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull()
+});
+
+const accountCredentialsInsertSchema = createInsertSchema(accountCredentials);
+const accountCredentialsUpdateSchema = createUpdateSchema(accountCredentials);
+const accountCredentialsSelectSchema = createSelectSchema(accountCredentials);
+
+const ott = sqliteTable("ott", {
+  ...base,
+  oneTimeToken: text("one_time_token").notNull(),
+  refId: text("ref_id").notNull(),
+  tokenType: text("token_type", { enum: TOKEN_TYPES }).$type().notNull(),
+  expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull()
+});
+
+const ottInsertSchema = createInsertSchema(ott);
+const ottUpdateSchema = createUpdateSchema(ott);
+const ottSelectSchema = createSelectSchema(ott);
+
+const batch = sqliteTable("batch", {
+  ...base,
+  batchPaymentInitiatedAt: integer("batch_payment_initiated_at", {
+    mode: "timestamp_ms"
+  }),
+  authorizationUrls: text("authorization_urls", { mode: "json" }).$type(),
+  accountId: text("account_id"),
+  status: text("status", { enum: BATCH_STATUSES }).$type(),
+  payments: text("payments", { mode: "json" }).$type().notNull(),
+  metadata: text("metadata", { mode: "json" }).$type()
+});
+
+const payment = sqliteTable("payment", {
+  ...base,
+  refId: text("ref_id"),
+  bankRefId: text("bank_ref_id"),
+  accountId: text("account_id").references(() => account.id).notNull(),
+  connectorKey: text("connector_key", { enum: CONNECTOR_KEYS }).$type().notNull(),
+  amount: real("amount").notNull(),
+  direction: text("direction").$type().notNull(),
+  paymentType: text("payment_type").$type(),
+  currency: text("currency").$type().notNull(),
+  status: text("status").$type().notNull(),
+  statusReason: text("status_reason"),
+  batchId: text("bank_execution_batch_id"),
+  initiatedAt: integer("initiated_at", {
+    mode: "timestamp_ms"
+  }),
+  vs: text("vs"),
+  ss: text("ss"),
+  ks: text("ks"),
+  message: text("message"),
+  processedAt: integer("processed_at", {
+    mode: "timestamp_ms"
+  }),
+  creditorHolderName: text("creditor_holder_name").notNull(),
+  creditorAccountNumberWithBankCode: text(
+    "creditor_account_number_with_bank_code"
+  ),
+  creditorIban: text("creditor_iban"),
+  debtorIban: text("debtor_iban"),
+  debtorHolderName: text("debtor_holder_name"),
+  debtorAccountNumberWithBankCode: text("debtor_account_number_with_bank_code")
+});
+const paymentRelations = relations(payment, ({ one }) => ({
+  batch: one(batch, { fields: [payment.batchId], references: [batch.id] })
+}));
+
+const schema = {
+  __proto__: null,
+  account: account,
+  accountCredentials: accountCredentials,
+  batch: batch,
+  ott: ott,
+  payment: payment,
+  paymentRelations: paymentRelations
+};
+
+const tables = schema;
+
+export { ACCOUNT_STATUSES as A, BATCH_STATUSES as B, COUNTRY_CODES as C, ErsteConnector as E, FinbricksConnector as F, IBankConnector as I, MockConnector as M, PAYMENT_TYPES as P, TOKEN_TYPES as T, FinbricksClient as a, FINBRICKS_ENDPOINTS as b, PAYMENT_STATUSES as c, PAYMENT_DIRECTIONS as d, CONNECTOR_KEYS as e, CREDENTIALS_TYPES as f, accountInsertSchema as g, accountUpdateSchema as h, accountSelectSchema as i, accountCredentialsInsertSchema as j, accountCredentialsUpdateSchema as k, accountCredentialsSelectSchema as l, ottUpdateSchema as m, ottSelectSchema as n, ottInsertSchema as o, paymentInsertTypeZod as p, getPaymentDirection as q, batch as r, signFinbricksJws as s, tables as t, useFinbricksFetch as u, payment as v, paymentRelations as w, ott as x, account as y, accountCredentials as z };