@lenso/payments 0.0.0-stage → 0.1.2

package/dist/index-bzm562dq.js

@@ -0,0 +1,461 @@
+import {
+  PaymentsError2,
+  RefundNotCreatedError2
+} from "./index-qtpqn1xv.js";
+
+// src/index.ts
+function identifier(value) {
+  if (typeof value !== "string" || !value.length || value.length > 256 || [...value].some((character) => character.charCodeAt(0) < 32))
+    throw new PaymentsError2("invalid-input");
+}
+async function digest(parts) {
+  const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(parts)));
+  return Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function resource(record) {
+  return Object.freeze({
+    paymentId: record.paymentId,
+    tenantId: record.tenantId,
+    orderId: record.orderId,
+    accountId: record.accountId,
+    live: record.live,
+    amount: record.amount,
+    currency: record.currency
+  });
+}
+function view(record) {
+  return {
+    ...resource(record),
+    status: record.status,
+    providerId: record.providerId,
+    refunds: record.refunds.map(({ refundId, amount, status, providerId }) => ({
+      refundId,
+      amount,
+      status,
+      providerId
+    }))
+  };
+}
+function verifyPayment(record, payment) {
+  if (payment.paymentId !== record.paymentId || payment.tenantId !== record.tenantId || payment.orderId !== record.orderId || payment.accountId !== record.accountId || payment.live !== record.live || payment.amount !== record.amount || payment.currency !== record.currency || record.providerId !== null && payment.id !== record.providerId || payment.status === "succeeded" && payment.received !== record.amount)
+    throw new PaymentsError2("provider-mismatch");
+}
+function verifyRefund(record, refund, observed) {
+  if (observed.paymentId !== record.paymentId || observed.refundId !== refund.refundId || observed.paymentProviderId !== record.providerId || observed.accountId !== record.accountId || observed.live !== record.live || observed.amount !== refund.amount || observed.currency !== record.currency || refund.providerId !== null && observed.id !== refund.providerId)
+    throw new PaymentsError2("provider-mismatch");
+}
+function paymentTerminal(status) {
+  return status === "succeeded" || status === "canceled";
+}
+function refundTerminal(status) {
+  return status === "succeeded" || status === "failed" || status === "canceled";
+}
+function appendResult(record, result) {
+  if (!record.results.some((existing) => existing.resultId === result.resultId))
+    record.results.push(result);
+}
+function createPayments2(options) {
+  const { store, provider, authorize } = options;
+  const clock = options.clock ?? Date.now;
+  const leaseMs = options.leaseMs ?? 60000;
+  const delay = options.reconcileDelayMs ?? 60000;
+  const maxRefunds = options.maxRefunds ?? 100;
+  if (typeof authorize !== "function" || !Number.isSafeInteger(leaseMs) || leaseMs < 1000 || leaseMs > 3600000 || !Number.isSafeInteger(delay) || delay < 1000 || delay > 86400000 || !Number.isSafeInteger(maxRefunds) || maxRefunds < 1 || maxRefunds > 1000 || !Number.isSafeInteger(provider.replayWindowMs) || provider.replayWindowMs <= 0)
+    throw new PaymentsError2("invalid-input");
+  identifier(provider.accountId);
+  function now() {
+    const value = clock();
+    if (!Number.isSafeInteger(value) || value < 0)
+      throw new PaymentsError2("unavailable");
+    return value;
+  }
+  async function load(paymentId) {
+    identifier(paymentId);
+    const record = await store.get(paymentId);
+    if (!record)
+      throw new PaymentsError2("not-found");
+    if (record.accountId !== provider.accountId || record.live !== provider.live)
+      throw new PaymentsError2("forbidden");
+    return record;
+  }
+  async function allowed(actor, action, record) {
+    await authorize(actor, action, resource(record));
+  }
+  function renewLease(record, token) {
+    const time = now();
+    if (record.lease?.token !== token || record.lease.until <= time)
+      throw new PaymentsError2("conflict");
+    record.lease.until = time + leaseMs;
+  }
+  async function mutate(paymentId, change) {
+    for (let attempt = 0;attempt < 12; attempt++) {
+      const current = await load(paymentId);
+      const next = structuredClone(current);
+      if (!change(next))
+        return current;
+      next.revision = current.revision + 1;
+      next.updatedAt = now();
+      if (await store.compareAndSet(next, current.revision))
+        return next;
+    }
+    throw new PaymentsError2("conflict");
+  }
+  async function observePayment(paymentId, token, observed) {
+    return mutate(paymentId, (record) => {
+      renewLease(record, token);
+      verifyPayment(record, observed);
+      if (paymentTerminal(record.status) && observed.status !== record.status)
+        throw new PaymentsError2("provider-mismatch");
+      record.providerId = observed.id;
+      record.status = observed.status;
+      if (paymentTerminal(record.status)) {
+        appendResult(record, {
+          ...resource(record),
+          kind: record.status === "succeeded" ? "payment.succeeded" : "payment.canceled",
+          resultId: `${record.paymentId}:${record.status}`
+        });
+      }
+      return true;
+    });
+  }
+  async function observeRefund(paymentId, token, refundId, observed) {
+    return mutate(paymentId, (record) => {
+      renewLease(record, token);
+      const refund = record.refunds.find((item) => item.refundId === refundId);
+      verifyRefund(record, refund, observed);
+      if (refundTerminal(refund.status) && observed.status !== refund.status)
+        throw new PaymentsError2("provider-mismatch");
+      refund.providerId = observed.id;
+      refund.status = observed.status;
+      if (refundTerminal(refund.status)) {
+        appendResult(record, {
+          ...resource(record),
+          kind: refund.status === "succeeded" ? "refund.succeeded" : refund.status === "failed" ? "refund.failed" : "refund.canceled",
+          resultId: `${refund.refundId}:${refund.status}`,
+          refundId,
+          refundAmount: refund.amount
+        });
+      }
+      return true;
+    });
+  }
+  async function run(paymentId) {
+    const token = crypto.randomUUID();
+    let record = await mutate(paymentId, (current) => {
+      if (current.lease && current.lease.until > now())
+        return false;
+      current.lease = { token, until: now() + leaseMs };
+      return true;
+    });
+    if (record.lease?.token !== token)
+      return false;
+    let resolved = true;
+    try {
+      const previousAttempt = record.attemptedAt;
+      if (previousAttempt === null) {
+        record = await mutate(paymentId, (current) => {
+          if (current.lease?.token !== token)
+            throw new PaymentsError2("conflict");
+          current.attemptedAt = now();
+          return true;
+        });
+      }
+      let observed = record.providerId ? await provider.getPayment(record.providerId) : previousAttempt === null ? null : await provider.findPayment(record);
+      if (!observed) {
+        record = await load(paymentId);
+        if (record.providerId) {
+          observed = await provider.getPayment(record.providerId);
+        } else if (mayWrite(record, token, record.attemptedAt)) {
+          observed = await provider.createPayment(record, `payment:${record.paymentId}`, async () => {
+            const current = await load(paymentId);
+            if (!mayWrite(current, token, current.attemptedAt) || current.providerId !== null)
+              throw new PaymentsError2("conflict");
+          });
+        }
+      }
+      if (!observed)
+        return false;
+      record = await observePayment(paymentId, token, observed);
+      for (const pending of record.refunds) {
+        if (refundTerminal(pending.status) && pending.providerId === null)
+          continue;
+        let refund = pending;
+        const previousRefundAttempt = refund.attemptedAt;
+        record = await mutate(paymentId, (current) => {
+          renewLease(current, token);
+          const item = current.refunds.find((candidate) => candidate.refundId === refund.refundId);
+          item.attemptedAt ??= now();
+          return true;
+        });
+        refund = record.refunds.find((item) => item.refundId === refund.refundId);
+        let observedRefund = refund.providerId ? await provider.getRefund(refund.providerId) : previousRefundAttempt === null ? null : await provider.findRefund(record, refund);
+        if (!observedRefund) {
+          record = await load(paymentId);
+          refund = record.refunds.find((item) => item.refundId === refund.refundId);
+          if (refund.providerId) {
+            observedRefund = await provider.getRefund(refund.providerId);
+          } else if (mayWrite(record, token, refund.attemptedAt)) {
+            try {
+              observedRefund = await provider.createRefund(record, refund, `refund:${refund.refundId}`, async () => {
+                const current = await load(paymentId);
+                const item = current.refunds.find((candidate) => candidate.refundId === refund.refundId);
+                if (!item || !mayWrite(current, token, item.attemptedAt) || item.providerId !== null || item.status !== "unknown" || current.providerId !== record.providerId)
+                  throw new PaymentsError2("conflict");
+              });
+            } catch (error) {
+              if (!(error instanceof RefundNotCreatedError2))
+                throw error;
+              record = await mutate(paymentId, (current) => {
+                renewLease(current, token);
+                const item = current.refunds.find((candidate) => candidate.refundId === refund.refundId);
+                if (item.providerId !== null)
+                  throw new PaymentsError2("provider-mismatch");
+                item.status = "failed";
+                appendResult(current, {
+                  ...resource(current),
+                  kind: "refund.failed",
+                  resultId: `${item.refundId}:failed`,
+                  refundId: item.refundId,
+                  refundAmount: item.amount
+                });
+                return true;
+              });
+              continue;
+            }
+          }
+        }
+        if (observedRefund)
+          record = await observeRefund(paymentId, token, refund.refundId, observedRefund);
+        else
+          resolved = false;
+      }
+      return resolved;
+    } catch (error) {
+      if (error instanceof PaymentsError2 && error.code === "provider-mismatch")
+        throw error;
+      return false;
+    } finally {
+      await mutate(paymentId, (current) => {
+        if (current.lease?.token !== token)
+          return false;
+        current.lease = null;
+        const finished = paymentTerminal(current.status) && current.refunds.every((item) => refundTerminal(item.status));
+        current.reconcileAt = finished ? Number.MAX_SAFE_INTEGER : now() + delay;
+        return true;
+      });
+    }
+  }
+  function mayWrite(record, token, attemptedAt) {
+    const time = now();
+    return record.lease?.token === token && record.lease.until > time && attemptedAt !== null && time >= attemptedAt && time - attemptedAt < provider.replayWindowMs;
+  }
+  const payments = {
+    async create(input, actor) {
+      identifier(input.tenantId);
+      identifier(input.orderId);
+      identifier(input.key);
+      provider.validateAmount(input.amount, input.currency);
+      const paymentId = await digest([
+        provider.accountId,
+        provider.live,
+        input.tenantId,
+        input.key
+      ]);
+      const orderKey = await digest([
+        provider.accountId,
+        provider.live,
+        input.tenantId,
+        input.orderId
+      ]);
+      const time = now();
+      const draft = {
+        tenantId: input.tenantId,
+        orderId: input.orderId,
+        key: input.key,
+        amount: input.amount,
+        currency: input.currency,
+        paymentId,
+        orderKey,
+        accountId: provider.accountId,
+        live: provider.live,
+        providerId: null,
+        status: "unknown",
+        revision: 0,
+        lease: null,
+        attemptedAt: null,
+        refunds: [],
+        results: [],
+        createdAt: time,
+        updatedAt: time,
+        reconcileAt: time
+      };
+      await allowed(actor, "create", draft);
+      if (!await store.insert(draft)) {
+        const existing = await store.get(paymentId) ?? await store.getByOrder(orderKey);
+        if (!existing)
+          throw new PaymentsError2("conflict");
+        await allowed(actor, "create", existing);
+        if (existing.paymentId !== paymentId || existing.orderKey !== orderKey || existing.amount !== input.amount || existing.currency !== input.currency || existing.key !== input.key)
+          throw new PaymentsError2("conflict");
+      }
+      const current = await load(paymentId);
+      if (current.attemptedAt === null)
+        await run(paymentId);
+      return view(await load(paymentId));
+    },
+    async get(input, actor) {
+      const record = await load(input.paymentId);
+      await allowed(actor, "read", record);
+      return view(record);
+    },
+    async refund(input, actor) {
+      identifier(input.key);
+      let record = await load(input.paymentId);
+      await allowed(actor, "refund", record);
+      provider.validateRefundAmount(input.amount, record.currency);
+      const refundId = await digest([record.paymentId, input.key]);
+      record = await mutate(record.paymentId, (current) => {
+        const existing = current.refunds.find((refund) => refund.key === input.key);
+        if (existing) {
+          if (existing.amount !== input.amount)
+            throw new PaymentsError2("conflict");
+          return false;
+        }
+        if (current.status !== "succeeded" || !current.providerId)
+          throw new PaymentsError2("conflict");
+        const reserved = current.refunds.reduce((sum, refund) => sum + (refund.status === "failed" || refund.status === "canceled" ? 0 : refund.amount), 0);
+        if (input.amount > current.amount - reserved || current.refunds.length >= maxRefunds)
+          throw new PaymentsError2("conflict");
+        current.refunds.push({
+          refundId,
+          key: input.key,
+          amount: input.amount,
+          providerId: null,
+          status: "unknown",
+          attemptedAt: null
+        });
+        current.reconcileAt = now();
+        return true;
+      });
+      if (record.refunds.find((refund) => refund.refundId === refundId)?.attemptedAt === null)
+        await run(record.paymentId);
+      return view(await load(record.paymentId));
+    },
+    async results(input, actor) {
+      const record = await load(input.paymentId);
+      await allowed(actor, "results", record);
+      return structuredClone(record.results);
+    },
+    async clientSecret(input, actor) {
+      const record = await load(input.paymentId);
+      await allowed(actor, "client-secret", record);
+      if (!record.providerId || paymentTerminal(record.status))
+        return null;
+      const observed = await provider.getPayment(record.providerId);
+      verifyPayment(record, observed);
+      try {
+        return await provider.clientSecret(record.providerId);
+      } catch {
+        throw new PaymentsError2("unavailable");
+      }
+    }
+  };
+  return {
+    payments,
+    webhook: {
+      async receive(raw, signature) {
+        const event = await provider.verifyWebhook(raw, signature);
+        if (!event)
+          return { accepted: false, duplicate: false };
+        if (event.accountId !== provider.accountId || event.live !== provider.live)
+          throw new PaymentsError2("provider-mismatch");
+        const record = await load(event.object.paymentId);
+        if ("refundId" in event.object) {
+          const object = event.object;
+          const refund = record.refunds.find((item) => item.refundId === object.refundId);
+          if (!refund)
+            throw new PaymentsError2("provider-mismatch");
+          verifyRefund(record, refund, object);
+        } else
+          verifyPayment(record, event.object);
+        const time = now();
+        const eventKey = await digest([provider.accountId, provider.live, event.eventId]);
+        const inserted = await store.receive({
+          eventKey,
+          eventId: event.eventId,
+          paymentId: record.paymentId,
+          objectId: event.object.id,
+          refundId: "refundId" in event.object ? event.object.refundId : null,
+          accountId: record.accountId,
+          live: record.live,
+          createdAt: time,
+          reconcileAt: time,
+          done: false
+        });
+        return { accepted: true, duplicate: !inserted };
+      }
+    },
+    reconciliation: {
+      run,
+      async drain(limit = 50) {
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200)
+          throw new PaymentsError2("invalid-input");
+        let events = 0;
+        let paymentCount = 0;
+        let unresolved = 0;
+        async function processEvent(event) {
+          try {
+            await mutate(event.paymentId, (record) => {
+              if (event.refundId !== null) {
+                const refund = record.refunds.find((item) => item.refundId === event.refundId);
+                if (!refund || refund.providerId !== null && refund.providerId !== event.objectId)
+                  throw new PaymentsError2("provider-mismatch");
+                if (refund.providerId !== null)
+                  return false;
+                refund.providerId = event.objectId;
+              } else {
+                if (record.providerId !== null && record.providerId !== event.objectId)
+                  throw new PaymentsError2("provider-mismatch");
+                if (record.providerId !== null)
+                  return false;
+                record.providerId = event.objectId;
+              }
+              return true;
+            });
+            if (await run(event.paymentId)) {
+              await store.finishEvent(event.eventKey);
+              events++;
+              return;
+            }
+          } catch {}
+          unresolved++;
+          await store.deferEvent(event.eventKey, now() + delay);
+        }
+        const inbox = await store.inbox(provider.accountId, provider.live, now(), limit);
+        for (const event of inbox)
+          await processEvent(event);
+        const due = await store.due(provider.accountId, provider.live, now(), limit);
+        for (const record of due) {
+          try {
+            if (!await run(record.paymentId))
+              unresolved++;
+          } catch {
+            unresolved++;
+          }
+          paymentCount++;
+        }
+        const [nextPayment] = await store.due(provider.accountId, provider.live, Number.MAX_SAFE_INTEGER - 1, 1);
+        const [nextEvent] = await store.inbox(provider.accountId, provider.live, Number.MAX_SAFE_INTEGER, 1);
+        const next = [nextPayment?.reconcileAt, nextEvent?.reconcileAt].filter((time) => time !== undefined);
+        return {
+          payments: paymentCount,
+          events,
+          unresolved,
+          nextRunAt: next.length ? Math.min(...next) : null
+        };
+      }
+    }
+  };
+}
+
+export { createPayments2 };

