@develit-services/bank 0.8.9 → 0.8.12

package/dist/export/worker.cjs

@@ -1,18 +1,18 @@
 'use strict';
 
 const backendSdk = require('@develit-io/backend-sdk');
-const drizzle = require('../shared/bank.DT6bg8k5.cjs');
+const drizzle = require('../shared/bank.Cev1E9sk.cjs');
+const drizzleOrm = require('drizzle-orm');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
-const mock_connector = require('../shared/bank.CtnsGHM8.cjs');
+const mock_connector = require('../shared/bank.CUvVxlHy.cjs');
 require('jose');
 const zod = require('zod');
-const paymentRequest_schema = require('../shared/bank.JVlyPAAb.cjs');
+const paymentRequest_schema = require('../shared/bank.BBXoZ5QU.cjs');
 const generalCodes = require('@develit-io/general-codes');
 require('date-fns');
-const drizzleOrm = require('drizzle-orm');
 require('node:crypto');
-require('../shared/bank.DJnDSYqE.cjs');
+require('../shared/bank.CVi6R7fr.cjs');
 require('drizzle-orm/relations');
 require('drizzle-orm/sqlite-core');
 require('drizzle-zod');
@@ -107,8 +107,8 @@ const createPaymentRequestCommand = (db, { paymentRequest }) => {
 const getAccountBatchCountsQuery = async (db, { accountId }) => {
   const result = await db.select({
     totalCount: drizzleOrm.sql`COUNT(*)`.as("totalCount"),
-    openCount: drizzleOrm.sql`SUM(CASE WHEN ${drizzle.tables.batch.status} = 'OPEN' THEN 1 ELSE 0 END)`.as(
-      "openCount"
+    processingCount: drizzleOrm.sql`SUM(CASE WHEN ${drizzle.tables.batch.status} = 'PROCESSING' THEN 1 ELSE 0 END)`.as(
+      "processingCount"
     ),
     readyToSignCount: drizzleOrm.sql`SUM(CASE WHEN ${drizzle.tables.batch.status} = 'READY_TO_SIGN' THEN 1 ELSE 0 END)`.as(
       "readyToSignCount"
@@ -119,7 +119,7 @@ const getAccountBatchCountsQuery = async (db, { accountId }) => {
   }).from(drizzle.tables.batch).where(drizzleOrm.eq(drizzle.tables.batch.accountId, accountId)).then(backendSdk.first);
   return result || {
     totalCount: 0,
-    openCount: 0,
+    processingCount: 0,
     readyToSignCount: 0,
     failedCount: 0
   };
@@ -162,10 +162,6 @@ const getAllAccountsQuery = async (db, filters) => {
   };
 };
 
-const getAllPendingBatchesQuery = (db) => {
-  return db.select().from(drizzle.tables.batch).where(drizzleOrm.inArray(drizzle.tables.batch.status, ["READY_TO_SIGN", "SIGNED"]));
-};
-
 const buildMultiFilterConditions = (column, value) => {
   if (value === void 0) return void 0;
   if (Array.isArray(value)) {
@@ -265,6 +261,7 @@ const getBatchesQuery = async (db, {
   filterBatchStatus
 }) => {
   const whereConditions = drizzleOrm.and(
+    drizzleOrm.isNull(drizzle.tables.batch.deletedAt),
     buildMultiFilterConditions(drizzle.tables.batch.accountId, filterBatchAccountId),
     buildMultiFilterConditions(drizzle.tables.batch.status, filterBatchStatus)
   );
@@ -274,7 +271,12 @@ const getBatchesQuery = async (db, {
   }).from(drizzle.tables.batch).where(whereConditions);
   const batches = await db.select().from(drizzle.tables.batch).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
   const batchIds = batches.map((b) => b.id);
-  const paymentRequests = batchIds.length > 0 ? await db.select().from(drizzle.tables.paymentRequest).where(drizzleOrm.inArray(drizzle.tables.paymentRequest.batchId, batchIds)) : [];
+  const paymentRequests = batchIds.length > 0 ? await db.select().from(drizzle.tables.paymentRequest).where(
+    drizzleOrm.and(
+      drizzleOrm.inArray(drizzle.tables.paymentRequest.batchId, batchIds),
+      drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt)
+    )
+  ) : [];
   const paymentRequestsByBatchId = Map.groupBy(
     paymentRequests,
     (pr) => pr.batchId
@@ -289,17 +291,6 @@ const getBatchesQuery = async (db, {
   };
 };
 
-const getAccountAccumulatingBatchesQuery = async (db, { accountId, paymentType }) => {
-  return await db.select().from(drizzle.tables.batch).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(drizzle.tables.batch.accountId, accountId),
-      drizzleOrm.eq(drizzle.tables.batch.status, "OPEN"),
-      drizzleOrm.isNull(drizzle.tables.batch.batchPaymentInitiatedAt),
-      paymentType ? drizzleOrm.eq(drizzle.tables.batch.paymentType, paymentType) : void 0
-    )
-  );
-};
-
 const getOttQuery = async (db, { ott }) => {
   return await db.select().from(drizzle.tables.ott).where(drizzleOrm.eq(drizzle.tables.ott.oneTimeToken, ott)).get();
 };
@@ -346,15 +337,15 @@ const getPaymentRequestsQuery = async (db, params) => {
   return { paymentRequests, totalCount };
 };
 
-const NON_BATCH_CONNECTOR_KEYS = ["DBU", "CREDITAS"];
-const getPendingNonBatchPaymentRequestsQuery = (db) => db.select().from(drizzle.tables.paymentRequest).where(
+const TERMINAL_STATUSES = [
+  "SETTLED",
+  "REJECTED",
+  "CLOSED"
+];
+const getNonTerminalPaymentRequestsQuery = (db) => db.select().from(drizzle.tables.paymentRequest).where(
   drizzleOrm.and(
-    drizzleOrm.inArray(drizzle.tables.paymentRequest.status, [
-      "PREPARED",
-      "SIGNED",
-      "PENDING"
-    ]),
-    drizzleOrm.inArray(drizzle.tables.paymentRequest.connectorKey, NON_BATCH_CONNECTOR_KEYS)
+    drizzleOrm.not(drizzleOrm.inArray(drizzle.tables.paymentRequest.status, TERMINAL_STATUSES)),
+    drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt)
   )
 );
 
@@ -375,6 +366,10 @@ const sendPaymentInputSchema = zod.z.object({
   sendAsSinglePayment: zod.z.boolean().optional()
 });
 
+const sendBatchInputSchema = zod.z.object({
+  payments: zod.z.array(sendPaymentInputSchema).min(1)
+});
+
 const getAuthUriInputSchema = zod.z.object({
   connectorKey: zod.z.enum(paymentRequest_schema.CONNECTOR_KEYS)
 });
@@ -439,14 +434,6 @@ zod.z.object({
   details: backendSdk.workflowInstanceStatusSchema
 });
 
-const updateBatchStatusesInputSchema = zod.z.object({
-  batchId: zod.z.uuid().optional()
-}).optional();
-zod.z.object({
-  processed: zod.z.number(),
-  statusChanged: zod.z.number()
-});
-
 const ALLOWED_PAYMENT_FILTERS = {
   ACCOUNT_ID: "filterPaymentAccountId",
   AMOUNT: "filterPaymentAmount",
@@ -535,6 +522,7 @@ const getBankAccountsInputSchema = zod.z.object({
   limit: zod.z.number().positive().optional(),
   includeWorkflow: zod.z.boolean().optional(),
   includeBatchCounts: zod.z.boolean().optional(),
+  includePendingPaymentRequestCount: zod.z.boolean().optional(),
   filterIbans: zod.z.array(zod.z.string()).optional(),
   filterCurrencies: zod.z.array(zod.z.string()).optional(),
   filterBankRefIds: zod.z.array(zod.z.string()).optional()
@@ -545,14 +533,9 @@ const disconnectAccountInputSchema = zod.z.object({
 });
 
 const handleAuthorizationCallbackInputSchema = zod.z.object({
-  paymentId: zod.z.string().uuid().optional(),
-  batchId: zod.z.string().uuid().optional()
-}).refine((data) => data.paymentId || data.batchId, {
-  message: "Either paymentId or batchId is required"
+  callbackUrl: zod.z.string().url()
 });
 
-const sendPaymentSyncInputSchema = sendPaymentInputSchema;
-
 const getPaymentRequestsInputSchema = zod.z.object({
   page: zod.z.number().positive(),
   limit: zod.z.number().positive(),
@@ -561,7 +544,10 @@ const getPaymentRequestsInputSchema = zod.z.object({
     direction: zod.z.enum(["asc", "desc"])
   }),
   filterAccountId: zod.z.union([zod.z.uuid(), zod.z.uuid().array()]).optional(),
-  filterStatus: zod.z.union([zod.z.enum(paymentRequest_schema.PAYMENT_STATUSES), zod.z.enum(paymentRequest_schema.PAYMENT_STATUSES).array()]).optional(),
+  filterStatus: zod.z.union([
+    zod.z.enum(paymentRequest_schema.PAYMENT_REQUEST_STATUSES),
+    zod.z.enum(paymentRequest_schema.PAYMENT_REQUEST_STATUSES).array()
+  ]).optional(),
   filterPaymentType: zod.z.union([zod.z.enum(paymentRequest_schema.PAYMENT_TYPES), zod.z.enum(paymentRequest_schema.PAYMENT_TYPES).array()]).optional(),
   filterCurrency: zod.z.union([zod.z.enum(generalCodes.CURRENCY_CODES), zod.z.enum(generalCodes.CURRENCY_CODES).array()]).optional(),
   filterMinAmount: zod.z.number().positive().optional(),
@@ -581,11 +567,6 @@ const getPaymentRequestsInputSchema = zod.z.object({
   // filterDirection: removed — payment_request is always OUTGOING
 });
 
-zod.z.object({
-  processed: zod.z.number(),
-  statusChanged: zod.z.number()
-});
-
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -596,11 +577,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 backendSdk.develitWorker(cloudflare_workers.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 = d1.drizzle(this.env.BANK_D1, { schema: drizzle.tables });
   }
@@ -745,472 +729,222 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       }
     );
   }
-  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 drizzle.upsertBatchCommand(this.db, {
-        batch: {
-          ...batch,
-          status: currentStatus,
-          statusResponse: apiResponse
-        }
-      }).command.execute();
-      statusChanged = true;
-    }
-    if (statusChanged) {
-      const paymentRequests = await drizzle.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 drizzle.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 = mock_connector.mapFinbricksTransactionStatus(
-              match.resultCode,
-              match.finalBankStatus ?? false
-            );
-          }
-        } else {
-          newStatus = batchStatusToPaymentStatus[currentStatus] ?? pr.status;
-        }
-        if (newStatus !== pr.status) {
-          await drizzle.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 drizzle.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 drizzle.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 drizzle.getBatchByIdQuery(this.db, {
-            batchId: validatedInput.batchId
-          });
-          if (!batch) {
-            throw backendSdk.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 drizzle.getPaymentRequestsByBatchIdQuery(this.db, {
-              batchId: batch.id
-            });
-            const prCmds = prs.filter((p) => p.status !== "FAILED").map(
-              (p) => drizzle.updatePaymentRequestStatusCommand(this.db, {
-                id: p.id,
-                status: "FAILED",
-                statusReason: "ACCOUNT_NOT_FOUND",
-                processedAt: /* @__PURE__ */ new Date()
-              }).command
-            );
-            const batchCmd = drizzle.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 drizzle.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([
+      drizzle.getPaymentRequestsByBatchIdQuery(this.db, { batchId }),
+      drizzle.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 drizzle.upsertBatchCommand(this.db, {
+        batch: { ...batch, status: hasFailed ? "FAILED" : "COMPLETED" }
+      }).command.execute();
+    } else if (allAuthorizedOrHigher && batch.status !== "AUTHORIZED") {
+      await drizzle.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 drizzle.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 drizzle.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 drizzle.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([
-            drizzle.getPaymentRequestsByBatchIdQuery(this.db, { batchId }),
-            drizzle.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 drizzle.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 backendSdk.createInternalError(null, {
-              message: `Payment request not found: ${paymentId}`,
-              code: "DB-B-008",
-              status: 404
-            });
-          }
-          if (pr.status !== "SIGNED" && pr.status !== "COMPLETED") {
-            await drizzle.updatePaymentRequestStatusCommand(this.db, {
-              id: paymentId,
-              status: "SIGNED"
-            }).command.execute();
-            paymentsUpdated = 1;
-          }
-          targetBatchId = pr.batchId;
-        }
-        if (batchId) {
-          targetBatchId = batchId;
-          const batchPayments = await drizzle.getPaymentRequestsByBatchIdQuery(
-            this.db,
-            {
-              batchId
-            }
-          );
-          for (const pr of batchPayments) {
-            if (pr.status !== "SIGNED" && pr.status !== "COMPLETED") {
-              await drizzle.updatePaymentRequestStatusCommand(this.db, {
-                id: pr.id,
-                status: "SIGNED"
-              }).command.execute();
-              paymentsUpdated++;
-            }
-          }
-        }
-        let batchSigned = false;
-        if (targetBatchId) {
-          const allPayments = await drizzle.getPaymentRequestsByBatchIdQuery(this.db, {
-            batchId: targetBatchId
+          if (pr) connectorKey = pr.connectorKey;
+        } else if (batchId) {
+          const batchPrs = await drizzle.getPaymentRequestsByBatchIdQuery(this.db, {
+            batchId
           });
-          const allDone = allPayments.every(
-            (p) => p.status === "SIGNED" || p.status === "COMPLETED"
-          );
-          if (allDone) {
-            const batch = await drizzle.getBatchByIdQuery(this.db, {
-              batchId: targetBatchId
-            });
-            if (batch && batch.status !== "SIGNED") {
-              await drizzle.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) => drizzle.updatePaymentRequestStatusCommand(this.db, {
-                id: p.id,
-                status: "FAILED",
-                statusReason: "ACCOUNT_NOT_FOUND"
-              }).command.execute()
-            )
-          );
-          continue;
+        if (!connectorKey) {
+          throw backendSdk.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 = backendSdk.uuidv4();
-          const { command: upsertBatch } = drizzle.upsertBatchCommand(this.db, {
-            batch: {
-              id: batchId,
-              authorizationUrls: [],
-              accountId: acc.id,
-              paymentType: singlePayment.paymentType,
-              status: "OPEN",
-              metadata: { sizeLimit: 1 }
-            }
-          });
-          const { command: updateRequest } = drizzle.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
+          };
+        }
+        const prIds = [];
+        if (result.type === "paymentRequest") {
+          prIds.push(result.paymentRequestId);
         }
-        if (regularPayments.length > 0) {
-          const openBatches = await getAccountAccumulatingBatchesQuery(
+        if (result.type === "batch") {
+          const batchPayments = await drizzle.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 drizzle.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 = backendSdk.uuidv4();
-            this.log({
-              message: `\u2728 Creating new batch (${first2.paymentType}) for account ${acc.id} with ${regularPayments.length} payments`
-            });
-          }
-          const { command: upsertBatch } = drizzle.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) => drizzle.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(
@@ -1257,19 +991,6 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       }
     );
   }
-  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 },
@@ -1455,7 +1176,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           direction: "INCOMING",
           paymentType: "DOMESTIC",
           currency,
-          status: "COMPLETED",
+          status: "BOOKED",
           batchId: backendSdk.uuidv4(),
           initiatedAt: /* @__PURE__ */ new Date(),
           processedAt: /* @__PURE__ */ new Date(),
@@ -1473,7 +1194,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         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,
@@ -1488,20 +1209,32 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
   async sendPayment(input) {
     return this.handleAction(
       { data: input, schema: sendPaymentInputSchema },
-      { successMessage: "Payment queued successfully" },
+      { successMessage: "Payment initiated successfully" },
       async (data) => {
         const incomingPayment = mock_connector.toIncomingPayment(data);
+        this._validatePaymentTypeAndCurrency(
+          data.paymentType,
+          data.currency,
+          data.creditor
+        );
         const { accounts } = await this._getAccounts();
         const account = accounts.find(
-          (acc) => acc.iban === incomingPayment.debtorIban && acc.currency === incomingPayment.currency
+          (acc) => acc.iban === incomingPayment.debtorIban
         );
         if (!account) {
           throw backendSdk.createInternalError(null, {
-            message: `No account found for IBAN ${incomingPayment.debtorIban} with currency ${incomingPayment.currency}`,
+            message: `No account found for IBAN ${incomingPayment.debtorIban}`,
             code: "VALID-B-004",
             status: 422
           });
         }
+        if (account.currency !== data.currency) {
+          throw backendSdk.createInternalError(null, {
+            message: `Account ${account.iban} has currency ${account.currency}, but payment requires ${data.currency}`,
+            code: "VALID-B-010",
+            status: 422
+          });
+        }
         if (account.status !== "AUTHORIZED") {
           throw backendSdk.createInternalError(null, {
             message: `Account ${account.iban} is not authorized (status: ${account.status})`,
@@ -1519,42 +1252,107 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             status: 422
           });
         }
-        this._validatePaymentTypeAndCurrency(
-          data.paymentType,
-          data.currency,
-          data.creditor
-        );
         const accountAssigned = mock_connector.assignAccount(incomingPayment, account);
+        const batchedPayment = mock_connector.toBatchedPayment(accountAssigned);
         const { command: insertPaymentRequest } = createPaymentRequestCommand(
           this.db,
           { paymentRequest: mock_connector.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 backendSdk.createInternalError(null, {
+                message: `Unsupported payment type: ${data.paymentType}`,
+                code: "VALID-B-005",
+                status: 400
+              });
+          }
+        };
+        let initiated;
+        try {
+          initiated = await initiate();
+        } catch (err) {
+          await drizzle.updatePaymentRequestStatusCommand(this.db, {
+            id: incomingPayment.id,
+            deletedAt: /* @__PURE__ */ new Date()
+          }).command.execute();
+          throw err;
+        }
+        await drizzle.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 = mock_connector.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 backendSdk.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 backendSdk.createInternalError(null, {
+              message: "All payments in a batch must have the same payment type",
+              code: "VALID-B-012",
+              status: 422
+            });
+          }
+        }
+        for (const p of paymentInputs) {
+          this._validatePaymentTypeAndCurrency(
+            p.paymentType,
+            p.currency,
+            p.creditor
+          );
+        }
         const { accounts } = await this._getAccounts();
-        const account = accounts.find(
-          (acc) => acc.iban === incomingPayment.debtorIban && acc.currency === incomingPayment.currency
-        );
+        const account = accounts.find((acc) => acc.iban === debtorIban);
         if (!account) {
           throw backendSdk.createInternalError(null, {
-            message: `No account found for IBAN ${incomingPayment.debtorIban} with currency ${incomingPayment.currency}`,
+            message: `No account found for IBAN ${debtorIban}`,
             code: "VALID-B-004",
             status: 422
           });
         }
+        if (account.currency !== currency) {
+          throw backendSdk.createInternalError(null, {
+            message: `Account ${account.iban} has currency ${account.currency}, but payments require ${currency}`,
+            code: "VALID-B-010",
+            status: 422
+          });
+        }
         if (account.status !== "AUTHORIZED") {
           throw backendSdk.createInternalError(null, {
             message: `Account ${account.iban} is not authorized (status: ${account.status})`,
@@ -1562,44 +1360,106 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             status: 422
           });
         }
-        const batchedPayment = mock_connector.toBatchedPayment(
-          mock_connector.assignAccount(incomingPayment, account)
-        );
+        if (paymentInputs.length > account.batchSizeLimit) {
+          throw backendSdk.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 backendSdk.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
+        const incomingPayments = paymentInputs.map(mock_connector.toIncomingPayment);
+        const batchedPayments = incomingPayments.map(
+          (p) => mock_connector.toBatchedPayment(mock_connector.assignAccount(p, account))
         );
-        const initiate = () => {
-          switch (data.paymentType) {
-            case "DOMESTIC":
-              return connector.initiateDomesticPayment(batchedPayment);
+        const batchId = backendSdk.uuidv4();
+        const batchMode = connector.supportsBatch(paymentType) ? "NATIVE" : "SINGLE";
+        const batchCmd = drizzle.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: mock_connector.toPaymentRequestInsert(
+              mock_connector.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 backendSdk.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) => drizzle.updatePaymentRequestStatusCommand(this.db, {
+              id: p.id,
+              deletedAt: /* @__PURE__ */ new Date()
+            }).command
+          );
+          const deleteBatchCmd = drizzle.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) => drizzle.updatePaymentRequestStatusCommand(this.db, {
+            id: pp.id,
+            bankRefId: pp.bankRefId,
+            initiatedAt: pp.initiatedAt,
+            authorizationUrl: isPerPaymentFallback ? authorizationUrls[i] : authorizationUrls[0]
+          }).command
+        );
+        const updateBatchCmd = drizzle.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 };
       }
     );
   }
@@ -1612,6 +1472,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         limit,
         includeWorkflow,
         includeBatchCounts,
+        includePendingPaymentRequestCount,
         filterIbans,
         filterCurrencies,
         filterBankRefIds
@@ -1629,7 +1490,8 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
               ...a,
               expiresAt: a.expiresAt || null,
               workflow: null,
-              batches: null
+              batches: null,
+              pendingPaymentRequestCount: null
             };
             if (includeWorkflow) {
               let status;
@@ -1650,6 +1512,18 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
               });
               result.batches = batchCounts;
             }
+            if (includePendingPaymentRequestCount) {
+              const [row] = await this.db.select({
+                count: drizzleOrm.sql`count(*)`
+              }).from(drizzle.tables.paymentRequest).where(
+                drizzleOrm.and(
+                  drizzleOrm.eq(drizzle.tables.paymentRequest.accountId, a.id),
+                  drizzleOrm.eq(drizzle.tables.paymentRequest.status, "OPENED"),
+                  drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt)
+                )
+              );
+              result.pendingPaymentRequestCount = row?.count ?? 0;
+            }
             return result;
           })
         );
