@develit-services/bank 0.0.28 → 0.0.30

package/dist/shared/{bank.Cy_TcyKb.cjs → bank.BMRBXGF1.cjs}

@@ -1,36 +1,15 @@
 'use strict';
 
 const backendSdk = require('@develit-io/backend-sdk');
-const database_schema = require('./bank.P9gDUycr.cjs');
 const drizzleOrm = require('drizzle-orm');
-const zod = require('zod');
 const generalCodes = require('@develit-io/general-codes');
+const zod = require('zod');
 const jose = require('jose');
-require('superjson');
+const drizzleZod = require('drizzle-zod');
+const sqliteCore = require('drizzle-orm/sqlite-core');
 const dateFns = require('date-fns');
-
-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;
+const relations = require('drizzle-orm/relations');
+require('superjson');
 
 class IBankConnector {
 }
@@ -130,6 +109,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"
 };
@@ -203,6 +183,7 @@ const mapFinbricksTransactionToPayment = (tx, account) => {
   const related = tx.entryDetails?.transactionDetails?.relatedParties;
   const base = {
     id: backendSdk.uuidv4(),
+    connectorKey: account.connectorKey,
     bankRefId: tx.entryReference || tx.fbxReference,
     amount: tx.amount?.value || 0,
     currency: tx.amount?.currency || "CZK",
@@ -215,49 +196,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 = backendSdk.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 backendSdk.useResult(
       this.finbricks.request({
@@ -273,35 +270,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(database_schema.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 backendSdk.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 backendSdk.createInternalError(null, {
@@ -310,7 +285,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 "";
@@ -358,13 +360,9 @@ class FinbricksConnector extends IBankConnector {
     const validTo = new Date(record.validTo);
     return validTo.getTime() < Date.now();
   }
-  async listAccounts() {
-    if (!this._clientIds) {
-      throw backendSdk.createInternalError(null, {
-        message: "Finbricks: missing valid clientId",
-        code: "FINBRICKS_CLIENT_ID_MISSING"
-      });
-    }
+  async getAccountsForClient({
+    clientId
+  }) {
     const [response, error] = await backendSdk.useResult(
       this.finbricks.request({
         endpoint: FINBRICKS_ENDPOINTS.ACCOUNT_LIST,
@@ -372,17 +370,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 backendSdk.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 = backendSdk.uuidv4();
     return {
@@ -399,6 +420,13 @@ class FinbricksConnector extends IBankConnector {
     payments
   }) {
     const batchId = backendSdk.uuidv4();
+    const authorizedClient = this.connectedAccounts.find(
+      (acc) => acc.iban === payments[0].debtorIban
+    );
+    if (!authorizedClient)
+      throw backendSdk.createInternalError(null, {
+        message: `Batch for unauthorized client with iban: ${payments[0].debtorIban}`
+      });
     const [response, error] = await backendSdk.useResult(
       this.finbricks.request({
         endpoint: FINBRICKS_ENDPOINTS.TRANSACTION_BATCH_INIT,
@@ -407,7 +435,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
           },
@@ -430,6 +458,47 @@ class FinbricksConnector extends IBankConnector {
       payments: payments.map((p) => ({ ...p, status: "INITIALIZED" }))
     };
   }
+  async initiateSEPAPayment(payment) {
+    const [response, error] = await backendSdk.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 backendSdk.createInternalError(error, {
+        message: "Finbricks: failed to initiate SEPA payment"
+      });
+    }
+    return {
+      authorizationUrl: response.redirectUrl,
+      payment: { ...payment, status: "INITIALIZED" }
+    };
+  }
   async initiateSinglePayment(payment) {
     const [response, error] = await backendSdk.useResult(
       this.finbricks.request({
@@ -442,14 +511,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 backendSdk.createInternalError(error, {
         message: "Finbricks: failed to initiate payment"
       });
@@ -475,11 +546,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,
@@ -566,17 +637,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",
@@ -585,17 +656,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 backendSdk.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";
@@ -604,11 +683,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
       };
     }
@@ -789,6 +867,7 @@ class ErsteConnector extends IBankConnector {
       const symbols = mapReferencesToPayment(reference);
       const paymentInsert = {
         id: backendSdk.uuidv4(),
+        connectorKey: "ERSTE",
         bankRefId: payment.entryReference,
         amount: payment.amount.value,
         currency: payment.amount.currency.code,
@@ -809,10 +888,7 @@ class ErsteConnector extends IBankConnector {
       };
       return {
         ...paymentInsert,
-        direction: getPaymentDirection(
-          paymentInsert,
-          account.identification.iban
-        )
+        direction: getPaymentDirection(paymentInsert, account.iban)
       };
     });
     return payments;
@@ -826,10 +902,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;
@@ -841,13 +920,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 = backendSdk.uuidv4();
@@ -904,11 +985,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 = generalCodes.COUNTRY_CODES_2;
 
 const paymentInsertTypeZod = zod.z.object({
   refId: zod.z.string(),
@@ -931,20 +1028,164 @@ const paymentInsertTypeZod = zod.z.object({
   debtorHolderName: zod.z.string().nullable()
 });
 
+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 = sqliteCore.sqliteTable(
+  "account",
+  {
+    ...backendSdk.base,
+    ...backendSdk.bankAccount,
+    connectorKey: sqliteCore.text("connector_key", {
+      enum: CONNECTOR_KEYS
+    }).$type().notNull(),
+    status: sqliteCore.text("status", { enum: ACCOUNT_STATUSES }).$type().notNull(),
+    sync: sqliteCore.integer("sync", { mode: "boolean" }).default(false).notNull(),
+    syncPeriod: sqliteCore.integer("sync_period"),
+    lastSyncedAt: sqliteCore.integer("last_synced_at", { mode: "timestamp_ms" })
+  },
+  (t) => [sqliteCore.unique().on(t.iban)]
+);
+
+const accountInsertSchema = drizzleZod.createInsertSchema(account);
+const accountUpdateSchema = drizzleZod.createUpdateSchema(account);
+const accountSelectSchema = drizzleZod.createSelectSchema(account);
+
+const accountCredentials = sqliteCore.sqliteTable("account_credentials", {
+  ...backendSdk.base,
+  accountId: sqliteCore.text("account_id").references(() => account.id).notNull(),
+  connectorKey: sqliteCore.text("connector_key", {
+    enum: CONNECTOR_KEYS
+  }).$type().notNull(),
+  type: sqliteCore.text("type", {
+    enum: CREDENTIALS_TYPES
+  }).$type().notNull(),
+  value: sqliteCore.text("value").notNull(),
+  expiresAt: sqliteCore.integer("expires_at", { mode: "timestamp_ms" }).notNull()
+});
+
+const accountCredentialsInsertSchema = drizzleZod.createInsertSchema(accountCredentials);
+const accountCredentialsUpdateSchema = drizzleZod.createUpdateSchema(accountCredentials);
+const accountCredentialsSelectSchema = drizzleZod.createSelectSchema(accountCredentials);
+
+const ott = sqliteCore.sqliteTable("ott", {
+  ...backendSdk.base,
+  oneTimeToken: sqliteCore.text("one_time_token").notNull(),
+  refId: sqliteCore.text("ref_id").notNull(),
+  tokenType: sqliteCore.text("token_type", { enum: TOKEN_TYPES }).$type().notNull(),
+  expiresAt: sqliteCore.integer("expires_at", { mode: "timestamp_ms" }).notNull()
+});
+
+const ottInsertSchema = drizzleZod.createInsertSchema(ott);
+const ottUpdateSchema = drizzleZod.createUpdateSchema(ott);
+const ottSelectSchema = drizzleZod.createSelectSchema(ott);
+
+const batch = sqliteCore.sqliteTable("batch", {
+  ...backendSdk.base,
+  batchPaymentInitiatedAt: sqliteCore.integer("batch_payment_initiated_at", {
+    mode: "timestamp_ms"
+  }),
+  authorizationUrls: sqliteCore.text("authorization_urls", { mode: "json" }).$type(),
+  accountId: sqliteCore.text("account_id"),
+  status: sqliteCore.text("status", { enum: BATCH_STATUSES }).$type(),
+  payments: sqliteCore.text("payments", { mode: "json" }).$type().notNull(),
+  metadata: sqliteCore.text("metadata", { mode: "json" }).$type()
+});
+
+const payment = sqliteCore.sqliteTable("payment", {
+  ...backendSdk.base,
+  refId: sqliteCore.text("ref_id"),
+  bankRefId: sqliteCore.text("bank_ref_id"),
+  accountId: sqliteCore.text("account_id").references(() => account.id).notNull(),
+  connectorKey: sqliteCore.text("connector_key", { enum: CONNECTOR_KEYS }).$type().notNull(),
+  amount: sqliteCore.real("amount").notNull(),
+  direction: sqliteCore.text("direction").$type().notNull(),
+  paymentType: sqliteCore.text("payment_type").$type(),
+  currency: sqliteCore.text("currency").$type().notNull(),
+  status: sqliteCore.text("status").$type().notNull(),
+  statusReason: sqliteCore.text("status_reason"),
+  batchId: sqliteCore.text("bank_execution_batch_id"),
+  initiatedAt: sqliteCore.integer("initiated_at", {
+    mode: "timestamp_ms"
+  }),
+  vs: sqliteCore.text("vs"),
+  ss: sqliteCore.text("ss"),
+  ks: sqliteCore.text("ks"),
+  message: sqliteCore.text("message"),
+  processedAt: sqliteCore.integer("processed_at", {
+    mode: "timestamp_ms"
+  }),
+  creditorHolderName: sqliteCore.text("creditor_holder_name").notNull(),
+  creditorAccountNumberWithBankCode: sqliteCore.text(
+    "creditor_account_number_with_bank_code"
+  ),
+  creditorIban: sqliteCore.text("creditor_iban"),
+  debtorIban: sqliteCore.text("debtor_iban"),
+  debtorHolderName: sqliteCore.text("debtor_holder_name"),
+  debtorAccountNumberWithBankCode: sqliteCore.text("debtor_account_number_with_bank_code")
+});
+const paymentRelations = relations.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;
+
+exports.ACCOUNT_STATUSES = ACCOUNT_STATUSES;
 exports.BATCH_STATUSES = BATCH_STATUSES;
+exports.CONNECTOR_KEYS = CONNECTOR_KEYS;
 exports.COUNTRY_CODES = COUNTRY_CODES;
+exports.CREDENTIALS_TYPES = CREDENTIALS_TYPES;
 exports.ErsteConnector = ErsteConnector;
 exports.FINBRICKS_ENDPOINTS = FINBRICKS_ENDPOINTS;
 exports.FinbricksClient = FinbricksClient;
 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.TOKEN_TYPES = TOKEN_TYPES;
+exports.account = account;
+exports.accountCredentials = accountCredentials;
+exports.accountCredentialsInsertSchema = accountCredentialsInsertSchema;
+exports.accountCredentialsSelectSchema = accountCredentialsSelectSchema;
+exports.accountCredentialsUpdateSchema = accountCredentialsUpdateSchema;
+exports.accountInsertSchema = accountInsertSchema;
+exports.accountSelectSchema = accountSelectSchema;
+exports.accountUpdateSchema = accountUpdateSchema;
+exports.batch = batch;
 exports.getPaymentDirection = getPaymentDirection;
+exports.ott = ott;
+exports.ottInsertSchema = ottInsertSchema;
+exports.ottSelectSchema = ottSelectSchema;
+exports.ottUpdateSchema = ottUpdateSchema;
+exports.payment = payment;
 exports.paymentInsertTypeZod = paymentInsertTypeZod;
+exports.paymentRelations = paymentRelations;
 exports.signFinbricksJws = signFinbricksJws;
 exports.tables = tables;
 exports.useFinbricksFetch = useFinbricksFetch;