package/dist/index-qtpqn1xv.js

@@ -0,0 +1,18 @@
+// src/contracts.ts
+class PaymentsError2 extends Error {
+  code;
+  constructor(code) {
+    super(`Payments: ${code}`);
+    this.code = code;
+    this.name = "PaymentsError";
+  }
+}
+
+class RefundNotCreatedError2 extends Error {
+  constructor() {
+    super("Payments: refund-not-created");
+    this.name = "RefundNotCreatedError";
+  }
+}
+
+export { PaymentsError2, RefundNotCreatedError2 };

package/dist/index-w0b3sn1n.js

@@ -0,0 +1,76 @@
+// src/drizzle/sqlite.ts
+import { and, eq, lte } from "drizzle-orm";
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var payments = sqliteTable("lenso_payments", {
+  paymentId: text("payment_id").primaryKey(),
+  orderKey: text("order_key").notNull().unique(),
+  accountId: text("account_id").notNull(),
+  live: integer("live").notNull(),
+  revision: integer("revision").notNull(),
+  reconcileAt: integer("reconcile_at").notNull(),
+  data: text("data", { mode: "json" }).$type().notNull()
+}, (t) => [index("lenso_payments_due_idx").on(t.accountId, t.live, t.reconcileAt, t.paymentId)]);
+var inboxTable = sqliteTable("lenso_payment_events", {
+  eventKey: text("event_key").primaryKey(),
+  eventId: text("event_id").notNull(),
+  paymentId: text("payment_id").notNull(),
+  objectId: text("object_id").notNull(),
+  refundId: text("refund_id"),
+  accountId: text("account_id").notNull(),
+  live: integer("live").notNull(),
+  createdAt: integer("created_at").notNull(),
+  reconcileAt: integer("reconcile_at").notNull(),
+  done: integer("done").notNull()
+}, (t) => [
+  index("lenso_payment_events_due_idx").on(t.accountId, t.live, t.done, t.reconcileAt, t.eventKey)
+]);
+var copy = (value) => structuredClone(value);
+function sqlitePaymentsStore2(db) {
+  return {
+    async insert(r) {
+      return (await db.insert(payments).values({
+        paymentId: r.paymentId,
+        orderKey: r.orderKey,
+        accountId: r.accountId,
+        live: +r.live,
+        revision: r.revision,
+        reconcileAt: r.reconcileAt,
+        data: copy(r)
+      }).onConflictDoNothing().returning().all()).length > 0;
+    },
+    async get(id) {
+      const [r] = await db.select().from(payments).where(eq(payments.paymentId, id)).limit(1).all();
+      return r ? copy(r.data) : null;
+    },
+    async getByOrder(key) {
+      const [r] = await db.select().from(payments).where(eq(payments.orderKey, key)).limit(1).all();
+      return r ? copy(r.data) : null;
+    },
+    async compareAndSet(r, revision) {
+      if (r.revision !== revision + 1)
+        return false;
+      return (await db.update(payments).set({
+        revision: r.revision,
+        reconcileAt: r.reconcileAt,
+        data: copy(r)
+      }).where(and(eq(payments.paymentId, r.paymentId), eq(payments.revision, revision), eq(payments.orderKey, r.orderKey), eq(payments.accountId, r.accountId), eq(payments.live, +r.live))).returning().all()).length > 0;
+    },
+    async due(accountId, live, now, limit) {
+      return (await db.select().from(payments).where(and(eq(payments.accountId, accountId), eq(payments.live, +live), lte(payments.reconcileAt, now))).orderBy(payments.reconcileAt, payments.paymentId).limit(Math.max(0, limit)).all()).map((r) => copy(r.data));
+    },
+    async receive(e) {
+      return (await db.insert(inboxTable).values({ ...copy(e), live: +e.live, done: +e.done }).onConflictDoNothing().returning().all()).length > 0;
+    },
+    async inbox(accountId, live, now, limit) {
+      return (await db.select().from(inboxTable).where(and(eq(inboxTable.accountId, accountId), eq(inboxTable.live, +live), eq(inboxTable.done, 0), lte(inboxTable.reconcileAt, now))).orderBy(inboxTable.reconcileAt, inboxTable.eventKey).limit(Math.max(0, limit)).all()).map((r) => ({ ...r, live: !!r.live, done: !!r.done }));
+    },
+    async finishEvent(eventKey) {
+      await db.update(inboxTable).set({ done: 1 }).where(eq(inboxTable.eventKey, eventKey));
+    },
+    async deferEvent(eventKey, reconcileAt) {
+      await db.update(inboxTable).set({ reconcileAt }).where(eq(inboxTable.eventKey, eventKey));
+    }
+  };
+}
+
+export { sqlitePaymentsStore2 };

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+import { type CreatePayment, type CreateRefund, type PaymentResult, type PaymentView, type PaymentsAuthorization, type PaymentsProvider, type PaymentsStore } from "./contracts";
+export * from "./contracts";
+export interface Payments<A> {
+    create(input: CreatePayment, actor: A): Promise<PaymentView>;
+    get(input: {
+        paymentId: string;
+    }, actor: A): Promise<PaymentView>;
+    refund(input: CreateRefund, actor: A): Promise<PaymentView>;
+    results(input: {
+        paymentId: string;
+    }, actor: A): Promise<readonly PaymentResult[]>;
+    /** Sensitive capability for the authenticated payer, excluded from ordinary status results. */
+    clientSecret(input: {
+        paymentId: string;
+    }, actor: A): Promise<string | null>;
+}
+export interface PaymentsRuntime<A> {
+    readonly payments: Payments<A>;
+    readonly webhook: {
+        receive(raw: Uint8Array, signature: string): Promise<{
+            accepted: boolean;
+            duplicate: boolean;
+        }>;
+    };
+    /** Trusted worker capability, not a user-facing or Manage operation. */
+    readonly reconciliation: {
+        run(paymentId: string): Promise<boolean>;
+        drain(limit?: number): Promise<{
+            payments: number;
+            events: number;
+            unresolved: number;
+            nextRunAt: number | null;
+        }>;
+    };
+}
+export declare function createPayments<A>(options: {
+    store: PaymentsStore;
+    provider: PaymentsProvider;
+    authorize: PaymentsAuthorization<A>;
+    clock?: () => number;
+    leaseMs?: number;
+    reconcileDelayMs?: number;
+    maxRefunds?: number;
+}): PaymentsRuntime<A>;