@@ -1829,27 +1703,18 @@ __decorateClass([
 __decorateClass([
   backendSdk.action("synchronize-accounts")
 ], BankServiceBase.prototype, "syncAccounts", 1);
+__decorateClass([
+  backendSdk.action("update-payment-request-statuses")
+], BankServiceBase.prototype, "updatePaymentRequestStatuses", 1);
 __decorateClass([
   backendSdk.action("scheduled")
 ], BankServiceBase.prototype, "scheduled", 1);
-__decorateClass([
-  backendSdk.action("update-batch-statuses")
-], BankServiceBase.prototype, "updateBatchStatuses", 1);
-__decorateClass([
-  backendSdk.action("update-payment-statuses")
-], BankServiceBase.prototype, "updatePaymentStatuses", 1);
 __decorateClass([
   backendSdk.action("handle-authorization-callback")
 ], BankServiceBase.prototype, "handleAuthorizationCallback", 1);
-__decorateClass([
-  backendSdk.action("add-payments-to-batch")
-], BankServiceBase.prototype, "addPaymentsToBatch", 1);
 __decorateClass([
   backendSdk.action("process-batch")
 ], BankServiceBase.prototype, "processBatch", 1);
-__decorateClass([
-  backendSdk.action("queue-handler")
-], BankServiceBase.prototype, "queue", 1);
 __decorateClass([
   backendSdk.action("get-auth-uri")
 ], BankServiceBase.prototype, "getAuthUri", 1);
@@ -1865,6 +1730,9 @@ __decorateClass([
 __decorateClass([
   backendSdk.action("send-payment-sync")
 ], BankServiceBase.prototype, "sendPaymentSync", 1);
+__decorateClass([
+  backendSdk.action("send-batch")
+], BankServiceBase.prototype, "sendBatch", 1);
 __decorateClass([
   backendSdk.action("get-bank-accounts")
 ], BankServiceBase.prototype, "getBankAccounts", 1);