@routedock/routedock 0.1.2 → 0.3.0

package/dist/schema.js

@@ -0,0 +1,399 @@
+// src/schemas/routedock.schema.json
+var routedock_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://routedock.xyz/schemas/routedock.schema.json",
+  title: "RouteDock Manifest",
+  description: "Discovery manifest served at /.well-known/routedock.json on every RouteDock provider endpoint",
+  type: "object",
+  required: [
+    "routedock",
+    "name",
+    "description",
+    "modes",
+    "network",
+    "asset",
+    "asset_contract",
+    "payee",
+    "pricing",
+    "endpoints",
+    "tags"
+  ],
+  additionalProperties: false,
+  properties: {
+    routedock: {
+      type: "string",
+      pattern: "^[0-9]+\\.[0-9]+$",
+      description: "Manifest schema version, e.g. '1.0', '1.1', '2.0'."
+    },
+    min_client_version: {
+      type: "string",
+      pattern: "^[0-9]+\\.[0-9]+$",
+      description: "Minimum SDK client version (major.minor) required to use this manifest. Clients below this version must refuse to pay."
+    },
+    deprecated_modes: {
+      type: "array",
+      items: {
+        $ref: "#/definitions/PaymentMode"
+      },
+      uniqueItems: true,
+      description: "Payment modes still listed in 'modes' for backwards compatibility but deprecated for new integrations."
+    },
+    sunset_at: {
+      type: "string",
+      format: "date-time",
+      description: "ISO 8601 timestamp after which this manifest version is no longer supported by the provider."
+    },
+    name: {
+      type: "string",
+      minLength: 1,
+      maxLength: 120,
+      description: "Human-readable provider name"
+    },
+    description: {
+      type: "string",
+      minLength: 1,
+      maxLength: 500,
+      description: "Human-readable description of the provider's data or service"
+    },
+    modes: {
+      type: "array",
+      minItems: 1,
+      uniqueItems: true,
+      items: {
+        $ref: "#/definitions/PaymentMode"
+      },
+      description: "Payment modes supported by this provider"
+    },
+    network: {
+      type: "string",
+      enum: ["testnet", "mainnet"],
+      description: "Stellar network this provider operates on"
+    },
+    asset: {
+      type: "string",
+      description: "Asset ticker symbol (e.g. 'USDC')"
+    },
+    asset_contract: {
+      type: "string",
+      description: "Stellar Asset Contract (SAC) address for the payment asset"
+    },
+    assets: {
+      type: "array",
+      minItems: 1,
+      items: {
+        $ref: "#/definitions/AssetConfig"
+      },
+      description: "Payment assets accepted by this provider. Each asset can be scoped to specific modes and endpoints. When present, assets[0] must match the root-level asset and asset_contract."
+    },
+    payee: {
+      type: "string",
+      description: "Stellar address (G...) that receives payments"
+    },
+    pricing: {
+      type: "object",
+      description: "Pricing configuration per supported payment mode",
+      additionalProperties: false,
+      properties: {
+        x402: {
+          $ref: "#/definitions/PricingConfig"
+        },
+        "mpp-charge": {
+          $ref: "#/definitions/PricingConfig"
+        },
+        "mpp-session": {
+          $ref: "#/definitions/SessionPricingConfig"
+        },
+        "mpp-session-ws": {
+          $ref: "#/definitions/SessionPricingConfig",
+          description: "WebSocket transport variant of mpp-session: channel opened and first voucher negotiated over HTTP, then the connection upgrades to WebSocket for push-based streaming."
+        }
+      },
+      minProperties: 1
+    },
+    endpoints: {
+      type: "object",
+      description: "Map of endpoint name to endpoint descriptors",
+      additionalProperties: {
+        $ref: "#/definitions/EndpointDescriptor"
+      },
+      minProperties: 1
+    },
+    sla: {
+      $ref: "#/definitions/SLAConfig"
+    },
+    tags: {
+      type: "array",
+      items: {
+        type: "string",
+        minLength: 1,
+        maxLength: 64
+      },
+      uniqueItems: true,
+      description: "Capability tags indexed with trigram search in the provider registry"
+    },
+    vault: {
+      $ref: "#/definitions/VaultMode"
+    },
+    nulth_account: {
+      type: "string",
+      description: "Optional Nulth smart account address associated with this provider"
+    },
+    capabilities: {
+      type: "object",
+      description: "Optional protocol features this provider supports",
+      properties: {
+        streaming: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: ["sse", "websocket"]
+          },
+          description: "Supported streaming transports"
+        },
+        webhooks: {
+          type: "boolean",
+          description: "Whether webhook callbacks are supported"
+        },
+        idempotency_keys: {
+          type: "boolean",
+          description: "Whether idempotency keys are supported"
+        },
+        content_types: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "Supported content types for request/response"
+        }
+      },
+      additionalProperties: false
+    },
+    regions: {
+      type: "array",
+      items: {
+        type: "string",
+        minLength: 2,
+        maxLength: 10
+      },
+      uniqueItems: true,
+      description: "IATA airport codes or UN/LOCODE identifiers for regions where this provider has infrastructure (e.g. ['IAD', 'AMS']). Used by agents to select the nearest provider."
+    },
+    latency_hints: {
+      type: "object",
+      additionalProperties: {
+        type: "number",
+        minimum: 0
+      },
+      description: "Provider-declared p50 latency in milliseconds per region code. Keys must be a subset of 'regions'. Example: { 'IAD': 14, 'AMS': 22 }."
+    },
+    signature: {
+      type: "string",
+      description: "Base64 Ed25519 signature (payee keypair) over the SHA-256 hash of this manifest with the signature field omitted. Clients must verify before trusting any routing field."
+    },
+    signature_version: {
+      type: "string",
+      const: "2",
+      description: "Manifest signature format. Version 2 recursively includes every nested manifest field in the signed digest."
+    },
+    categories: {
+      type: "array",
+      items: {
+        type: "string",
+        minLength: 1,
+        maxLength: 128
+      },
+      uniqueItems: true,
+      description: "Optional hierarchical categories from a published taxonomy (e.g. data/price/crypto)"
+    }
+  },
+  definitions: {
+    VaultMode: {
+      type: "string",
+      enum: ["local-key", "agent-vault", "nulth"],
+      description: "Agent vault / custody mode for payments from this provider"
+    },
+    PaymentMode: {
+      type: "string",
+      enum: ["x402", "mpp-charge", "mpp-session", "mpp-session-ws"],
+      description: "A supported RouteDock payment mode"
+    },
+    AssetConfig: {
+      type: "object",
+      description: "Payment asset configuration with optional mode and endpoint scoping",
+      required: ["asset", "asset_contract"],
+      additionalProperties: false,
+      properties: {
+        asset: {
+          type: "string",
+          description: "Asset ticker symbol (e.g. 'USDC' or 'XLM')"
+        },
+        asset_contract: {
+          type: "string",
+          description: "Stellar Asset Contract (SAC) address for the payment asset"
+        },
+        modes: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/PaymentMode"
+          },
+          uniqueItems: true,
+          description: "Optional: restrict this asset to specific payment modes. If omitted, available for all modes."
+        },
+        endpoints: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          uniqueItems: true,
+          description: "Optional: restrict this asset to specific endpoints (by name). If omitted, available for all endpoints."
+        }
+      }
+    },
+    PricingConfig: {
+      type: "object",
+      description: "Per-request pricing for x402 or mpp-charge modes",
+      required: ["amount", "per"],
+      additionalProperties: false,
+      properties: {
+        amount: {
+          type: "string",
+          description: "Cost per request in the payment asset (decimal string, e.g. '0.001')"
+        },
+        per: {
+          type: "string",
+          const: "request",
+          description: "Billing unit \u2014 always 'request' for non-session modes"
+        },
+        facilitator: {
+          type: "string",
+          description: "x402 facilitator URL (required for x402 mode). OpenZeppelin Channels endpoint."
+        },
+        payee: {
+          type: "string",
+          description: "Optional per-mode payee override (Stellar G... address). Directs settlements for this mode to a separate account for treasury separation. Falls back to the top-level 'payee' when omitted."
+        }
+      }
+    },
+    SessionPricingConfig: {
+      type: "object",
+      description: "Per-voucher pricing for mpp-session (one-way-channel) mode",
+      required: ["rate", "per", "channel_factory", "min_deposit", "refund_waiting_period_ledgers"],
+      additionalProperties: false,
+      properties: {
+        rate: {
+          type: "string",
+          description: "Cost per voucher in the payment asset (decimal string, e.g. '0.0001')"
+        },
+        per: {
+          type: "string",
+          const: "voucher",
+          description: "Billing unit \u2014 always 'voucher' for session mode"
+        },
+        channel_factory: {
+          type: "string",
+          description: "Stable Soroban factory address (C...) used to deploy a per-session channel"
+        },
+        min_deposit: {
+          type: "string",
+          description: "Minimum initial deposit to open a channel (decimal string)"
+        },
+        refund_waiting_period_ledgers: {
+          type: "integer",
+          minimum: 1,
+          description: "Ledgers the server has to settle before the funder can reclaim. Default: 17280 (~24h). Do not reduce in production."
+        }
+      }
+    },
+    SLAConfig: {
+      type: "object",
+      description: "Service Level Agreement for the provider",
+      required: ["uptime_30d_percent", "p95_latency_ms"],
+      additionalProperties: false,
+      properties: {
+        uptime_30d_percent: {
+          type: "number",
+          description: "Uptime percentage over the last 30 days"
+        },
+        p95_latency_ms: {
+          type: "number",
+          description: "P95 latency in milliseconds"
+        },
+        maintenance_windows: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["cron", "duration_minutes"],
+            additionalProperties: false,
+            properties: {
+              cron: {
+                type: "string",
+                description: "Cron expression for the maintenance window"
+              },
+              duration_minutes: {
+                type: "number",
+                description: "Duration of the maintenance window in minutes"
+              }
+            }
+          }
+        }
+      }
+    },
+    EndpointDescriptor: {
+      type: "object",
+      description: "Descriptor for a provider endpoint",
+      required: ["method", "path"],
+      additionalProperties: false,
+      properties: {
+        method: {
+          type: "string",
+          description: "HTTP method for the endpoint"
+        },
+        path: {
+          type: "string",
+          description: "Path for the endpoint"
+        },
+        deprecated: {
+          type: "boolean",
+          description: "Whether this endpoint is retained only for backwards compatibility"
+        },
+        sunset_at: {
+          type: "string",
+          format: "date-time",
+          description: "ISO 8601 timestamp after which callers should stop using this endpoint"
+        },
+        headers: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          },
+          description: "Expected request headers"
+        },
+        request_schema: {
+          description: "JSON schema for the request body"
+        },
+        response_schema: {
+          description: "JSON schema for the response body"
+        },
+        rate_limit: {
+          type: "object",
+          required: ["requests", "window_seconds"],
+          additionalProperties: false,
+          properties: {
+            requests: {
+              type: "number"
+            },
+            window_seconds: {
+              type: "number"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/schema.ts
+var schema = routedock_schema_default;
+var schema_default = schema;
+
+export { schema_default as default, schema };

package/dist/sign-AKH67sft.d.cts

@@ -0,0 +1,53 @@
+import { h as RouteDockManifest } from './logger-D8_Q2ytp.cjs';
+
+/**
+ * Ed25519 manifest signing and verification.
+ *
+ * The canonical message is the SHA-256 hash of the manifest JSON with the
+ * `signature` field omitted and object keys sorted recursively at every depth.
+ * Array order and JSON primitive semantics are preserved. The payee Stellar
+ * keypair signs this hash.
+ *
+ * TRUST MODEL: the `payee` field is part of the document being signed, so a
+ * valid signature only proves that whoever signed it controlled the signing
+ * key declared in `payee`. It does NOT, by itself, prove the manifest was
+ * served by that entity — any host serving `/.well-known/routedock.json` can
+ * substitute its own payee and self-sign.
+ *
+ * Verification must therefore be bound to an out-of-band trust anchor. Callers
+ * that already know the expected payee (e.g. the account a provider registered
+ * in the on-chain registry, or a pinned/allowlisted key) MUST pass it as
+ * `expectedPayee` so a substituted document is rejected before any signature
+ * work is trusted.
+ *
+ * Providers call `signManifest` once at startup to embed the signature.
+ */
+
+declare const MANIFEST_SIGNATURE_VERSION: "2";
+/** Produce the canonical SHA-256 digest of the manifest (signature field excluded). */
+declare function manifestDigest(manifest: RouteDockManifest): Buffer;
+/**
+ * Sign a manifest with the payee's Stellar secret key.
+ * Returns a new manifest object with the `signature` field populated.
+ */
+declare function signManifest(manifest: RouteDockManifest, payeeSecretKey: string): RouteDockManifest & {
+    signature_version: typeof MANIFEST_SIGNATURE_VERSION;
+    signature: string;
+};
+/**
+ * Verify the manifest's Ed25519 signature.
+ *
+ * `expectedPayee` binds the manifest to an out-of-band trust anchor: when
+ * provided, the (attacker-controllable) `manifest.payee` must equal it,
+ * otherwise `RouteDockSignatureError` is thrown before signature verification.
+ * Callers that have a registry/pinned payee MUST pass it; omitting it leaves
+ * only self-signed authenticity, which is insufficient for routing trust.
+ *
+ * Throws `RouteDockSignatureError` if the signature is missing, the payee does
+ * not match `expectedPayee`, or the signature is invalid.
+ */
+declare function verifyManifestSignature(manifest: RouteDockManifest & {
+    signature?: string;
+}, expectedPayee?: string): void;
+
+export { manifestDigest as m, signManifest as s, verifyManifestSignature as v };

package/dist/sign-BEq-OsSq.d.ts

@@ -0,0 +1,53 @@
+import { h as RouteDockManifest } from './logger-D8_Q2ytp.js';
+
+/**
+ * Ed25519 manifest signing and verification.
+ *
+ * The canonical message is the SHA-256 hash of the manifest JSON with the
+ * `signature` field omitted and object keys sorted recursively at every depth.
+ * Array order and JSON primitive semantics are preserved. The payee Stellar
+ * keypair signs this hash.
+ *
+ * TRUST MODEL: the `payee` field is part of the document being signed, so a
+ * valid signature only proves that whoever signed it controlled the signing
+ * key declared in `payee`. It does NOT, by itself, prove the manifest was
+ * served by that entity — any host serving `/.well-known/routedock.json` can
+ * substitute its own payee and self-sign.
+ *
+ * Verification must therefore be bound to an out-of-band trust anchor. Callers
+ * that already know the expected payee (e.g. the account a provider registered
+ * in the on-chain registry, or a pinned/allowlisted key) MUST pass it as
+ * `expectedPayee` so a substituted document is rejected before any signature
+ * work is trusted.
+ *
+ * Providers call `signManifest` once at startup to embed the signature.
+ */
+
+declare const MANIFEST_SIGNATURE_VERSION: "2";
+/** Produce the canonical SHA-256 digest of the manifest (signature field excluded). */
+declare function manifestDigest(manifest: RouteDockManifest): Buffer;
+/**
+ * Sign a manifest with the payee's Stellar secret key.
+ * Returns a new manifest object with the `signature` field populated.
+ */
+declare function signManifest(manifest: RouteDockManifest, payeeSecretKey: string): RouteDockManifest & {
+    signature_version: typeof MANIFEST_SIGNATURE_VERSION;
+    signature: string;
+};
+/**
+ * Verify the manifest's Ed25519 signature.
+ *
+ * `expectedPayee` binds the manifest to an out-of-band trust anchor: when
+ * provided, the (attacker-controllable) `manifest.payee` must equal it,
+ * otherwise `RouteDockSignatureError` is thrown before signature verification.
+ * Callers that have a registry/pinned payee MUST pass it; omitting it leaves
+ * only self-signed authenticity, which is insufficient for routing trust.
+ *
+ * Throws `RouteDockSignatureError` if the signature is missing, the payee does
+ * not match `expectedPayee`, or the signature is invalid.
+ */
+declare function verifyManifestSignature(manifest: RouteDockManifest & {
+    signature?: string;
+}, expectedPayee?: string): void;
+
+export { manifestDigest as m, signManifest as s, verifyManifestSignature as v };

package/dist/testing.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+// src/testing/createMockRoutedockMiddleware.ts
+var DEFAULT_TX_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
+var DEFAULT_CHANNEL_ID = "CCK4XOW3YKQUEZFONUTINKMSNW7SNMRQZURME5U3UP7E6WNGK7UHUCAH";
+var DEFAULT_PAYER = "GAIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCF6M";
+function format7(scaled) {
+  return (Number(scaled) / 1e7).toFixed(7);
+}
+function toScaled(decimal) {
+  const [whole, frac = ""] = decimal.split(".");
+  const fracPadded = (frac + "0000000").slice(0, 7);
+  return BigInt(whole + fracPadded);
+}
+async function runMockSettlement(opts) {
+  const mode = opts.mode ?? "x402";
+  if ((opts.payment ?? "auto-pass") === "auto-fail") return null;
+  const s = opts.synthetic ?? {};
+  const txHash = s.txHash ?? DEFAULT_TX_HASH;
+  const payer = s.payer === void 0 ? DEFAULT_PAYER : s.payer;
+  if (mode === "mpp-session" || mode === "mpp-session-ws") {
+    const channelId = s.channelId ?? DEFAULT_CHANNEL_ID;
+    const rate = toScaled(s.rate ?? "0.0001");
+    const count = s.voucherCount ?? 3;
+    if (opts.onSessionOpen) await opts.onSessionOpen(channelId, payer);
+    const vouchers = [];
+    for (let i = 1; i <= count; i++) {
+      const cumulativeAmount = format7(rate * BigInt(i));
+      vouchers.push({ index: i, cumulativeAmount });
+      if (opts.onVoucher) await opts.onVoucher(channelId, i, cumulativeAmount, "0000000000000000000000000000000000000000000000000000000000000000");
+    }
+    const totalPaid = format7(rate * BigInt(count));
+    if (opts.onSettled) await opts.onSettled(txHash, totalPaid, mode, payer);
+    return { mode, txHash, amount: totalPaid, channelId, vouchers };
+  }
+  const amount = s.amount ?? "0.001";
+  if (opts.onSettled) await opts.onSettled(txHash, amount, mode, payer);
+  return { mode, txHash, amount };
+}
+function createMockRoutedockMiddleware(opts = {}) {
+  const payment = opts.payment ?? "auto-pass";
+  const failStatus = opts.failStatus ?? 402;
+  return (req, res, next) => {
+    if (payment === "auto-fail") {
+      res.status(failStatus).json({
+        error: "payment required",
+        detail: "mock routedock middleware: payment=auto-fail"
+      });
+      return;
+    }
+    void runMockSettlement(opts).then((record) => {
+      if (record) req.routedock = record;
+      next();
+    }).catch((err) => next(err));
+  };
+}
+
+exports.createMockRoutedockMiddleware = createMockRoutedockMiddleware;
+exports.runMockSettlement = runMockSettlement;

package/dist/testing.d.cts

@@ -0,0 +1,114 @@
+import { RequestHandler } from 'express';
+import { P as PaymentMode } from './logger-D8_Q2ytp.cjs';
+import { R as RouteDockMiddlewareOptions } from './routedockMiddleware-DlyLrxp7.cjs';
+import 'mppx';
+import './MppSessionHandler-1EL8QBAn.cjs';
+
+/**
+ * Loosen a production callback's return type so a plain sync test spy works,
+ * while keeping its exact parameter list (the real adapter's signature).
+ */
+type TestCallback<F> = F extends (...args: infer A) => unknown ? (...args: A) => void | Promise<void> : never;
+/**
+ * Provider settlement callbacks under test. Same parameter list as the real
+ * `RouteDockMiddlewareOptions` callbacks — including `payer` — but they accept
+ * sync or async fns so a plain test spy works without wrapping it in a Promise.
+ */
+interface MockRoutedockCallbacks {
+    /** Called after each (synthetic) on-chain settlement. */
+    onSettled?: TestCallback<NonNullable<RouteDockMiddlewareOptions['onSettled']>>;
+    /** Called once when a synthetic session is opened (first voucher). */
+    onSessionOpen?: TestCallback<NonNullable<RouteDockMiddlewareOptions['onSessionOpen']>>;
+    /** Called for each synthetic voucher in a session (1-based index). */
+    onVoucher?: TestCallback<NonNullable<RouteDockMiddlewareOptions['onVoucher']>>;
+}
+/** Synthetic settlement values handed to the callbacks. All optional — sensible defaults per mode. */
+interface SyntheticPayment {
+    /** On-chain tx hash passed to onSettled. Default: a fixed 64-hex string. */
+    txHash?: string;
+    /** Settled amount (x402 / mpp-charge) passed to onSettled. Default: '0.001'. */
+    amount?: string;
+    /** Channel address (session modes) passed to onSessionOpen. Default: a fixed C... address. */
+    channelId?: string;
+    /** Per-voucher rate (session modes), in decimal string. Default: '0.0001'. */
+    rate?: string;
+    /** Number of vouchers to emit before close (session modes). Default: 3. */
+    voucherCount?: number;
+    /**
+     * Payer passed to onSettled (4th arg) and onSessionOpen (2nd arg). Default: a
+     * valid Stellar G... account. Pass `null` to exercise the address-unavailable
+     * path; `null` is passed through untouched (an explicit null is not replaced
+     * by the default).
+     */
+    payer?: string | null;
+}
+interface MockRoutedockOptions extends MockRoutedockCallbacks {
+    /** Payment mode the synthetic payment uses. Default: 'x402'. */
+    mode?: PaymentMode;
+    /**
+     * 'auto-pass' (default): synthesize a successful settlement, invoke the
+     * configured callbacks with synthetic data, then call the route handler.
+     * 'auto-fail': respond with `failStatus` and skip both callbacks and handler.
+     */
+    payment?: 'auto-pass' | 'auto-fail';
+    /** Override the synthetic data handed to callbacks. */
+    synthetic?: SyntheticPayment;
+    /** HTTP status used on 'auto-fail'. Default: 402. */
+    failStatus?: number;
+}
+/** Synthetic settlement record attached to `req.routedock` for assertions. */
+interface MockSettlementRecord {
+    mode: PaymentMode;
+    txHash: string;
+    amount: string;
+    channelId?: string;
+    vouchers?: Array<{
+        index: number;
+        cumulativeAmount: string;
+    }>;
+}
+/**
+ * Drive a provider's settlement callbacks with synthetic data, with no Express
+ * request involved. Useful for unit-testing an `onSettled` (e.g. a Supabase
+ * write) in complete isolation. Returns the synthetic settlement record.
+ *
+ * Honors `payment: 'auto-fail'` by invoking no callbacks and returning null.
+ */
+declare function runMockSettlement(opts: MockRoutedockOptions): Promise<MockSettlementRecord | null>;
+/**
+ * Express middleware that mocks RouteDock payment verification — the testing
+ * counterpart to `routedock()`. Drop it in front of a route to drive that
+ * route's settlement callbacks with synthetic data, without any on-chain
+ * settlement, facilitator, or wallet. Think `msw` for RouteDock providers.
+ *
+ * On `payment: 'auto-pass'` (default) it invokes the configured callbacks with
+ * synthetic data and then calls the next handler (your route). On
+ * `payment: 'auto-fail'` it responds with `failStatus` (402 by default) and
+ * skips both the callbacks and the route handler — exactly as a real payment
+ * rejection would.
+ *
+ * The synthetic settlement is attached to `req.routedock` for assertions.
+ *
+ * @example
+ * ```ts
+ * import express from 'express'
+ * import request from 'supertest'
+ * import { createMockRoutedockMiddleware } from '@routedock/routedock/testing'
+ *
+ * const onSettled = vi.fn()
+ * const app = express()
+ * app.use('/price', createMockRoutedockMiddleware({ mode: 'x402', payment: 'auto-pass', onSettled }))
+ * app.get('/price', (_req, res) => res.json({ price: '42' }))
+ *
+ * await request(app).get('/price').expect(200)
+ * expect(onSettled).toHaveBeenCalledWith(
+ *   expect.any(String),
+ *   '0.001',
+ *   'x402',
+ *   expect.any(String), // payer
+ * )
+ * ```
+ */
+declare function createMockRoutedockMiddleware(opts?: MockRoutedockOptions): RequestHandler;
+
+export { type MockRoutedockCallbacks, type MockRoutedockOptions, type MockSettlementRecord, type SyntheticPayment, createMockRoutedockMiddleware, runMockSettlement };