package/dist/index.js

@@ -0,0 +1,12 @@
+import {
+  createPayments2
+} from "./index-bzm562dq.js";
+import {
+  PaymentsError2,
+  RefundNotCreatedError2
+} from "./index-qtpqn1xv.js";
+export {
+  PaymentsError2 as PaymentsError,
+  RefundNotCreatedError2 as RefundNotCreatedError,
+  createPayments2 as createPayments
+};

package/dist/manage.d.ts

@@ -0,0 +1,54 @@
+import { type Plugin } from "@lenso/core/plugin";
+import { z } from "zod";
+import type { PaymentsRuntime } from "./index";
+/** Explicit opt-in, read-only. The entry binding supplies an Auth-produced actor, not input JSON. */
+export declare function createPaymentsManage<A>(options: {
+    id: string;
+    payments: Plugin<PaymentsRuntime<A>>;
+}): {
+    plugin: Plugin<{
+        status(input: {
+            paymentId: string;
+        }, invocation: {
+            actor: A;
+        }): Promise<import("./contracts").PaymentView>;
+    }>;
+    operations: (import("@lenso/engine/operations").Operation<{
+        actor: A;
+    }> & {
+        readonly plugin: Plugin<{
+            status(input: {
+                paymentId: string;
+            }, invocation: {
+                actor: A;
+            }): Promise<import("./contracts").PaymentView>;
+        }>;
+        readonly method: "status";
+        readonly input: z.ZodObject<{
+            paymentId: z.ZodString;
+        }, z.core.$strict>;
+        readonly context: true;
+    })[];
+    manage: import("@lenso/manage").Manage<Plugin<{
+        status(input: {
+            paymentId: string;
+        }, invocation: {
+            actor: A;
+        }): Promise<import("./contracts").PaymentView>;
+    }>, (import("@lenso/engine/operations").Operation<{
+        actor: A;
+    }> & {
+        readonly plugin: Plugin<{
+            status(input: {
+                paymentId: string;
+            }, invocation: {
+                actor: A;
+            }): Promise<import("./contracts").PaymentView>;
+        }>;
+        readonly method: "status";
+        readonly input: z.ZodObject<{
+            paymentId: z.ZodString;
+        }, z.core.$strict>;
+        readonly context: true;
+    })[]>;
+};