@develit-services/bank 0.8.8 → 0.8.10

package/dist/export/worker.mjs

@@ -1,16 +1,16 @@
 import { uuidv4, first, buildMultiFilterConditions as buildMultiFilterConditions$1, bankAccountMetadataSchema, workflowInstanceStatusSchema, develitWorker, createInternalError, action, service } from '@develit-io/backend-sdk';
-import { t as tables, h as encrypt, d as createCredentialsResolver, u as upsertBatchCommand, a as getPaymentRequestsByBatchIdQuery, e as updatePaymentRequestStatusCommand, g as getBatchByIdQuery, i as importAesKey, f as createPaymentCommand, b as getAccountByIdQuery } from '../shared/bank.B5bZRvgq.mjs';
+import { t as tables, h as encrypt, d as createCredentialsResolver, e as updatePaymentRequestStatusCommand, a as getPaymentRequestsByBatchIdQuery, g as getBatchByIdQuery, u as upsertBatchCommand, i as importAesKey, f as createPaymentCommand, b as getAccountByIdQuery } from '../shared/bank.xB9eTN77.mjs';
+import { eq, sql, and, like, asc, desc, inArray, gte, lte, isNull, count, not } from 'drizzle-orm';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { drizzle } from 'drizzle-orm/d1';
-import { j as initiateConnector, m as mapFinbricksTransactionStatus, g as toIncomingPayment, d as assignAccount, t as toBatchedPayment, a as FinbricksClient, F as FINBRICKS_ENDPOINTS, h as toPaymentRequestInsert } from '../shared/bank.BtszLapg.mjs';
+import { j as initiateConnector, g as toIncomingPayment, d as assignAccount, t as toBatchedPayment, h as toPaymentRequestInsert, a as FinbricksClient, F as FINBRICKS_ENDPOINTS } from '../shared/bank.D-O_gmmZ.mjs';
 import 'jose';
 import { z } from 'zod';
-import { I as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, e as PAYMENT_TYPES, a as CONNECTOR_KEYS, B as BATCH_STATUSES, d as PAYMENT_STATUSES, P as PAYMENT_DIRECTIONS, i as accountInsertSchema } from '../shared/bank.C6jjS1Pl.mjs';
+import { I as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, g as PAYMENT_TYPES, b as CONNECTOR_KEYS, a as BATCH_STATUSES, f as PAYMENT_STATUSES, P as PAYMENT_DIRECTIONS, k as accountInsertSchema, e as PAYMENT_REQUEST_STATUSES } from '../shared/bank.CXBeULUL.mjs';
 import { CURRENCY_CODES } from '@develit-io/general-codes';
 import 'date-fns';
-import { eq, sql, and, inArray, like, asc, desc, gte, lte, isNull, count } from 'drizzle-orm';
 import 'node:crypto';
-import '../shared/bank.BoZtXQpG.mjs';
+import '../shared/bank.CR0UlyRi.mjs';
 import 'drizzle-orm/relations';
 import 'drizzle-orm/sqlite-core';
 import 'drizzle-zod';
@@ -105,8 +105,8 @@ const createPaymentRequestCommand = (db, { paymentRequest }) => {
 const getAccountBatchCountsQuery = async (db, { accountId }) => {
   const result = await db.select({
     totalCount: sql`COUNT(*)`.as("totalCount"),
-    openCount: sql`SUM(CASE WHEN ${tables.batch.status} = 'OPEN' THEN 1 ELSE 0 END)`.as(
-      "openCount"
+    processingCount: sql`SUM(CASE WHEN ${tables.batch.status} = 'PROCESSING' THEN 1 ELSE 0 END)`.as(
+      "processingCount"
     ),
     readyToSignCount: sql`SUM(CASE WHEN ${tables.batch.status} = 'READY_TO_SIGN' THEN 1 ELSE 0 END)`.as(
       "readyToSignCount"
@@ -117,7 +117,7 @@ const getAccountBatchCountsQuery = async (db, { accountId }) => {
   }).from(tables.batch).where(eq(tables.batch.accountId, accountId)).then(first);
   return result || {
     totalCount: 0,
-    openCount: 0,
+    processingCount: 0,
     readyToSignCount: 0,
     failedCount: 0
   };
@@ -160,10 +160,6 @@ const getAllAccountsQuery = async (db, filters) => {
   };
 };
 
-const getAllPendingBatchesQuery = (db) => {
-  return db.select().from(tables.batch).where(inArray(tables.batch.status, ["READY_TO_SIGN", "SIGNED"]));
-};
-
 const buildMultiFilterConditions = (column, value) => {
   if (value === void 0) return void 0;
   if (Array.isArray(value)) {
@@ -263,6 +259,7 @@ const getBatchesQuery = async (db, {
   filterBatchStatus
 }) => {
   const whereConditions = and(
+    isNull(tables.batch.deletedAt),
     buildMultiFilterConditions(tables.batch.accountId, filterBatchAccountId),
     buildMultiFilterConditions(tables.batch.status, filterBatchStatus)
   );
@@ -272,7 +269,12 @@ const getBatchesQuery = async (db, {
   }).from(tables.batch).where(whereConditions);
   const batches = await db.select().from(tables.batch).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? asc(sortColumn) : desc(sortColumn));
   const batchIds = batches.map((b) => b.id);
-  const paymentRequests = batchIds.length > 0 ? await db.select().from(tables.paymentRequest).where(inArray(tables.paymentRequest.batchId, batchIds)) : [];
+  const paymentRequests = batchIds.length > 0 ? await db.select().from(tables.paymentRequest).where(
+    and(
+      inArray(tables.paymentRequest.batchId, batchIds),
+      isNull(tables.paymentRequest.deletedAt)
+    )
+  ) : [];
   const paymentRequestsByBatchId = Map.groupBy(
     paymentRequests,
     (pr) => pr.batchId
@@ -287,17 +289,6 @@ const getBatchesQuery = async (db, {
   };
 };
 
-const getAccountAccumulatingBatchesQuery = async (db, { accountId, paymentType }) => {
-  return await db.select().from(tables.batch).where(
-    and(
-      eq(tables.batch.accountId, accountId),
-      eq(tables.batch.status, "OPEN"),
-      isNull(tables.batch.batchPaymentInitiatedAt),
-      paymentType ? eq(tables.batch.paymentType, paymentType) : void 0
-    )
-  );
-};
-
 const getOttQuery = async (db, { ott }) => {
   return await db.select().from(tables.ott).where(eq(tables.ott.oneTimeToken, ott)).get();
 };
@@ -344,15 +335,15 @@ const getPaymentRequestsQuery = async (db, params) => {
   return { paymentRequests, totalCount };
 };
 
-const NON_BATCH_CONNECTOR_KEYS = ["DBU", "CREDITAS"];
-const getPendingNonBatchPaymentRequestsQuery = (db) => db.select().from(tables.paymentRequest).where(
+const TERMINAL_STATUSES = [
+  "SETTLED",
+  "REJECTED",
+  "CLOSED"
+];
+const getNonTerminalPaymentRequestsQuery = (db) => db.select().from(tables.paymentRequest).where(
   and(
-    inArray(tables.paymentRequest.status, [
-      "PREPARED",
-      "SIGNED",
-      "PENDING"
-    ]),
-    inArray(tables.paymentRequest.connectorKey, NON_BATCH_CONNECTOR_KEYS)
+    not(inArray(tables.paymentRequest.status, TERMINAL_STATUSES)),
+    isNull(tables.paymentRequest.deletedAt)
   )
 );
 
@@ -373,6 +364,10 @@ const sendPaymentInputSchema = z.object({
   sendAsSinglePayment: z.boolean().optional()
 });
 
+const sendBatchInputSchema = z.object({
+  payments: z.array(sendPaymentInputSchema).min(1)
+});
+
 const getAuthUriInputSchema = z.object({
   connectorKey: z.enum(CONNECTOR_KEYS)
 });
@@ -437,14 +432,6 @@ z.object({
   details: workflowInstanceStatusSchema
 });
 
-const updateBatchStatusesInputSchema = z.object({
-  batchId: z.uuid().optional()
-}).optional();
-z.object({
-  processed: z.number(),
-  statusChanged: z.number()
-});
-
 const ALLOWED_PAYMENT_FILTERS = {
   ACCOUNT_ID: "filterPaymentAccountId",
   AMOUNT: "filterPaymentAmount",
@@ -480,7 +467,7 @@ const getPaymentsInputSchema = z.object({
   [ALLOWED_PAYMENT_FILTERS.FROM]: z.date().optional(),
   [ALLOWED_PAYMENT_FILTERS.TO]: z.date().optional(),
   [ALLOWED_PAYMENT_FILTERS.STATUS]: z.union([z.enum(PAYMENT_STATUSES), z.enum(PAYMENT_STATUSES).array()]).optional(),
-  [ALLOWED_PAYMENT_FILTERS.PAYMENT_TYPE]: z.enum(PAYMENT_TYPES).optional(),
+  [ALLOWED_PAYMENT_FILTERS.PAYMENT_TYPE]: z.union([z.enum(PAYMENT_TYPES), z.enum(PAYMENT_TYPES).array()]).optional(),
   [ALLOWED_PAYMENT_FILTERS.MIN_AMOUNT]: z.number().positive().optional(),
   [ALLOWED_PAYMENT_FILTERS.MAX_AMOUNT]: z.number().positive().optional(),
   [ALLOWED_PAYMENT_FILTERS.VARIABLE_SYMBOL]: z.string().regex(/^\d{1,10}$/).optional(),
@@ -533,6 +520,7 @@ const getBankAccountsInputSchema = z.object({
   limit: z.number().positive().optional(),
   includeWorkflow: z.boolean().optional(),
   includeBatchCounts: z.boolean().optional(),
+  includePendingPaymentRequestCount: z.boolean().optional(),
   filterIbans: z.array(z.string()).optional(),
   filterCurrencies: z.array(z.string()).optional(),
   filterBankRefIds: z.array(z.string()).optional()
@@ -543,14 +531,9 @@ const disconnectAccountInputSchema = z.object({
 });
 
 const handleAuthorizationCallbackInputSchema = z.object({
-  paymentId: z.string().uuid().optional(),
-  batchId: z.string().uuid().optional()
-}).refine((data) => data.paymentId || data.batchId, {
-  message: "Either paymentId or batchId is required"
+  callbackUrl: z.string().url()
 });
 
-const sendPaymentSyncInputSchema = sendPaymentInputSchema;
-
 const getPaymentRequestsInputSchema = z.object({
   page: z.number().positive(),
   limit: z.number().positive(),
@@ -559,7 +542,10 @@ const getPaymentRequestsInputSchema = z.object({
     direction: z.enum(["asc", "desc"])
   }),
   filterAccountId: z.union([z.uuid(), z.uuid().array()]).optional(),
-  filterStatus: z.union([z.enum(PAYMENT_STATUSES), z.enum(PAYMENT_STATUSES).array()]).optional(),
+  filterStatus: z.union([
+    z.enum(PAYMENT_REQUEST_STATUSES),
+    z.enum(PAYMENT_REQUEST_STATUSES).array()
+  ]).optional(),
   filterPaymentType: z.union([z.enum(PAYMENT_TYPES), z.enum(PAYMENT_TYPES).array()]).optional(),
   filterCurrency: z.union([z.enum(CURRENCY_CODES), z.enum(CURRENCY_CODES).array()]).optional(),
   filterMinAmount: z.number().positive().optional(),
@@ -579,11 +565,6 @@ const getPaymentRequestsInputSchema = z.object({
   // filterDirection: removed — payment_request is always OUTGOING
 });
 
-z.object({
-  processed: z.number(),
-  statusChanged: z.number()
-});
-
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -594,11 +575,14 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
-const POLLING_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1e3;
 let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
   constructor(ctx, env, config) {
     super(ctx, env);
     this.allowedProviders = [];
+    // ── Unified status resolution ──────────────────────────────────────
+    this.POLLING_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1e3;
+    // 14 days
+    this.COMPLETED_POLLING_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
     this.allowedProviders = config.allowedProviders;
     this.db = drizzle(this.env.BANK_D1, { schema: tables });
   }
@@ -743,472 +727,222 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       }
     );
   }
-  async scheduled(controller) {
-    if (controller.cron === this.env.CRON_BATCH_STATUSES) {
-      console.log("Scheduled CRON batch statuses");
-      await this.updateBatchStatuses();
-    }
-    if (controller.cron === this.env.CRON_PAYMENT_STATUSES) {
-      console.log("Scheduled CRON payment statuses");
-      await this.updatePaymentStatuses();
-    }
-  }
-  async _resolveSingleBatch(batch, connector) {
-    const previousStatus = batch.status;
-    const { status: currentStatus, apiResponse } = await connector.getBatchStatus({
-      batchId: batch.id
-    });
-    let statusChanged = false;
-    if (previousStatus !== currentStatus || !batch.statusResponse) {
-      await upsertBatchCommand(this.db, {
-        batch: {
-          ...batch,
-          status: currentStatus,
-          statusResponse: apiResponse
-        }
-      }).command.execute();
-      statusChanged = true;
-    }
-    if (statusChanged) {
-      const paymentRequests = await getPaymentRequestsByBatchIdQuery(this.db, {
-        batchId: batch.id
-      });
-      const perPaymentStatuses = "payments" in apiResponse ? apiResponse.payments : null;
-      const batchStatusToPaymentStatus = {
-        SIGNED: "SIGNED",
-        COMPLETED: "COMPLETED",
-        FAILED: "FAILED",
-        SIGNATURE_FAILED: "FAILED"
-      };
-      for (const pr of paymentRequests) {
-        if (pr.status !== "COMPLETED" && pr.status !== "FAILED" && pr.createdAt != null && Date.now() - pr.createdAt.getTime() > POLLING_TIMEOUT_MS) {
-          await updatePaymentRequestStatusCommand(this.db, {
-            id: pr.id,
-            status: "FAILED",
-            statusReason: "Polling timeout: no final status received after 14 days",
-            processedAt: /* @__PURE__ */ new Date()
-          }).command.execute();
-          continue;
-        }
-        let newStatus = pr.status;
-        let match;
-        if (perPaymentStatuses) {
-          match = perPaymentStatuses.find(
-            (p) => p.merchantTransactionId === pr.id
-          );
-          if (match) {
-            newStatus = mapFinbricksTransactionStatus(
-              match.resultCode,
-              match.finalBankStatus ?? false
-            );
-          }
-        } else {
-          newStatus = batchStatusToPaymentStatus[currentStatus] ?? pr.status;
-        }
-        if (newStatus !== pr.status) {
-          await updatePaymentRequestStatusCommand(this.db, {
-            id: pr.id,
-            status: newStatus,
-            ...newStatus === "FAILED" && {
-              statusReason: perPaymentStatuses ? match?.resultCode ?? currentStatus : currentStatus
-            },
-            processedAt: newStatus === "COMPLETED" || newStatus === "FAILED" ? /* @__PURE__ */ new Date() : void 0
-          }).command.execute();
-        }
-      }
-      if (paymentRequests.length > 0) {
-        const freshPRs = await getPaymentRequestsByBatchIdQuery(this.db, {
-          batchId: batch.id
+  // 7 days
+  /**
+   * Core status resolution logic. Polls connector for each PR and updates status.
+   * Called from CRON and from handleAuthorizationCallback.
+   */
+  async _resolvePaymentRequestStatuses(prIds) {
+    if (prIds.length === 0) return { processed: 0, statusChanged: 0 };
+    const allPRs = (await Promise.all(
+      prIds.map(
+        (id) => getPaymentRequestByIdQuery(this.db, { paymentRequestId: id })
+      )
+    )).filter((p) => p !== void 0);
+    const byConnector = Map.groupBy(allPRs, (pr) => pr.connectorKey);
+    let processed = 0;
+    let statusChanged = 0;
+    const eventsToEmit = [];
+    for (const [connectorKey, requests] of byConnector) {
+      let connector;
+      try {
+        connector = await this._initiateBankConnector({ connectorKey });
+      } catch (err) {
+        this.logError({
+          message: `[_resolvePaymentRequestStatuses] Failed to init connector ${connectorKey}: ${err}`
         });
-        const allTerminal = freshPRs.every(
-          (pr) => pr.status === "COMPLETED" || pr.status === "FAILED"
-        );
-        if (allTerminal && currentStatus !== "COMPLETED" && currentStatus !== "FAILED") {
-          const finalBatchStatus = freshPRs.some((pr) => pr.status === "FAILED") ? "FAILED" : "COMPLETED";
-          await upsertBatchCommand(this.db, {
-            batch: { ...batch, status: finalBatchStatus }
-          }).command.execute();
-          console.log(
-            `Batch ${batch.id} auto-closed with status ${finalBatchStatus}`
-          );
-        }
+        continue;
       }
-    }
-    return {
-      batchId: batch.id,
-      previousStatus,
-      currentStatus,
-      statusChanged
-    };
-  }
-  async updateBatchStatuses(input) {
-    return this.handleAction(
-      { data: input, schema: updateBatchStatusesInputSchema },
-      { successMessage: "Batch statuses updated" },
-      async (validatedInput) => {
-        let pendingBatches;
-        if (validatedInput?.batchId) {
-          const batch = await getBatchByIdQuery(this.db, {
-            batchId: validatedInput.batchId
-          });
-          if (!batch) {
-            throw createInternalError(null, {
-              message: `Batch not found: ${validatedInput.batchId}`,
-              code: "DB-B-007",
-              status: 404
-            });
-          }
-          pendingBatches = [batch];
-        } else {
-          pendingBatches = await getAllPendingBatchesQuery(this.db);
-        }
-        const accounts = await this._getConnectedAccounts();
-        console.log(`Processing ${pendingBatches.length} pending batche(s)`);
-        const batchesByConnector = /* @__PURE__ */ new Map();
-        for (const batch of pendingBatches) {
-          const account = accounts.find((acc) => acc.id === batch.accountId);
-          if (!account) {
-            this.logError({
-              message: `Account not found for batch ${batch.id}, skipping`
-            });
-            const prs = await getPaymentRequestsByBatchIdQuery(this.db, {
-              batchId: batch.id
-            });
-            const prCmds = prs.filter((p) => p.status !== "FAILED").map(
-              (p) => updatePaymentRequestStatusCommand(this.db, {
-                id: p.id,
-                status: "FAILED",
-                statusReason: "ACCOUNT_NOT_FOUND",
-                processedAt: /* @__PURE__ */ new Date()
-              }).command
-            );
-            const batchCmd = upsertBatchCommand(this.db, {
-              batch: {
-                ...batch,
-                status: "FAILED",
-                statusReason: "ACCOUNT_NOT_FOUND"
+      for (const pr of requests) {
+        try {
+          const paymentId = pr.bankRefId ?? pr.id;
+          const newStatus = await connector.getPaymentStatus({ paymentId });
+          if (newStatus !== pr.status) {
+            await updatePaymentRequestStatusCommand(this.db, {
+              id: pr.id,
+              status: newStatus,
+              processedAt: newStatus === "COMPLETED" ? /* @__PURE__ */ new Date() : void 0
+            }).command.execute();
+            statusChanged++;
+            eventsToEmit.push({
+              eventType: "BANK_PAYMENT_REQUEST",
+              eventSignal: "paymentRequestStatusChanged",
+              paymentRequest: { ...pr, status: newStatus },
+              metadata: {
+                correlationId: pr.correlationId,
+                entityId: pr.id,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
               }
-            }).command;
-            const allCmds = [batchCmd, ...prCmds];
-            if (allCmds.length > 0) {
-              await this.db.batch(allCmds);
-            }
-            continue;
+            });
           }
-          const batches = batchesByConnector.get(account.connectorKey) || [];
-          batches.push(batch);
-          batchesByConnector.set(account.connectorKey, batches);
-        }
-        const allResults = [];
-        for (const [connectorKey, batches] of batchesByConnector) {
-          console.log(
-            `Initializing ${connectorKey} connector for ${batches.length} batches`
-          );
-          const connector = await this._initiateBankConnector({
-            connectorKey
+          processed++;
+        } catch (err) {
+          this.logError({
+            message: `Failed to resolve status for PR ${pr.id}: ${err}`
           });
-          if (connector.lifecycleMode === "per-payment") {
-            continue;
-          }
-          for (const batch of batches) {
-            const result = await this._resolveSingleBatch(batch, connector);
-            if (result) {
-              allResults.push(result);
-            }
-          }
         }
-        const changedCount = allResults.filter((r) => r.statusChanged).length;
-        console.log(
-          `Batch update completed: ${changedCount} status change(s) detected`
-        );
-        return {
-          processed: allResults.length,
-          statusChanged: changedCount
-        };
       }
+    }
+    if (eventsToEmit.length > 0) {
+      await this.pushToQueue(
+        this.env.QUEUE_BUS_QUEUE,
+        eventsToEmit
+      );
+    }
+    const affectedBatchIds = [
+      ...new Set(
+        allPRs.map((pr) => pr.batchId).filter((id) => id != null)
+      )
+    ];
+    for (const batchId of affectedBatchIds) {
+      await this._deriveBatchStatus(batchId);
+    }
+    return { processed, statusChanged };
+  }
+  /**
+   * Derives batch status from its payment requests.
+   */
+  async _deriveBatchStatus(batchId) {
+    const [allPRs, batch] = await Promise.all([
+      getPaymentRequestsByBatchIdQuery(this.db, { batchId }),
+      getBatchByIdQuery(this.db, { batchId })
+    ]);
+    if (!batch || batch.status === "COMPLETED" || batch.status === "FAILED")
+      return;
+    if (allPRs.length === 0) return;
+    const terminalStatuses = [
+      "SETTLED",
+      "REJECTED",
+      "CLOSED"
+    ];
+    const authorizedOrHigher = [
+      "AUTHORIZED",
+      "COMPLETED",
+      "BOOKED",
+      "SETTLED"
+    ];
+    const allTerminal = allPRs.every(
+      (pr) => terminalStatuses.includes(pr.status)
+    );
+    const allAuthorizedOrHigher = allPRs.every(
+      (pr) => [...authorizedOrHigher, ...terminalStatuses].includes(
+        pr.status
+      )
     );
+    if (allTerminal) {
+      const hasFailed = allPRs.some(
+        (pr) => pr.status === "REJECTED" || pr.status === "CLOSED"
+      );
+      await upsertBatchCommand(this.db, {
+        batch: { ...batch, status: hasFailed ? "FAILED" : "COMPLETED" }
+      }).command.execute();
+    } else if (allAuthorizedOrHigher && batch.status !== "AUTHORIZED") {
+      await upsertBatchCommand(this.db, {
+        batch: { ...batch, status: "AUTHORIZED" }
+      }).command.execute();
+    }
   }
-  async updatePaymentStatuses() {
+  async updatePaymentRequestStatuses() {
     return this.handleAction(
       null,
-      { successMessage: "Payment statuses updated" },
+      { successMessage: "Payment request statuses updated" },
       async () => {
-        const pendingRequests = await getPendingNonBatchPaymentRequestsQuery(
-          this.db
-        );
-        if (pendingRequests.length === 0) {
+        const nonTerminalPRs = await getNonTerminalPaymentRequestsQuery(this.db);
+        if (nonTerminalPRs.length === 0) {
           return { processed: 0, statusChanged: 0 };
         }
-        const requestsByConnector = /* @__PURE__ */ new Map();
-        for (const pr of pendingRequests) {
-          const list = requestsByConnector.get(pr.connectorKey) || [];
-          list.push(pr);
-          requestsByConnector.set(pr.connectorKey, list);
-        }
-        let processed = 0;
-        let statusChanged = 0;
-        for (const [connectorKey, requests] of requestsByConnector) {
-          let connector;
-          try {
-            connector = await this._initiateBankConnector({ connectorKey });
-          } catch (err) {
-            this.logError({
-              message: `[updatePaymentStatuses] Failed to init connector ${connectorKey}: ${err}`
-            });
-            continue;
-          }
-          for (const pr of requests) {
-            try {
-              if (pr.createdAt != null && Date.now() - pr.createdAt.getTime() > POLLING_TIMEOUT_MS) {
-                await updatePaymentRequestStatusCommand(this.db, {
-                  id: pr.id,
-                  status: "FAILED",
-                  statusReason: "Polling timeout: no final status received after 14 days",
-                  processedAt: /* @__PURE__ */ new Date()
-                }).command.execute();
-                statusChanged++;
-                processed++;
-                continue;
-              }
-              const paymentId = pr.bankRefId ?? pr.id;
-              const newStatus = await connector.getPaymentStatus({ paymentId });
-              if (newStatus !== pr.status) {
-                await updatePaymentRequestStatusCommand(this.db, {
-                  id: pr.id,
-                  status: newStatus,
-                  processedAt: newStatus === "COMPLETED" || newStatus === "FAILED" ? /* @__PURE__ */ new Date() : void 0
-                }).command.execute();
-                statusChanged++;
-              }
-              processed++;
-            } catch (err) {
-              this.logError({
-                message: `Failed to get status for payment ${pr.id}: ${err}`
-              });
+        const now = Date.now();
+        const pollableIds = [];
+        for (const pr of nonTerminalPRs) {
+          const status = pr.status;
+          if (status === "OPENED" || status === "AUTHORIZED") {
+            if (pr.createdAt != null && now - pr.createdAt.getTime() > this.POLLING_TIMEOUT_MS) {
+              await updatePaymentRequestStatusCommand(this.db, {
+                id: pr.id,
+                status: "CLOSED",
+                statusReason: "Polling timeout: no final status received after 14 days",
+                processedAt: /* @__PURE__ */ new Date()
+              }).command.execute();
+              continue;
             }
+            pollableIds.push(pr.id);
+          } else if (status === "COMPLETED" || status === "BOOKED") {
+            if (pr.processedAt != null && now - pr.processedAt.getTime() > this.COMPLETED_POLLING_WINDOW_MS) {
+              continue;
+            }
+            pollableIds.push(pr.id);
           }
         }
-        const affectedBatchIds = [
-          ...new Set(
-            pendingRequests.map((pr) => pr.batchId).filter((id) => id != null)
-          )
-        ];
-        for (const batchId of affectedBatchIds) {
-          const [allPRs, batch] = await Promise.all([
-            getPaymentRequestsByBatchIdQuery(this.db, { batchId }),
-            getBatchByIdQuery(this.db, { batchId })
-          ]);
-          if (!batch || batch.status === "COMPLETED" || batch.status === "FAILED")
-            continue;
-          const allTerminal = allPRs.every(
-            (pr) => pr.status === "COMPLETED" || pr.status === "FAILED"
-          );
-          if (allTerminal && allPRs.length > 0) {
-            const finalStatus = allPRs.some((pr) => pr.status === "FAILED") ? "FAILED" : "COMPLETED";
-            await upsertBatchCommand(this.db, {
-              batch: { ...batch, status: finalStatus }
-            }).command.execute();
-          }
-        }
-        return { processed, statusChanged };
+        return this._resolvePaymentRequestStatuses(pollableIds);
       }
     );
   }
+  async scheduled(controller) {
+    if (controller.cron === this.env.CRON_PAYMENT_STATUSES) {
+      console.log("Scheduled CRON payment request statuses");
+      await this.updatePaymentRequestStatuses();
+    }
+  }
   async handleAuthorizationCallback(input) {
     return this.handleAction(
       { data: input, schema: handleAuthorizationCallbackInputSchema },
       { successMessage: "Authorization callback processed" },
-      async ({ paymentId, batchId }) => {
-        let targetBatchId = null;
-        let paymentsUpdated = 0;
-        if (paymentId) {
+      async ({ callbackUrl }) => {
+        const url = new URL(callbackUrl);
+        const params = url.searchParams;
+        const paymentRequestId = params.get("paymentRequestId");
+        const batchId = params.get("batchId");
+        let connectorKey;
+        if (paymentRequestId) {
           const pr = await getPaymentRequestByIdQuery(this.db, {
-            paymentRequestId: paymentId
+            paymentRequestId
           });
-          if (!pr) {
-            throw createInternalError(null, {
-              message: `Payment request not found: ${paymentId}`,
-              code: "DB-B-008",
-              status: 404
-            });
-          }
-          if (pr.status !== "SIGNED" && pr.status !== "COMPLETED") {
-            await updatePaymentRequestStatusCommand(this.db, {
-              id: paymentId,
-              status: "SIGNED"
-            }).command.execute();
-            paymentsUpdated = 1;
-          }
-          targetBatchId = pr.batchId;
-        }
-        if (batchId) {
-          targetBatchId = batchId;
-          const batchPayments = await getPaymentRequestsByBatchIdQuery(
-            this.db,
-            {
-              batchId
-            }
-          );
-          for (const pr of batchPayments) {
-            if (pr.status !== "SIGNED" && pr.status !== "COMPLETED") {
-              await updatePaymentRequestStatusCommand(this.db, {
-                id: pr.id,
-                status: "SIGNED"
-              }).command.execute();
-              paymentsUpdated++;
-            }
-          }
-        }
-        let batchSigned = false;
-        if (targetBatchId) {
-          const allPayments = await getPaymentRequestsByBatchIdQuery(this.db, {
-            batchId: targetBatchId
+          if (pr) connectorKey = pr.connectorKey;
+        } else if (batchId) {
+          const batchPrs = await getPaymentRequestsByBatchIdQuery(this.db, {
+            batchId
           });
-          const allDone = allPayments.every(
-            (p) => p.status === "SIGNED" || p.status === "COMPLETED"
-          );
-          if (allDone) {
-            const batch = await getBatchByIdQuery(this.db, {
-              batchId: targetBatchId
-            });
-            if (batch && batch.status !== "SIGNED") {
-              await upsertBatchCommand(this.db, {
-                batch: { ...batch, status: "SIGNED" }
-              }).command.execute();
-              batchSigned = true;
-            }
-          }
+          if (batchPrs.length > 0) connectorKey = batchPrs[0].connectorKey;
         }
-        return {
-          paymentsUpdated,
-          batchId: targetBatchId,
-          batchSigned
-        };
-      }
-    );
-  }
-  async addPaymentsToBatch({ paymentIds }) {
-    return this.handleAction(null, {}, async () => {
-      this.logInput({ paymentIds });
-      const paymentRequests = (await Promise.all(
-        paymentIds.map(
-          (id) => getPaymentRequestByIdQuery(this.db, { paymentRequestId: id })
-        )
-      )).filter((p) => p !== void 0);
-      const foundIds = new Set(paymentRequests.map((p) => p.id));
-      const missingIds = paymentIds.filter((id) => !foundIds.has(id));
-      if (missingIds.length > 0) {
-        this.logError({ missingIds });
-      }
-      const byAccount = Map.groupBy(
-        paymentRequests,
-        (p) => `${p.accountId}:${p.paymentType}`
-      );
-      const { accounts } = await this._getAccounts();
-      for (const [, paymentsOfType] of byAccount) {
-        const first2 = paymentsOfType[0];
-        const acc = accounts.find((a) => a.id === first2.accountId);
-        if (!acc) {
-          this.logError({ message: `Account not found: ${first2.accountId}` });
-          await Promise.all(
-            paymentsOfType.map(
-              (p) => updatePaymentRequestStatusCommand(this.db, {
-                id: p.id,
-                status: "FAILED",
-                statusReason: "ACCOUNT_NOT_FOUND"
-              }).command.execute()
-            )
-          );
-          continue;
+        if (!connectorKey) {
+          throw createInternalError(null, {
+            message: `Could not resolve connector from callback URL`,
+            code: "DB-B-008",
+            status: 400
+          });
         }
-        const singlePayments = paymentsOfType.filter(
-          (p) => p.sendAsSinglePayment === true
-        );
-        const regularPayments = paymentsOfType.filter(
-          (p) => p.sendAsSinglePayment !== true
-        );
-        this.log({
-          message: `\u{1F4B0} Processing ${paymentsOfType.length} payments for account (${acc.iban}, ${acc.currency})`
+        const connector = await this._initiateBankConnector({
+          connectorKey
         });
-        for (const singlePayment of singlePayments) {
-          const batchId = uuidv4();
-          const { command: upsertBatch } = upsertBatchCommand(this.db, {
-            batch: {
-              id: batchId,
-              authorizationUrls: [],
-              accountId: acc.id,
-              paymentType: singlePayment.paymentType,
-              status: "OPEN",
-              metadata: { sizeLimit: 1 }
-            }
-          });
-          const { command: updateRequest } = updatePaymentRequestStatusCommand(
-            this.db,
-            { id: singlePayment.id, status: "CREATED", batchId }
-          );
-          await this.db.batch([upsertBatch, updateRequest]);
-          this.log({
-            message: `\u2728 Created single payment batch (${singlePayment.paymentType}) for account ${acc.id}`
-          });
+        const result = connector.parseAuthorizationCallback(callbackUrl);
+        if (!result.success) {
+          return {
+            paymentsUpdated: 0,
+            batchId: null,
+            batchAuthorized: false,
+            error: result.error
+          };
         }
-        if (regularPayments.length > 0) {
-          const openBatches = await getAccountAccumulatingBatchesQuery(
+        const prIds = [];
+        if (result.type === "paymentRequest") {
+          prIds.push(result.paymentRequestId);
+        }
+        if (result.type === "batch") {
+          const batchPayments = await getPaymentRequestsByBatchIdQuery(
             this.db,
-            {
-              accountId: acc.id,
-              paymentType: first2.paymentType
-            }
+            { batchId: result.batchId }
           );
-          let batchId;
-          let availableCount = 0;
-          let availableBatch;
-          for (const ob of openBatches) {
-            const existingPayments = await getPaymentRequestsByBatchIdQuery(
-              this.db,
-              { batchId: ob.id }
-            );
-            const limit = ob.metadata?.sizeLimit ?? acc.batchSizeLimit;
-            if (existingPayments.length < limit) {
-              availableBatch = ob;
-              availableCount = existingPayments.length;
-              break;
-            }
-          }
-          if (availableBatch) {
-            batchId = availableBatch.id;
-            this.log({
-              message: `\u{1F504} Found existing OPEN batch (${first2.paymentType}) for account ${acc.id}, merging ${availableCount} existing + ${regularPayments.length} new payments`
-            });
-          } else {
-            batchId = uuidv4();
-            this.log({
-              message: `\u2728 Creating new batch (${first2.paymentType}) for account ${acc.id} with ${regularPayments.length} payments`
-            });
-          }
-          const { command: upsertBatch } = upsertBatchCommand(this.db, {
-            batch: availableBatch ? { ...availableBatch } : {
-              id: batchId,
-              authorizationUrls: [],
-              accountId: acc.id,
-              paymentType: first2.paymentType,
-              status: "OPEN",
-              metadata: { sizeLimit: acc.batchSizeLimit }
-            }
-          });
-          const updateCommands = regularPayments.map(
-            (p) => updatePaymentRequestStatusCommand(this.db, {
-              id: p.id,
-              status: "CREATED",
-              batchId
-            }).command
-          );
-          await this.db.batch([upsertBatch, ...updateCommands]);
-          this.log({
-            message: `\u2705 Batch (${first2.paymentType}) upserted successfully for account ${acc.id}`
-          });
+          prIds.push(...batchPayments.map((pr) => pr.id));
         }
+        const { statusChanged } = await this._resolvePaymentRequestStatuses(prIds);
+        return {
+          paymentsUpdated: statusChanged,
+          batchId: result.type === "batch" ? result.batchId : null,
+          batchAuthorized: false,
+          error: null
+        };
       }
-    });
+    );
   }
   async processBatch(input) {
     return this.handleAction(
@@ -1255,19 +989,6 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       }
     );
   }
-  async queue(b) {
-    await this.handleAction(
-      null,
-      { successMessage: "Queue handler executed successfully" },
-      async () => {
-        this.logQueuePull(b);
-        const queueHandlerResponse = await this.addPaymentsToBatch({
-          paymentIds: b.messages.map(({ body }) => body.paymentId)
-        });
-        this.logOutput(queueHandlerResponse);
-      }
-    );
-  }
   async getAuthUri(input) {
     return this.handleAction(
       { data: input, schema: getAuthUriInputSchema },
@@ -1453,7 +1174,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           direction: "INCOMING",
           paymentType: "DOMESTIC",
           currency,
-          status: "COMPLETED",
+          status: "BOOKED",
           batchId: uuidv4(),
           initiatedAt: /* @__PURE__ */ new Date(),
           processedAt: /* @__PURE__ */ new Date(),
@@ -1471,7 +1192,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         this.logQueuePush({ payment, isPaymentExecuted: true });
         await this.pushToQueue(this.env.QUEUE_BUS_QUEUE, {
           eventType: "BANK_PAYMENT",
-          eventSignal: "paymentCompleted",
+          eventSignal: "paymentFetched",
           bankPayment: createdPayment,
           metadata: {
             correlationId: createdPayment.correlationId,
@@ -1486,7 +1207,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
   async sendPayment(input) {
     return this.handleAction(
       { data: input, schema: sendPaymentInputSchema },
-      { successMessage: "Payment queued successfully" },
+      { successMessage: "Payment initiated successfully" },
       async (data) => {
         const incomingPayment = toIncomingPayment(data);
         const { accounts } = await this._getAccounts();
@@ -1523,32 +1244,90 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           data.creditor
         );
         const accountAssigned = assignAccount(incomingPayment, account);
+        const batchedPayment = toBatchedPayment(accountAssigned);
         const { command: insertPaymentRequest } = createPaymentRequestCommand(
           this.db,
           { paymentRequest: toPaymentRequestInsert(accountAssigned, null) }
         );
         await insertPaymentRequest.execute();
-        await this.pushToQueue(
-          this.env.PAYMENTS_READY_TO_BATCH_QUEUE,
-          { paymentId: incomingPayment.id }
-        );
-        return { paymentId: incomingPayment.id };
+        const initiate = () => {
+          switch (data.paymentType) {
+            case "DOMESTIC":
+              return connector.initiateDomesticPayment(batchedPayment);
+            case "SEPA":
+              return connector.initiateSEPAPayment(batchedPayment);
+            case "SWIFT":
+              return connector.initiateForeignPayment(batchedPayment);
+            default:
+              throw createInternalError(null, {
+                message: `Unsupported payment type: ${data.paymentType}`,
+                code: "VALID-B-005",
+                status: 400
+              });
+          }
+        };
+        let initiated;
+        try {
+          initiated = await initiate();
+        } catch (err) {
+          await updatePaymentRequestStatusCommand(this.db, {
+            id: incomingPayment.id,
+            deletedAt: /* @__PURE__ */ new Date()
+          }).command.execute();
+          throw err;
+        }
+        await updatePaymentRequestStatusCommand(this.db, {
+          id: incomingPayment.id,
+          bankRefId: initiated.payment.bankRefId,
+          initiatedAt: initiated.payment.initiatedAt,
+          authorizationUrl: initiated.authorizationUrl
+        }).command.execute();
+        return {
+          paymentRequestId: incomingPayment.id,
+          authorizationUrl: initiated.authorizationUrl
+        };
       }
     );
   }
   async sendPaymentSync(input) {
+    const result = await this.sendPayment(input);
+    return {
+      ...result,
+      data: result.data ? { authorizationUrl: result.data.authorizationUrl } : void 0
+    };
+  }
+  async sendBatch(input) {
     return this.handleAction(
-      { data: input, schema: sendPaymentSyncInputSchema },
-      { successMessage: "Payment initiated successfully" },
-      async (data) => {
-        const incomingPayment = toIncomingPayment(data);
+      { data: input, schema: sendBatchInputSchema },
+      { successMessage: "Batch initiated successfully" },
+      async ({ payments: paymentInputs }) => {
+        const firstPayment = paymentInputs[0];
+        const debtorIban = firstPayment.debtor.iban;
+        const paymentType = firstPayment.paymentType;
+        const currency = firstPayment.currency;
+        for (const p of paymentInputs) {
+          if (p.debtor.iban !== debtorIban || p.currency !== currency) {
+            throw createInternalError(null, {
+              message: "All payments in a batch must have the same debtor IBAN and currency",
+              code: "VALID-B-011",
+              status: 422
+            });
+          }
+          if (p.paymentType !== paymentType) {
+            throw createInternalError(null, {
+              message: "All payments in a batch must have the same payment type",
+              code: "VALID-B-012",
+              status: 422
+            });
+          }
+        }
         const { accounts } = await this._getAccounts();
         const account = accounts.find(
-          (acc) => acc.iban === incomingPayment.debtorIban && acc.currency === incomingPayment.currency
+          (acc) => acc.iban === debtorIban && acc.currency === currency
         );
         if (!account) {
           throw createInternalError(null, {
-            message: `No account found for IBAN ${incomingPayment.debtorIban} with currency ${incomingPayment.currency}`,
+            message: `No account found for IBAN ${debtorIban} with currency ${currency}`,
             code: "VALID-B-004",
             status: 422
           });
@@ -1560,44 +1339,113 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             status: 422
           });
         }
-        const batchedPayment = toBatchedPayment(
-          assignAccount(incomingPayment, account)
-        );
+        if (paymentInputs.length > account.batchSizeLimit) {
+          throw createInternalError(null, {
+            message: `Batch size ${paymentInputs.length} exceeds limit ${account.batchSizeLimit}`,
+            code: "VALID-B-013",
+            status: 422
+          });
+        }
         const connector = await this._initiateBankConnector({
           connectorKey: account.connectorKey
         });
-        if (!connector.supportsPaymentType(data.paymentType)) {
+        if (!connector.supportsPaymentType(paymentType)) {
           throw createInternalError(null, {
-            message: `Connector ${account.connectorKey} does not support ${data.paymentType} payments yet`,
+            message: `Connector ${account.connectorKey} does not support ${paymentType} payments yet`,
             code: "VALID-B-006",
             status: 422
           });
         }
-        this._validatePaymentTypeAndCurrency(
-          data.paymentType,
-          data.currency,
-          data.creditor
+        for (const p of paymentInputs) {
+          this._validatePaymentTypeAndCurrency(
+            p.paymentType,
+            p.currency,
+            p.creditor
+          );
+        }
+        const incomingPayments = paymentInputs.map(toIncomingPayment);
+        const batchedPayments = incomingPayments.map(
+          (p) => toBatchedPayment(assignAccount(p, account))
         );
-        const initiate = () => {
-          switch (data.paymentType) {
-            case "DOMESTIC":
-              return connector.initiateDomesticPayment(batchedPayment);
+        const batchId = uuidv4();
+        const batchMode = connector.supportsBatch(paymentType) ? "NATIVE" : "SINGLE";
+        const batchCmd = upsertBatchCommand(this.db, {
+          batch: {
+            id: batchId,
+            authorizationUrls: [],
+            accountId: account.id,
+            paymentType,
+            status: "PROCESSING",
+            metadata: { sizeLimit: account.batchSizeLimit },
+            batchMode
+          }
+        }).command;
+        const prCmds = incomingPayments.map(
+          (p) => createPaymentRequestCommand(this.db, {
+            paymentRequest: toPaymentRequestInsert(
+              assignAccount(p, account),
+              batchId
+            )
+          }).command
+        );
+        await this.db.batch([batchCmd, ...prCmds]);
+        const initiateBatch = () => {
+          const args = { batchId, payments: batchedPayments };
+          switch (paymentType) {
             case "SEPA":
-              return connector.initiateSEPAPayment(batchedPayment);
+              return connector.initiateSEPABatch(args);
             case "SWIFT":
-              return connector.initiateForeignPayment(batchedPayment);
+              return connector.initiateForeignBatch(args);
+            case "DOMESTIC":
             default:
-              throw createInternalError(null, {
-                message: `Unsupported payment type for single payment: ${data.paymentType}`,
-                code: "VALID-B-005",
-                status: 400
-              });
+              return connector.initiateDomesticBatch(args);
           }
         };
-        const initiated = await initiate();
-        return {
-          authorizationUrl: initiated.authorizationUrl
-        };
+        let result;
+        try {
+          result = await initiateBatch();
+        } catch (err) {
+          const deletePrCmds = incomingPayments.map(
+            (p) => updatePaymentRequestStatusCommand(this.db, {
+              id: p.id,
+              deletedAt: /* @__PURE__ */ new Date()
+            }).command
+          );
+          const deleteBatchCmd = upsertBatchCommand(this.db, {
+            batch: {
+              id: batchId,
+              accountId: account.id,
+              paymentType,
+              status: "FAILED",
+              deletedAt: /* @__PURE__ */ new Date()
+            }
+          }).command;
+          await this.db.batch([deleteBatchCmd, ...deletePrCmds]);
+          throw err;
+        }
+        const { authorizationUrls, payments: preparedPayments } = result;
+        const isPerPaymentFallback = authorizationUrls.length === preparedPayments.length;
+        const updatePrCmds = preparedPayments.map(
+          (pp, i) => updatePaymentRequestStatusCommand(this.db, {
+            id: pp.id,
+            bankRefId: pp.bankRefId,
+            initiatedAt: pp.initiatedAt,
+            authorizationUrl: isPerPaymentFallback ? authorizationUrls[i] : authorizationUrls[0]
+          }).command
+        );
+        const updateBatchCmd = upsertBatchCommand(this.db, {
+          batch: {
+            id: batchId,
+            accountId: account.id,
+            paymentType,
+            authorizationUrls,
+            metadata: result.metadata,
+            status: "READY_TO_SIGN",
+            batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
+          }
+        }).command;
+        await this.db.batch([updateBatchCmd, ...updatePrCmds]);
+        return { batchId, authorizationUrls };
       }
     );
   }
@@ -1610,6 +1458,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         limit,
         includeWorkflow,
         includeBatchCounts,
+        includePendingPaymentRequestCount,
         filterIbans,
         filterCurrencies,
         filterBankRefIds
@@ -1627,7 +1476,8 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
               ...a,
               expiresAt: a.expiresAt || null,
               workflow: null,
-              batches: null
+              batches: null,
+              pendingPaymentRequestCount: null
             };
             if (includeWorkflow) {
               let status;
@@ -1648,6 +1498,18 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
               });
               result.batches = batchCounts;
             }
+            if (includePendingPaymentRequestCount) {
+              const [row] = await this.db.select({
+                count: sql`count(*)`
+              }).from(tables.paymentRequest).where(
+                and(
+                  eq(tables.paymentRequest.accountId, a.id),
+                  eq(tables.paymentRequest.status, "OPENED"),
+                  isNull(tables.paymentRequest.deletedAt)
+                )
+              );
+              result.pendingPaymentRequestCount = row?.count ?? 0;
+            }
             return result;
           })
         );
@@ -1827,27 +1689,18 @@ __decorateClass([
 __decorateClass([
   action("synchronize-accounts")
 ], BankServiceBase.prototype, "syncAccounts", 1);
+__decorateClass([
+  action("update-payment-request-statuses")
+], BankServiceBase.prototype, "updatePaymentRequestStatuses", 1);
 __decorateClass([
   action("scheduled")
 ], BankServiceBase.prototype, "scheduled", 1);
-__decorateClass([
-  action("update-batch-statuses")
-], BankServiceBase.prototype, "updateBatchStatuses", 1);
-__decorateClass([
-  action("update-payment-statuses")
-], BankServiceBase.prototype, "updatePaymentStatuses", 1);
 __decorateClass([
   action("handle-authorization-callback")
 ], BankServiceBase.prototype, "handleAuthorizationCallback", 1);
-__decorateClass([
-  action("add-payments-to-batch")
-], BankServiceBase.prototype, "addPaymentsToBatch", 1);
 __decorateClass([
   action("process-batch")
 ], BankServiceBase.prototype, "processBatch", 1);
-__decorateClass([
-  action("queue-handler")
-], BankServiceBase.prototype, "queue", 1);
 __decorateClass([
   action("get-auth-uri")
 ], BankServiceBase.prototype, "getAuthUri", 1);
@@ -1863,6 +1716,9 @@ __decorateClass([
 __decorateClass([
   action("send-payment-sync")
 ], BankServiceBase.prototype, "sendPaymentSync", 1);
+__decorateClass([
+  action("send-batch")
+], BankServiceBase.prototype, "sendBatch", 1);
 __decorateClass([
   action("get-bank-accounts")
 ], BankServiceBase.prototype, "getBankAccounts", 1);