payweave 0.0.0

package/dist/index.js

@@ -0,0 +1,3677 @@
+import './chunk-CR63JAAS.js';
+import { PaystackClient } from './chunk-E633MKVX.js';
+export { PaystackClient } from './chunk-E633MKVX.js';
+import { FlutterwaveClient } from './chunk-FBPOCXRZ.js';
+export { FlutterwaveClient } from './chunk-FBPOCXRZ.js';
+import { defineProvider, STRIPE_BASE_URL, stripeProviderConfigSchema, readHeader, inferEnvironment, HttpClient, STRIPE_API_VERSION, resolvePayweaveConfig, SDK_VERSION, oauthClientCredentials, bearer } from './chunk-IUVGM3K7.js';
+export { SDK_VERSION as VERSION } from './chunk-IUVGM3K7.js';
+export { feature, plan } from './chunk-535Q3GUN.js';
+import { createPaystackUnified, createFlutterwaveUnified } from './chunk-JD4OZHRI.js';
+import './chunk-TWZK62TZ.js';
+import { verifyStripe, subscribe, constructEvent, resolvePlanGroup, BILLING_CAPABLE_PROVIDERS } from './chunk-CGQ73I4I.js';
+import './chunk-4R5OGOCC.js';
+import { verifyPaystack } from './chunk-NXQBP35U.js';
+import { verifyFlutterwaveV4, verifyFlutterwaveV3 } from './chunk-CJEYDHY6.js';
+import { toUnifiedEventType, UNIFIED_CAPABILITY_MATRIX, assertUnifiedCapability } from './chunk-67NRYGRC.js';
+import { PayweaveConfigError, PayweaveValidationError, PayweaveWebhookVerificationError, PayweaveProviderError, PayweaveError } from './chunk-HTRGMZFH.js';
+export { PayweaveAuthError, PayweaveConfigError, PayweaveError, PayweaveNetworkError, PayweaveNotFoundError, PayweaveProviderError, PayweaveRateLimitError, PayweaveValidationError, PayweaveWebhookVerificationError } from './chunk-HTRGMZFH.js';
+import { z } from 'zod';
+import { createHash } from 'crypto';
+
+// src/webhooks/dispatch.ts
+var SIGNATURE_HEADER_TABLE = [
+  { headerName: "x-paystack-signature", provider: "paystack" },
+  { headerName: "verif-hash", provider: "flutterwave", flutterwaveVersion: "v3" },
+  { headerName: "flutterwave-signature", provider: "flutterwave", flutterwaveVersion: "v4" },
+  { headerName: "stripe-signature", provider: "stripe" }
+];
+var KNOWN_HEADER_NAMES = SIGNATURE_HEADER_TABLE.map((spec) => spec.headerName).join(", ");
+function detectSignatureHeader(headers) {
+  const found = [];
+  for (const spec of SIGNATURE_HEADER_TABLE) {
+    const value = readHeader(headers, spec.headerName);
+    if (value !== void 0) found.push({ spec, value });
+  }
+  const [only, ...rest] = found;
+  if (only === void 0) {
+    throw new PayweaveWebhookVerificationError(
+      `No known webhook signature header on the request \u2014 expected exactly one of: ${KNOWN_HEADER_NAMES}.`,
+      { provider: "unknown", isRetryable: false }
+    );
+  }
+  if (rest.length > 0) {
+    const names = found.map((f) => f.spec.headerName).join(", ");
+    throw new PayweaveWebhookVerificationError(
+      `Multiple known webhook signature headers on one request (${names}) \u2014 ambiguous and likely forged; rejecting.`,
+      { provider: "unknown", isRetryable: false }
+    );
+  }
+  return only;
+}
+function requireConfigured(resolved, spec) {
+  const entry = resolved.providerConfigs[spec.provider];
+  if (entry === void 0) {
+    throw new PayweaveWebhookVerificationError(
+      `Received a "${spec.headerName}" header but ${spec.provider} is not configured on this client (configured: ${resolved.providers.join(", ")}) \u2014 failing closed.`,
+      { provider: spec.provider, isRetryable: false }
+    );
+  }
+  if (spec.provider === "flutterwave") {
+    const configuredVersion = entry.version === "v4" ? "v4" : "v3";
+    if (spec.flutterwaveVersion !== configuredVersion) {
+      throw new PayweaveWebhookVerificationError(
+        `Received the Flutterwave ${spec.flutterwaveVersion} signature header ("${spec.headerName}") but this client is configured for Flutterwave ${configuredVersion} \u2014 a client verifies webhooks only with its own version's scheme; failing closed.`,
+        { provider: "flutterwave", isRetryable: false }
+      );
+    }
+  }
+  return entry;
+}
+function verifyDetected(entry, spec, input) {
+  if (spec.provider === "paystack") {
+    const secret = entry.webhookSecret ?? entry.secretKey;
+    if (!secret) {
+      throw new PayweaveConfigError("Missing Paystack secret key for webhook verification.", {
+        provider: "paystack"
+      });
+    }
+    return verifyPaystack(input.rawBody, readHeader(input.headers, spec.headerName), secret);
+  }
+  if (spec.provider === "flutterwave") {
+    if (!entry.webhookSecret) {
+      throw new PayweaveConfigError(
+        "Flutterwave webhook verification requires `webhookSecret` (the dashboard secret hash).",
+        { provider: "flutterwave" }
+      );
+    }
+    if (spec.flutterwaveVersion === "v4") {
+      return verifyFlutterwaveV4(
+        input.rawBody,
+        readHeader(input.headers, spec.headerName),
+        entry.webhookSecret
+      );
+    }
+    return verifyFlutterwaveV3(readHeader(input.headers, spec.headerName), entry.webhookSecret);
+  }
+  if (!entry.webhookSecret) {
+    throw new PayweaveConfigError(
+      "Stripe webhook verification requires `webhookSecret` (the endpoint signing secret, `whsec_*`).",
+      { provider: "stripe" }
+    );
+  }
+  return verifyStripe(input.rawBody, readHeader(input.headers, spec.headerName), entry.webhookSecret);
+}
+function createWebhookDispatch(resolved, billing) {
+  function dispatch(headers) {
+    const { spec } = detectSignatureHeader(headers);
+    return { spec, entry: requireConfigured(resolved, spec) };
+  }
+  function verify(input) {
+    const { spec, entry } = dispatch(input.headers);
+    return verifyDetected(entry, spec, input);
+  }
+  return {
+    verify,
+    verifyOrThrow(input) {
+      const { spec, entry } = dispatch(input.headers);
+      if (!verifyDetected(entry, spec, input)) {
+        throw new PayweaveWebhookVerificationError("Webhook signature verification failed.", {
+          provider: spec.provider,
+          isRetryable: false
+        });
+      }
+    },
+    constructEvent(input) {
+      const { spec, entry } = dispatch(input.headers);
+      const version = spec.provider === "flutterwave" ? entry.version === "v4" ? "v4" : "v3" : void 0;
+      return constructEvent({
+        rawBody: input.rawBody,
+        headers: input.headers,
+        provider: spec.provider,
+        version,
+        verify: (i) => verifyDetected(entry, spec, i),
+        logger: entry.logger,
+        billing
+      });
+    }
+  };
+}
+
+// src/stripe/form-encoding.ts
+var STRIPE_FORM_CONTENT_TYPE = "application/x-www-form-urlencoded";
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function describe(value) {
+  if (typeof value === "number") return `non-finite number ${String(value)}`;
+  if (value instanceof Date) return "Date (pass a Unix timestamp in seconds instead)";
+  return `unsupported value of type ${typeof value}`;
+}
+function unsupported(path, value) {
+  return new PayweaveValidationError(
+    `Cannot form-encode "${path}" for Stripe: ${describe(value)}.`,
+    { provider: "stripe" }
+  );
+}
+function appendPairs(pairs, key, value) {
+  if (value === void 0 || value === null) return;
+  switch (typeof value) {
+    case "string":
+      pairs.push(`${key}=${encodeURIComponent(value)}`);
+      return;
+    case "boolean":
+      pairs.push(`${key}=${value ? "true" : "false"}`);
+      return;
+    case "number":
+      if (!Number.isFinite(value)) throw unsupported(key, value);
+      pairs.push(`${key}=${encodeURIComponent(String(value))}`);
+      return;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i += 1) {
+      appendPairs(pairs, `${key}[${i}]`, value[i]);
+    }
+    return;
+  }
+  if (isPlainObject(value)) {
+    for (const [childKey, childValue] of Object.entries(value)) {
+      appendPairs(pairs, `${key}[${encodeURIComponent(childKey)}]`, childValue);
+    }
+    return;
+  }
+  throw unsupported(key, value);
+}
+function encodeStripeForm(body) {
+  if (!isPlainObject(body)) {
+    throw new PayweaveValidationError(
+      "Stripe request bodies must be plain objects (validated by the request schema before encoding).",
+      { provider: "stripe" }
+    );
+  }
+  const pairs = [];
+  for (const [key, value] of Object.entries(body)) {
+    appendPairs(pairs, encodeURIComponent(key), value);
+  }
+  return { contentType: STRIPE_FORM_CONTENT_TYPE, body: pairs.join("&") };
+}
+
+// src/stripe/http-options.ts
+function stripeAuth(opts) {
+  const version = opts.apiVersion ?? STRIPE_API_VERSION;
+  return {
+    async applyAuth(init) {
+      init.headers.set("Authorization", `Bearer ${opts.secretKey}`);
+      init.headers.set("Stripe-Version", version);
+      if (opts.accountId !== void 0) {
+        init.headers.set("Stripe-Account", opts.accountId);
+      }
+    }
+  };
+}
+function stripeHttpOptions(resolved) {
+  if (resolved.provider !== "stripe") {
+    throw new PayweaveConfigError(
+      `stripeHttpOptions received a "${resolved.provider}" config \u2014 expected provider "stripe".`,
+      { provider: "stripe" }
+    );
+  }
+  if (resolved.secretKey === void 0) {
+    throw new PayweaveConfigError("Stripe config resolved without a secretKey.", {
+      provider: "stripe"
+    });
+  }
+  return {
+    baseUrl: resolved.baseUrl,
+    provider: "stripe",
+    auth: stripeAuth({
+      secretKey: resolved.secretKey,
+      apiVersion: resolved.apiVersion,
+      accountId: resolved.accountId
+    }),
+    bodyEncoder: encodeStripeForm,
+    timeoutMs: resolved.timeoutMs,
+    maxRetries: resolved.maxRetries,
+    fetch: resolved.fetch,
+    logger: resolved.logger
+  };
+}
+function parseRequest(schema, input) {
+  try {
+    return schema.parse(input);
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      const detail = err.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+      throw new PayweaveValidationError(`stripe request validation failed \u2014 ${detail}`, {
+        provider: "stripe",
+        cause: err
+      });
+    }
+    throw err;
+  }
+}
+var metadataSchema = z.record(
+  z.string(),
+  z.union([z.string(), z.number(), z.boolean()])
+);
+var createdRange = z.object({
+  gt: z.number().int().optional(),
+  gte: z.number().int().optional(),
+  lt: z.number().int().optional(),
+  lte: z.number().int().optional()
+});
+var listCursorFields = {
+  /** Page size, 1–100 (Stripe default 10). */
+  limit: z.number().int().min(1).max(100).optional(),
+  /** Cursor: object id — return items AFTER this id (next page). */
+  starting_after: z.string().optional(),
+  /** Cursor: object id — return items BEFORE this id (previous page). */
+  ending_before: z.string().optional()
+};
+var stripeList = (item) => z.looseObject({
+  object: z.string(),
+  data: z.array(item),
+  has_more: z.boolean(),
+  url: z.string().optional()
+});
+async function* iterateStripeList(fetchPage) {
+  let startingAfter;
+  for (; ; ) {
+    const page = await fetchPage(startingAfter);
+    for (const item of page.data) yield item;
+    const last = page.data[page.data.length - 1];
+    if (!page.has_more || last === void 0) return;
+    startingAfter = last.id;
+  }
+}
+function flattenQuery(query) {
+  const out = {};
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      for (const [childKey, childValue] of Object.entries(value)) {
+        if (childValue === void 0 || childValue === null) continue;
+        out[`${key}[${childKey}]`] = childValue;
+      }
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function requireId(value, what) {
+  return parseRequest(z.string().min(1, `${what} id must be a non-empty string`), value);
+}
+var stripeSearchResult = (item) => z.looseObject({
+  object: z.string(),
+  data: z.array(item),
+  has_more: z.boolean(),
+  next_page: z.string().nullable().optional(),
+  url: z.string().optional(),
+  total_count: z.number().optional()
+});
+async function* iterateStripeSearch(fetchPage) {
+  let page;
+  for (; ; ) {
+    const result = await fetchPage(page);
+    for (const item of result.data) yield item;
+    if (!result.has_more || result.next_page == null) return;
+    page = result.next_page;
+  }
+}
+var productData = z.object({
+  /** Product name — required by Stripe when creating a product inline. */
+  name: z.string(),
+  description: z.string().optional(),
+  images: z.array(z.string()).optional(),
+  metadata: metadataSchema.optional(),
+  tax_code: z.string().optional()
+});
+var recurring = z.object({
+  interval: z.enum(["day", "week", "month", "year"]),
+  interval_count: z.number().int().optional()
+});
+var priceData = z.object({
+  /** Three-letter ISO currency code, lowercase (e.g. `usd`). */
+  currency: z.string(),
+  /** Amount in the smallest currency unit (minor units) — integer, unchanged. */
+  unit_amount: z.number().int().nonnegative().optional(),
+  /** Decimal string alternative to `unit_amount` (e.g. fractional cents). */
+  unit_amount_decimal: z.string().optional(),
+  /** Existing Product id (`prod_*`) the price belongs to. */
+  product: z.string().optional(),
+  /** Inline Product creation (alternative to `product`). */
+  product_data: productData.optional(),
+  /** Present only for `subscription` mode line items. */
+  recurring: recurring.optional(),
+  tax_behavior: z.enum(["inclusive", "exclusive", "unspecified"]).optional()
+});
+var lineItemInput = z.object({
+  /** Saved Price (or Plan) id (`price_*`). Alternative to `price_data`. */
+  price: z.string().optional(),
+  /** Inline price definition. Alternative to `price`. */
+  price_data: priceData.optional(),
+  quantity: z.number().int().optional(),
+  /** Let the customer adjust the quantity in Checkout. */
+  adjustable_quantity: z.object({
+    enabled: z.boolean(),
+    minimum: z.number().int().optional(),
+    maximum: z.number().int().optional()
+  }).optional(),
+  /** Tax Rate ids applied to this line item. */
+  tax_rates: z.array(z.string()).optional(),
+  metadata: metadataSchema.optional()
+});
+var paymentIntentData = z.object({
+  capture_method: z.enum(["automatic", "automatic_async", "manual"]).optional(),
+  setup_future_usage: z.enum(["on_session", "off_session"]).optional(),
+  statement_descriptor: z.string().optional(),
+  statement_descriptor_suffix: z.string().optional(),
+  receipt_email: z.string().optional(),
+  metadata: metadataSchema.optional()
+});
+var sessionCreateReq = z.object({
+  /** Session mode — determines what the session sets up. Required. */
+  mode: z.enum(["payment", "setup", "subscription"]),
+  /** Items being purchased. Required for `payment`/`subscription` modes. */
+  line_items: z.array(lineItemInput).optional(),
+  /** Redirect target after a successful session (hosted page). */
+  success_url: z.string().optional(),
+  /** Redirect target when the customer cancels (hosted page). */
+  cancel_url: z.string().optional(),
+  /** Return target for embedded UI modes. */
+  return_url: z.string().optional(),
+  /** Checkout UI surface (see the JSDoc above for version-pinned values). */
+  ui_mode: z.enum(["hosted_page", "embedded_page", "elements"]).optional(),
+  /** Your internal reference for this session (≤200 chars). */
+  client_reference_id: z.string().max(200).optional(),
+  /** Existing Customer id (`cus_*`) to prefill. */
+  customer: z.string().optional(),
+  /** Email to prefill when no `customer` is given (≤800 chars). */
+  customer_email: z.string().max(800).optional(),
+  customer_creation: z.enum(["always", "if_required"]).optional(),
+  /** Three-letter ISO currency code — required in some `setup`-mode cases. */
+  currency: z.string().optional(),
+  /** Payment method types to accept (e.g. `["card"]`). Provider-validated. */
+  payment_method_types: z.array(z.string()).optional(),
+  metadata: metadataSchema.optional(),
+  /** Unix timestamp — 30 minutes to 24 hours after creation. */
+  expires_at: z.number().int().optional(),
+  payment_intent_data: paymentIntentData.optional(),
+  billing_address_collection: z.enum(["auto", "required"]).optional(),
+  allow_promotion_codes: z.boolean().optional()
+});
+var checkoutSession = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  /** `open` | `complete` | `expired` (normalization is the unified layer's job). */
+  status: z.string().nullable().optional(),
+  /** `paid` | `unpaid` | `no_payment_required`. */
+  payment_status: z.string().optional(),
+  mode: z.string().optional(),
+  /** Hosted checkout URL — null once the session is no longer open. */
+  url: z.string().nullable().optional(),
+  client_reference_id: z.string().nullable().optional(),
+  /** Customer id string, or an expanded object — kept unknown. */
+  customer: z.unknown().optional(),
+  customer_email: z.string().nullable().optional(),
+  /** PaymentIntent id string, or an expanded object — kept unknown. */
+  payment_intent: z.unknown().optional(),
+  /** Integer minor units. */
+  amount_subtotal: z.number().nullable().optional(),
+  /** Integer minor units. */
+  amount_total: z.number().nullable().optional(),
+  currency: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.string()).nullable().optional(),
+  success_url: z.string().nullable().optional(),
+  cancel_url: z.string().nullable().optional(),
+  created: z.number().optional(),
+  expires_at: z.number().optional(),
+  livemode: z.boolean().optional()
+});
+var sessionListQuery = z.object({
+  ...listCursorFields,
+  /** Filter by Customer id. */
+  customer: z.string().optional(),
+  /** Filter by customer email (`customer_details[email]`, ≤800 chars). */
+  customer_details: z.object({ email: z.string().max(800) }).optional(),
+  /** Filter by PaymentIntent id. */
+  payment_intent: z.string().optional(),
+  /** Filter by Payment Link id. */
+  payment_link: z.string().optional(),
+  /** Filter by Subscription id. */
+  subscription: z.string().optional(),
+  status: z.enum(["open", "complete", "expired"]).optional(),
+  /** Creation-date window (Unix timestamps). */
+  created: createdRange.optional()
+});
+var sessionLineItem = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  amount_discount: z.number().optional(),
+  amount_subtotal: z.number().optional(),
+  amount_tax: z.number().optional(),
+  amount_total: z.number().optional(),
+  currency: z.string().optional(),
+  description: z.string().nullable().optional(),
+  /** The Price object backing this item — kept loose. */
+  price: z.looseObject({}).nullable().optional(),
+  quantity: z.number().nullable().optional()
+});
+var lineItemsQuery = z.object({ ...listCursorFields });
+
+// src/stripe/resources/checkout-sessions.ts
+var sessionListRes = stripeList(checkoutSession);
+var lineItemListRes = stripeList(sessionLineItem);
+var CheckoutSessions = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Create a Checkout Session. `session.url` is the hosted checkout page to
+   * redirect the customer to. Amounts (`price_data.unit_amount`) are integer
+   * minor units, sent to Stripe unchanged. Pass `idempotencyKey` to make the
+   * POST safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/checkout/sessions/create
+   *
+   * @example
+   * const session = await payweave.stripe.checkout.sessions.create({
+   *   mode: "payment",
+   *   line_items: [{ price: "price_123", quantity: 2 }],
+   *   success_url: "https://example.com/success",
+   *   cancel_url: "https://example.com/cancel",
+   * }, { idempotencyKey: "order-8123-checkout" });
+   * console.log(session.url);
+   */
+  async create(input, opts = {}) {
+    const body = parseRequest(sessionCreateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: "/v1/checkout/sessions",
+      body,
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: checkoutSession
+    });
+  }
+  /**
+   * Retrieve a Checkout Session by id (`cs_*`). A 404 for an unknown id
+   * surfaces as {@link PayweaveNotFoundError}. Note `session.url` is null once
+   * the session is no longer open.
+   *
+   * Docs: https://docs.stripe.com/api/checkout/sessions/retrieve
+   *
+   * @example
+   * const session = await payweave.stripe.checkout.sessions.retrieve("cs_test_123");
+   * if (session.payment_status === "paid") { }
+   */
+  async retrieve(id) {
+    const sessionId = requireId(id, "checkout session");
+    return this.http.request({
+      method: "GET",
+      path: `/v1/checkout/sessions/${encodeURIComponent(sessionId)}`,
+      schema: checkoutSession
+    });
+  }
+  /**
+   * List Checkout Sessions (newest first). Cursor pagination: `limit` +
+   * `starting_after`/`ending_before`; nested filters (`created`,
+   * `customer_details`) become bracket query keys.
+   *
+   * Docs: https://docs.stripe.com/api/checkout/sessions/list
+   *
+   * @example
+   * const page = await payweave.stripe.checkout.sessions.list({ status: "complete", limit: 50 });
+   * console.log(page.data.length, page.has_more);
+   */
+  async list(query = {}) {
+    const q = parseRequest(sessionListQuery, query);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/checkout/sessions",
+      query: flattenQuery(q),
+      schema: sessionListRes
+    });
+  }
+  /**
+   * Async iterator over ALL sessions matching `query`, transparently following
+   * `has_more` with `starting_after = <last id>`.
+   *
+   * Docs: https://docs.stripe.com/api/checkout/sessions/list
+   *
+   * @example
+   * for await (const session of payweave.stripe.checkout.sessions.iterate({ status: "open" })) {
+   *   console.log(session.id);
+   * }
+   */
+  async *iterate(query = {}) {
+    const base = parseRequest(sessionListQuery, query);
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: "/v1/checkout/sessions",
+        query: flattenQuery({ ...base, starting_after: startingAfter }),
+        schema: sessionListRes
+      })
+    );
+  }
+  /**
+   * Expire an OPEN Checkout Session so it can no longer be paid — Stripe
+   * errors when the session is not `open` (surfaced as
+   * {@link PayweaveValidationError} on the 400). Returns the session with
+   * `status: "expired"`.
+   *
+   * Docs: https://docs.stripe.com/api/checkout/sessions/expire
+   *
+   * @example
+   * const expired = await payweave.stripe.checkout.sessions.expire("cs_test_123");
+   * console.log(expired.status); // "expired"
+   */
+  async expire(id) {
+    const sessionId = requireId(id, "checkout session");
+    return this.http.request({
+      method: "POST",
+      path: `/v1/checkout/sessions/${encodeURIComponent(sessionId)}/expire`,
+      schema: checkoutSession
+    });
+  }
+  /**
+   * List a session's line items (cursor-paginated; `amount_*` are integer
+   * minor units).
+   *
+   * Docs: https://docs.stripe.com/api/checkout/sessions/line_items
+   *
+   * @example
+   * const items = await payweave.stripe.checkout.sessions.lineItems("cs_test_123", { limit: 20 });
+   * console.log(items.data[0]?.amount_total);
+   */
+  async lineItems(id, query = {}) {
+    const sessionId = requireId(id, "checkout session");
+    const q = parseRequest(lineItemsQuery, query);
+    return this.http.request({
+      method: "GET",
+      path: `/v1/checkout/sessions/${encodeURIComponent(sessionId)}/line_items`,
+      query: flattenQuery(q),
+      schema: lineItemListRes
+    });
+  }
+  /**
+   * Async iterator over ALL line items of a session, following `has_more`
+   * with `starting_after = <last id>` — line items are themselves a paginated
+   * list (PW-602 work order).
+   *
+   * Docs: https://docs.stripe.com/api/checkout/sessions/line_items
+   *
+   * @example
+   * for await (const item of payweave.stripe.checkout.sessions.iterateLineItems("cs_test_123")) {
+   *   console.log(item.description, item.quantity);
+   * }
+   */
+  async *iterateLineItems(id, query = {}) {
+    const sessionId = requireId(id, "checkout session");
+    const base = parseRequest(lineItemsQuery, query);
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: `/v1/checkout/sessions/${encodeURIComponent(sessionId)}/line_items`,
+        query: flattenQuery({ ...base, starting_after: startingAfter }),
+        schema: lineItemListRes
+      })
+    );
+  }
+};
+var addressInput = z.object({
+  city: z.string().optional(),
+  /** Two-letter country code (ISO 3166-1 alpha-2). */
+  country: z.string().optional(),
+  line1: z.string().optional(),
+  line2: z.string().optional(),
+  postal_code: z.string().optional(),
+  /** State/county/province/region (ISO 3166-2 recommended). */
+  state: z.string().optional()
+});
+var cashBalanceInput = z.object({
+  settings: z.object({
+    reconciliation_mode: z.enum(["automatic", "manual", "merchant_default"]).optional()
+  }).optional()
+});
+var invoiceSettingsInput = z.object({
+  /** Up to 4 custom fields shown on invoices. */
+  custom_fields: z.array(
+    z.object({
+      /** ≤40 chars. */
+      name: z.string().max(40),
+      /** ≤140 chars. */
+      value: z.string().max(140)
+    })
+  ).optional(),
+  default_payment_method: z.string().optional(),
+  footer: z.string().optional(),
+  rendering_options: z.object({
+    amount_tax_display: z.enum(["exclude_tax", "include_inclusive_tax"]).optional(),
+    template: z.string().optional()
+  }).optional()
+});
+var shippingInput = z.object({
+  address: addressInput,
+  name: z.string(),
+  phone: z.string().optional()
+});
+var customerSharedFields = {
+  /** Required when calculating taxes. */
+  address: addressInput.optional(),
+  /** Integer MINOR units — a credit/debit applied to future invoices. */
+  balance: z.number().int().optional(),
+  /** ≤150 chars. */
+  business_name: z.string().max(150).optional(),
+  cash_balance: cashBalanceInput.optional(),
+  description: z.string().optional(),
+  /** ≤512 chars. */
+  email: z.string().max(512).optional(),
+  /** ≤150 chars. */
+  individual_name: z.string().max(150).optional(),
+  /** 3–12 uppercase letters or numbers (provider-validated). */
+  invoice_prefix: z.string().optional(),
+  invoice_settings: invoiceSettingsInput.optional(),
+  metadata: metadataSchema.optional(),
+  /** ≤256 chars. */
+  name: z.string().max(256).optional(),
+  next_invoice_sequence: z.number().int().optional(),
+  /** ≤20 chars. */
+  phone: z.string().max(20).optional(),
+  preferred_locales: z.array(z.string()).optional(),
+  shipping: shippingInput.optional(),
+  /** Payment source id; on update it becomes the new default source. */
+  source: z.string().optional(),
+  tax_exempt: z.enum(["none", "exempt", "reverse"]).optional()
+};
+var customerCreateReq = z.object({
+  ...customerSharedFields,
+  /** PaymentMethod id (`pm_*`) to attach to the new customer. */
+  payment_method: z.string().optional(),
+  /** Tax details — recommended when calculating taxes. */
+  tax: z.object({
+    ip_address: z.string().optional(),
+    /** Create documents `deferred` (default) | `immediately`. */
+    validate_location: z.enum(["deferred", "immediately"]).optional()
+  }).optional(),
+  /**
+   * The customer's tax IDs. `type` is a country-specific code (e.g. `eu_vat`,
+   * `us_ein`) — 100+ documented values, provider-validated (kept `string`).
+   */
+  tax_id_data: z.array(z.object({ type: z.string(), value: z.string() })).optional(),
+  /** Test clock id to attach (test mode). */
+  test_clock: z.string().optional()
+});
+var customerUpdateReq = z.object({
+  ...customerSharedFields,
+  /** Payment source id to make the customer's new default (≤500 chars). */
+  default_source: z.string().max(500).optional(),
+  /** Tax details — recommended when calculating taxes. */
+  tax: z.object({
+    ip_address: z.string().optional(),
+    /** Update documents `auto` (default) | `deferred` | `immediately`. */
+    validate_location: z.enum(["auto", "deferred", "immediately"]).optional()
+  }).optional()
+});
+var customerListQuery = z.object({
+  ...listCursorFields,
+  /** Creation-date window (Unix timestamps). */
+  created: createdRange.optional(),
+  /** Case-sensitive exact-match filter on email (≤512 chars). */
+  email: z.string().max(512).optional(),
+  /** Filter by test clock id. */
+  test_clock: z.string().optional()
+});
+var searchReqFields = {
+  /** Search query string, e.g. `name:'Jane' AND metadata['foo']:'bar'`. */
+  query: z.string().min(1, "search query must be a non-empty string"),
+  /** Page size, 1–100 (Stripe default 10). */
+  limit: z.number().int().min(1).max(100).optional(),
+  /** Pagination token from the previous page's `next_page` — omit initially. */
+  page: z.string().optional()
+};
+var customerSearchReq = z.object({ ...searchReqFields });
+var customer = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  address: z.looseObject({}).nullable().optional(),
+  /** Integer minor units. */
+  balance: z.number().optional(),
+  created: z.number().optional(),
+  currency: z.string().nullable().optional(),
+  /** Source id string, or an expanded object — kept unknown. */
+  default_source: z.unknown().optional(),
+  delinquent: z.boolean().nullable().optional(),
+  description: z.string().nullable().optional(),
+  email: z.string().nullable().optional(),
+  invoice_prefix: z.string().nullable().optional(),
+  invoice_settings: z.looseObject({}).optional(),
+  livemode: z.boolean().optional(),
+  metadata: z.record(z.string(), z.string()).nullable().optional(),
+  name: z.string().nullable().optional(),
+  next_invoice_sequence: z.number().optional(),
+  phone: z.string().nullable().optional(),
+  preferred_locales: z.array(z.string()).nullable().optional(),
+  shipping: z.looseObject({}).nullable().optional(),
+  /** `none` | `exempt` | `reverse`. */
+  tax_exempt: z.string().nullable().optional(),
+  /** Test clock id string, or an expanded object — kept unknown. */
+  test_clock: z.unknown().optional(),
+  /**
+   * `true` only on the reduced stub `retrieve` returns for a DELETED customer
+   * (https://docs.stripe.com/api/customers/retrieve — verified 2026-07-12:
+   * deleted customers stay retrievable "to be able to track their history").
+   */
+  deleted: z.boolean().optional()
+});
+var deletedCustomer = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  deleted: z.boolean()
+});
+
+// src/stripe/resources/customers.ts
+var customerListRes = stripeList(customer);
+var customerSearchRes = stripeSearchResult(customer);
+function bodyIfNonEmpty(body) {
+  return Object.keys(body).length > 0 ? { body } : {};
+}
+var Customers = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Create a Customer. Every field is optional — Stripe allows an empty
+   * customer. `metadata` maps go to the wire as bracket pairs
+   * (`metadata[pwv_reference]=...`). Pass `idempotencyKey` to make the POST
+   * safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/customers/create
+   *
+   * @example
+   * const cus = await payweave.stripe.customers.create({
+   *   email: "jenny.rosen@example.com",
+   *   name: "Jenny Rosen",
+   *   metadata: { pwv_reference: "pwv_ref_0001" },
+   * }, { idempotencyKey: "signup-8123-customer" });
+   * console.log(cus.id);
+   */
+  async create(input = {}, opts = {}) {
+    const body = parseRequest(customerCreateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: "/v1/customers",
+      ...bodyIfNonEmpty(body),
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: customer
+    });
+  }
+  /**
+   * Retrieve a Customer by id (`cus_*`). A 404 for an unknown id surfaces as
+   * {@link PayweaveNotFoundError}. DELETED customers stay retrievable (to
+   * track history) and come back as a reduced stub with `deleted: true` —
+   * check that flag before using other fields.
+   *
+   * Docs: https://docs.stripe.com/api/customers/retrieve
+   *
+   * @example
+   * const cus = await payweave.stripe.customers.retrieve("cus_123");
+   * if (!cus.deleted) console.log(cus.email);
+   */
+  async retrieve(id) {
+    const customerId = requireId(id, "customer");
+    return this.http.request({
+      method: "GET",
+      path: `/v1/customers/${encodeURIComponent(customerId)}`,
+      schema: customer
+    });
+  }
+  /**
+   * Update a Customer. Fields not provided remain unchanged; unset an
+   * individual `metadata` key by posting an empty string value for it. Pass
+   * `idempotencyKey` to make the POST safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/customers/update
+   *
+   * @example
+   * const cus = await payweave.stripe.customers.update("cus_123", {
+   *   metadata: { pwv_reference: "pwv_ref_0001", legacy_id: "" }, // "" unsets
+   * });
+   */
+  async update(id, input = {}, opts = {}) {
+    const customerId = requireId(id, "customer");
+    const body = parseRequest(customerUpdateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/customers/${encodeURIComponent(customerId)}`,
+      ...bodyIfNonEmpty(body),
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: customer
+    });
+  }
+  /**
+   * PERMANENTLY delete a Customer — cannot be undone. Immediately cancels
+   * any active subscriptions, removes all stored payment details, and blocks
+   * further operations on the customer. Returns the deletion stub
+   * `{ id, object: "customer", deleted: true }`; the customer remains
+   * retrievable afterwards (as a deleted stub) for history.
+   *
+   * Docs: https://docs.stripe.com/api/customers/delete
+   *
+   * @example
+   * const gone = await payweave.stripe.customers.delete("cus_123");
+   * console.log(gone.deleted); // true
+   */
+  async delete(id) {
+    const customerId = requireId(id, "customer");
+    return this.http.request({
+      method: "DELETE",
+      path: `/v1/customers/${encodeURIComponent(customerId)}`,
+      schema: deletedCustomer
+    });
+  }
+  /**
+   * List Customers (newest first). Cursor pagination: `limit` +
+   * `starting_after`/`ending_before`; the `created` window becomes bracket
+   * query keys (`created[gte]`).
+   *
+   * Docs: https://docs.stripe.com/api/customers/list
+   *
+   * @example
+   * const page = await payweave.stripe.customers.list({ email: "jenny.rosen@example.com" });
+   * console.log(page.data.length, page.has_more);
+   */
+  async list(query = {}) {
+    const q = parseRequest(customerListQuery, query);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/customers",
+      query: flattenQuery(q),
+      schema: customerListRes
+    });
+  }
+  /**
+   * Async iterator over ALL Customers matching `query`, transparently
+   * following `has_more` with `starting_after = <last id>`.
+   *
+   * Docs: https://docs.stripe.com/api/customers/list
+   *
+   * @example
+   * for await (const cus of payweave.stripe.customers.iterate({ email: "a@example.com" })) {
+   *   console.log(cus.id);
+   * }
+   */
+  async *iterate(query = {}) {
+    const base = parseRequest(customerListQuery, query);
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: "/v1/customers",
+        query: flattenQuery({ ...base, starting_after: startingAfter }),
+        schema: customerListRes
+      })
+    );
+  }
+  /**
+   * Search Customers with Stripe's search query language (e.g.
+   * `name:'Jane Doe' AND metadata['foo']:'bar'`). Pagination is TOKEN-based:
+   * pass the previous page's `next_page` as `page` (never `starting_after`).
+   * Search is eventually consistent (typically <1 minute; up to an hour
+   * during outages) — don't use it in read-after-write flows.
+   *
+   * Docs: https://docs.stripe.com/api/customers/search
+   *
+   * @example
+   * const found = await payweave.stripe.customers.search({
+   *   query: "metadata['pwv_reference']:'pwv_ref_0001'",
+   * });
+   * console.log(found.data[0]?.id, found.next_page);
+   */
+  async search(input) {
+    const q = parseRequest(customerSearchReq, input);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/customers/search",
+      query: flattenQuery(q),
+      schema: customerSearchRes
+    });
+  }
+  /**
+   * Async iterator over ALL Customers matching a search query, transparently
+   * following `has_more` with `page = <next_page token>` — search pagination
+   * differs from list pagination (https://docs.stripe.com/api/pagination/search).
+   *
+   * Docs: https://docs.stripe.com/api/customers/search
+   *
+   * @example
+   * for await (const cus of payweave.stripe.customers.iterateSearch({
+   *   query: "email:'jenny.rosen@example.com'",
+   * })) {
+   *   console.log(cus.id);
+   * }
+   */
+  async *iterateSearch(input) {
+    const base = parseRequest(customerSearchReq, input);
+    yield* iterateStripeSearch(
+      (page) => this.http.request({
+        method: "GET",
+        path: "/v1/customers/search",
+        query: flattenQuery({ ...base, page }),
+        schema: customerSearchRes
+      })
+    );
+  }
+};
+var automaticPaymentMethods = z.object({
+  enabled: z.boolean(),
+  allow_redirects: z.enum(["always", "never"]).optional()
+});
+var paymentIntentCreateReq = z.object({
+  /** Positive integer in the smallest currency unit (minor units) — unchanged. */
+  amount: z.number().int().positive(),
+  /** Three-letter ISO currency code, lowercase. Required. */
+  currency: z.string(),
+  automatic_payment_methods: automaticPaymentMethods.optional(),
+  /** `true` = create + confirm in one call. Defaults to false. */
+  confirm: z.boolean().optional(),
+  /** Customer id (`cus_*`) this intent belongs to. */
+  customer: z.string().optional(),
+  description: z.string().optional(),
+  metadata: metadataSchema.optional(),
+  /** PaymentMethod id (`pm_*`) to attach. */
+  payment_method: z.string().optional(),
+  /** Payment method types to accept (e.g. `["card", "link"]`). */
+  payment_method_types: z.array(z.string()).optional(),
+  receipt_email: z.string().optional(),
+  /** `automatic` | `automatic_async` (default) | `manual`. */
+  capture_method: z.enum(["automatic", "automatic_async", "manual"]).optional(),
+  confirmation_method: z.enum(["automatic", "manual"]).optional(),
+  setup_future_usage: z.enum(["on_session", "off_session"]).optional(),
+  /** ≤22 chars — statement text for non-card charges. */
+  statement_descriptor: z.string().max(22).optional(),
+  /** ≤22 chars — suffix appended to the account descriptor for card charges. */
+  statement_descriptor_suffix: z.string().max(22).optional(),
+  /** Redirect URL after off-page authentication (use with `confirm: true`). */
+  return_url: z.string().optional(),
+  /** Customer is not in the checkout flow (docs type: boolean or string). */
+  off_session: z.union([z.boolean(), z.string()]).optional(),
+  /** Transaction-group identifier for Connect. */
+  transfer_group: z.string().optional(),
+  /** Connect application fee, integer minor units. */
+  application_fee_amount: z.number().int().optional()
+});
+var paymentIntentConfirmReq = z.object({
+  /** PaymentMethod id (`pm_*`) to use for this confirmation attempt. */
+  payment_method: z.string().optional(),
+  /** Redirect URL after authentication for redirect-based methods. */
+  return_url: z.string().optional(),
+  receipt_email: z.string().optional(),
+  setup_future_usage: z.enum(["on_session", "off_session"]).optional(),
+  capture_method: z.enum(["automatic", "automatic_async", "manual"]).optional(),
+  /** Customer is not in the checkout flow (docs type: boolean or string). */
+  off_session: z.union([z.boolean(), z.string()]).optional(),
+  /** ConfirmationToken id capturing client-collected payment details. */
+  confirmation_token: z.string().optional(),
+  /** Fail (instead of returning `requires_action`) when an action is needed. */
+  error_on_requires_action: z.boolean().optional(),
+  /** Mandate id to use for this confirmation. */
+  mandate: z.string().optional()
+});
+var paymentIntentCaptureReq = z.object({
+  /** Integer minor units to capture; defaults to full `amount_capturable`. */
+  amount_to_capture: z.number().int().positive().optional(),
+  /** Connect application fee, integer minor units. */
+  application_fee_amount: z.number().int().optional(),
+  /** Default true. `false` retains uncaptured funds (multicapture accounts). */
+  final_capture: z.boolean().optional(),
+  metadata: metadataSchema.optional(),
+  /** ≤22 chars — statement text for non-card charges. */
+  statement_descriptor: z.string().max(22).optional(),
+  /** ≤22 chars — suffix appended to the account descriptor for card charges. */
+  statement_descriptor_suffix: z.string().max(22).optional()
+});
+var paymentIntentCancelReq = z.object({
+  cancellation_reason: z.enum(["duplicate", "fraudulent", "requested_by_customer", "abandoned"]).optional()
+});
+var paymentIntentListQuery = z.object({
+  ...listCursorFields,
+  /** Filter by Customer id. */
+  customer: z.string().optional(),
+  /** Creation-date window (Unix timestamps). */
+  created: createdRange.optional()
+});
+var paymentIntent = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  amount: z.number().optional(),
+  amount_capturable: z.number().optional(),
+  amount_received: z.number().optional(),
+  currency: z.string().optional(),
+  /**
+   * `requires_payment_method` | `requires_confirmation` | `requires_action` |
+   * `processing` | `requires_capture` | `canceled` | `succeeded` —
+   * normalization is the unified layer's job.
+   */
+  status: z.string().optional(),
+  client_secret: z.string().nullable().optional(),
+  capture_method: z.string().optional(),
+  confirmation_method: z.string().optional(),
+  /** Customer id string, or an expanded object — kept unknown. */
+  customer: z.unknown().optional(),
+  description: z.string().nullable().optional(),
+  /** Latest Charge id string, or an expanded object — kept unknown. */
+  latest_charge: z.unknown().optional(),
+  metadata: z.record(z.string(), z.string()).nullable().optional(),
+  /** PaymentMethod id string, or an expanded object — kept unknown. */
+  payment_method: z.unknown().optional(),
+  receipt_email: z.string().nullable().optional(),
+  /** Client-side action required to continue — kept loose. */
+  next_action: z.looseObject({}).nullable().optional(),
+  cancellation_reason: z.string().nullable().optional(),
+  canceled_at: z.number().nullable().optional(),
+  created: z.number().optional(),
+  livemode: z.boolean().optional()
+});
+
+// src/stripe/resources/payment-intents.ts
+var paymentIntentListRes = stripeList(paymentIntent);
+function bodyIfNonEmpty2(body) {
+  return Object.keys(body).length > 0 ? { body } : {};
+}
+var PaymentIntents = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Create a PaymentIntent. `amount` is a positive integer in MINOR units
+   * (e.g. 2000 = $20.00) and is sent to Stripe unchanged. Pass
+   * `idempotencyKey` to make the POST safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/payment_intents/create
+   *
+   * @example
+   * const pi = await payweave.stripe.paymentIntents.create({
+   *   amount: 2000,
+   *   currency: "usd",
+   *   automatic_payment_methods: { enabled: true },
+   * }, { idempotencyKey: "order-8123-intent" });
+   * console.log(pi.client_secret);
+   */
+  async create(input, opts = {}) {
+    const body = parseRequest(paymentIntentCreateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: "/v1/payment_intents",
+      body,
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: paymentIntent
+    });
+  }
+  /**
+   * Retrieve a PaymentIntent by id (`pi_*`). A 404 for an unknown id surfaces
+   * as {@link PayweaveNotFoundError}.
+   *
+   * Docs: https://docs.stripe.com/api/payment_intents/retrieve
+   *
+   * @example
+   * const pi = await payweave.stripe.paymentIntents.retrieve("pi_123");
+   * if (pi.status === "succeeded") { }
+   */
+  async retrieve(id) {
+    const intentId = requireId(id, "payment intent");
+    return this.http.request({
+      method: "GET",
+      path: `/v1/payment_intents/${encodeURIComponent(intentId)}`,
+      schema: paymentIntent
+    });
+  }
+  /**
+   * Confirm a PaymentIntent (attempt payment with the attached/provided
+   * payment method). On success the status moves to `succeeded` — or
+   * `requires_capture` when `capture_method` is `manual`, or
+   * `requires_action` when authentication is needed. Pass `idempotencyKey`
+   * to make the POST safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/payment_intents/confirm
+   *
+   * @example
+   * const pi = await payweave.stripe.paymentIntents.confirm("pi_123", {
+   *   payment_method: "pm_card_visa",
+   *   return_url: "https://example.com/return",
+   * }, { idempotencyKey: "order-8123-confirm" });
+   */
+  async confirm(id, input = {}, opts = {}) {
+    const intentId = requireId(id, "payment intent");
+    const body = parseRequest(paymentIntentConfirmReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/payment_intents/${encodeURIComponent(intentId)}/confirm`,
+      ...bodyIfNonEmpty2(body),
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: paymentIntent
+    });
+  }
+  /**
+   * Capture the funds of a `requires_capture` PaymentIntent (manual capture
+   * flow — uncaptured intents cancel after 7 days by default).
+   * `amount_to_capture` is integer minor units and defaults to the full
+   * `amount_capturable`. Pass `idempotencyKey` to make the POST safely
+   * replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/payment_intents/capture
+   *
+   * @example
+   * const pi = await payweave.stripe.paymentIntents.capture("pi_123", {
+   *   amount_to_capture: 1500,
+   * }, { idempotencyKey: "order-8123-capture" });
+   * console.log(pi.status); // "succeeded"
+   */
+  async capture(id, input = {}, opts = {}) {
+    const intentId = requireId(id, "payment intent");
+    const body = parseRequest(paymentIntentCaptureReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/payment_intents/${encodeURIComponent(intentId)}/capture`,
+      ...bodyIfNonEmpty2(body),
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: paymentIntent
+    });
+  }
+  /**
+   * Cancel a PaymentIntent. Valid only for statuses
+   * `requires_payment_method`, `requires_capture`, `requires_confirmation`,
+   * `requires_action` and (rarely) `processing` — Stripe errors otherwise
+   * (surfaced as {@link PayweaveValidationError} on the 400). For
+   * `requires_capture` intents the remaining `amount_capturable` is
+   * automatically refunded.
+   *
+   * Docs: https://docs.stripe.com/api/payment_intents/cancel
+   *
+   * @example
+   * const pi = await payweave.stripe.paymentIntents.cancel("pi_123", {
+   *   cancellation_reason: "requested_by_customer",
+   * });
+   * console.log(pi.status); // "canceled"
+   */
+  async cancel(id, input = {}) {
+    const intentId = requireId(id, "payment intent");
+    const body = parseRequest(paymentIntentCancelReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/payment_intents/${encodeURIComponent(intentId)}/cancel`,
+      ...bodyIfNonEmpty2(body),
+      schema: paymentIntent
+    });
+  }
+  /**
+   * List PaymentIntents (newest first). Cursor pagination: `limit` +
+   * `starting_after`/`ending_before`; the `created` window becomes bracket
+   * query keys (`created[gte]`).
+   *
+   * Docs: https://docs.stripe.com/api/payment_intents/list
+   *
+   * @example
+   * const page = await payweave.stripe.paymentIntents.list({ customer: "cus_123", limit: 50 });
+   * console.log(page.data.length, page.has_more);
+   */
+  async list(query = {}) {
+    const q = parseRequest(paymentIntentListQuery, query);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/payment_intents",
+      query: flattenQuery(q),
+      schema: paymentIntentListRes
+    });
+  }
+  /**
+   * Async iterator over ALL PaymentIntents matching `query`, transparently
+   * following `has_more` with `starting_after = <last id>`.
+   *
+   * Docs: https://docs.stripe.com/api/payment_intents/list
+   *
+   * @example
+   * for await (const pi of payweave.stripe.paymentIntents.iterate({ customer: "cus_123" })) {
+   *   console.log(pi.id, pi.status);
+   * }
+   */
+  async *iterate(query = {}) {
+    const base = parseRequest(paymentIntentListQuery, query);
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: "/v1/payment_intents",
+        query: flattenQuery({ ...base, starting_after: startingAfter }),
+        schema: paymentIntentListRes
+      })
+    );
+  }
+};
+var customUnitAmountInput = z.object({
+  /** Pass `true` to enable — otherwise omit the whole object. */
+  enabled: z.boolean(),
+  maximum: z.number().int().optional(),
+  minimum: z.number().int().optional(),
+  preset: z.number().int().optional()
+});
+var recurringInput = z.object({
+  interval: z.enum(["day", "week", "month", "year"]),
+  /** Intervals between billings — max 3 years (36 months, 156 weeks). */
+  interval_count: z.number().int().optional(),
+  /** Defaults to `licensed`. */
+  usage_type: z.enum(["licensed", "metered"]).optional(),
+  /** Billing Meter id tracking usage for a metered price. */
+  meter: z.string().optional()
+});
+var tierInput = z.object({
+  /** Upper bound of this tier — `"inf"` for the fallback tier. Required. */
+  up_to: z.union([z.literal("inf"), z.number().int()]),
+  /** Flat amount for the whole tier, integer minor units. */
+  flat_amount: z.number().int().optional(),
+  /** Decimal-string alternative to `flat_amount` (only one of the two). */
+  flat_amount_decimal: z.string().optional(),
+  /** Per-unit amount, integer minor units. */
+  unit_amount: z.number().int().optional(),
+  /** Decimal-string alternative to `unit_amount` (only one of the two). */
+  unit_amount_decimal: z.string().optional()
+});
+var productDataInput = z.object({
+  /** Displayable product name. Required. */
+  name: z.string(),
+  /** Defaults to true. */
+  active: z.boolean().optional(),
+  metadata: metadataSchema.optional(),
+  /** ≤22 chars; may not include `<`, `>`, `\`, `"`, `'`. */
+  statement_descriptor: z.string().max(22).optional(),
+  /** Tax code id — recommended when calculating taxes. */
+  tax_code: z.string().optional(),
+  tax_details: z.object({
+    tax_code: z.string().optional(),
+    /** Tax location id — required/optional/unsupported per tax code. */
+    performance_location: z.string().optional()
+  }).optional(),
+  /** ≤12 chars. */
+  unit_label: z.string().max(12).optional()
+});
+var priceCreateReq = z.object({
+  /** Three-letter ISO currency code, lowercase. Required. */
+  currency: z.string(),
+  /** Integer minor units (or 0 for a free price). */
+  unit_amount: z.number().int().nonnegative().optional(),
+  /** Decimal string alternative to `unit_amount` (≤12 decimal places). */
+  unit_amount_decimal: z.string().optional(),
+  custom_unit_amount: customUnitAmountInput.optional(),
+  /** Usable for new purchases. Defaults to true; `false` = archived. */
+  active: z.boolean().optional(),
+  /** Defaults to `per_unit`. */
+  billing_scheme: z.enum(["per_unit", "tiered"]).optional(),
+  /** Stable retrieval key (≤200 chars) — PW-803's price identifier. */
+  lookup_key: z.string().max(200).optional(),
+  /** Atomically move `lookup_key` off the price currently holding it. */
+  transfer_lookup_key: z.boolean().optional(),
+  metadata: metadataSchema.optional(),
+  /** Internal description, hidden from customers. */
+  nickname: z.string().optional(),
+  /** Existing Product id (`prod_*`). Alternative to `product_data`. */
+  product: z.string().optional(),
+  /** Inline Product creation. Alternative to `product`. */
+  product_data: productDataInput.optional(),
+  recurring: recurringInput.optional(),
+  /** Cannot be changed after being set to `inclusive`/`exclusive`. */
+  tax_behavior: z.enum(["inclusive", "exclusive", "unspecified"]).optional(),
+  /** Required when `billing_scheme=tiered`. */
+  tiers: z.array(tierInput).optional(),
+  /** Required when `billing_scheme=tiered`. */
+  tiers_mode: z.enum(["graduated", "volume"]).optional(),
+  /** Transform reported quantity before billing — cannot combine with tiers. */
+  transform_quantity: z.object({
+    divide_by: z.number().int(),
+    round: z.enum(["up", "down"])
+  }).optional()
+});
+var priceUpdateReq = z.object({
+  /** `false` archives the price for new purchases (PW-803 price rotation). */
+  active: z.boolean().optional(),
+  /** Stable retrieval key (≤200 chars). */
+  lookup_key: z.string().max(200).optional(),
+  /** Atomically move `lookup_key` off the price currently holding it. */
+  transfer_lookup_key: z.boolean().optional(),
+  metadata: metadataSchema.optional(),
+  /** Internal description, hidden from customers. */
+  nickname: z.string().optional(),
+  /** Cannot be changed after being set to `inclusive`/`exclusive`. */
+  tax_behavior: z.enum(["inclusive", "exclusive", "unspecified"]).optional()
+});
+var priceListQuery = z.object({
+  ...listCursorFields,
+  /** Only active (or only archived) prices. */
+  active: z.boolean().optional(),
+  /** Creation-date window (Unix timestamps). */
+  created: createdRange.optional(),
+  /** Filter by currency code. */
+  currency: z.string().optional(),
+  /** Only prices with these lookup_keys (up to 10). */
+  lookup_keys: z.array(z.string()).optional(),
+  /** Filter by Product id. */
+  product: z.string().optional(),
+  /** Filter by recurring components. */
+  recurring: z.object({
+    interval: z.enum(["day", "week", "month", "year"]).optional(),
+    /** Filter by the price's Billing Meter id. */
+    meter: z.string().optional(),
+    usage_type: z.enum(["licensed", "metered"]).optional()
+  }).optional(),
+  type: z.enum(["one_time", "recurring"]).optional()
+});
+var priceSearchReq = z.object({ ...searchReqFields });
+var price = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  active: z.boolean().optional(),
+  /** `per_unit` | `tiered`. */
+  billing_scheme: z.string().optional(),
+  created: z.number().optional(),
+  currency: z.string().optional(),
+  custom_unit_amount: z.looseObject({}).nullable().optional(),
+  livemode: z.boolean().optional(),
+  lookup_key: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.string()).nullable().optional(),
+  nickname: z.string().nullable().optional(),
+  /** Product id string, or an expanded object — kept unknown. */
+  product: z.unknown().optional(),
+  recurring: z.looseObject({
+    interval: z.string().optional(),
+    interval_count: z.number().nullable().optional(),
+    trial_period_days: z.number().nullable().optional(),
+    usage_type: z.string().optional(),
+    meter: z.string().nullable().optional()
+  }).nullable().optional(),
+  tax_behavior: z.string().nullable().optional(),
+  /** `graduated` | `volume` — null unless tiered. */
+  tiers_mode: z.string().nullable().optional(),
+  transform_quantity: z.looseObject({}).nullable().optional(),
+  /** `one_time` | `recurring`. */
+  type: z.string().optional(),
+  /** Integer minor units — null for tiered/custom-amount prices. */
+  unit_amount: z.number().nullable().optional(),
+  unit_amount_decimal: z.string().nullable().optional()
+});
+
+// src/stripe/resources/prices.ts
+var priceListRes = stripeList(price);
+var priceSearchRes = stripeSearchResult(price);
+function bodyIfNonEmpty3(body) {
+  return Object.keys(body).length > 0 ? { body } : {};
+}
+var Prices = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Create a Price. `unit_amount` is integer MINOR units (e.g. 1500 = $15.00)
+   * and is sent to Stripe unchanged; `recurring` makes it a subscription
+   * price; `lookup_key` (+ `transfer_lookup_key`) gives it a stable
+   * identifier that survives price rotation. Amount, currency, product and
+   * recurring are IMMUTABLE afterwards. Pass `idempotencyKey` to make the
+   * POST safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/prices/create
+   *
+   * @example
+   * const pr = await payweave.stripe.prices.create({
+   *   currency: "usd",
+   *   unit_amount: 1500,
+   *   product: "prod_123",
+   *   recurring: { interval: "month" },
+   *   lookup_key: "pro-monthly",
+   * }, { idempotencyKey: "push-pro-monthly-v2" });
+   * console.log(pr.id);
+   */
+  async create(input, opts = {}) {
+    const body = parseRequest(priceCreateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: "/v1/prices",
+      body,
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: price
+    });
+  }
+  /**
+   * Retrieve a Price by id (`price_*`). A 404 for an unknown id surfaces as
+   * {@link PayweaveNotFoundError}.
+   *
+   * Docs: https://docs.stripe.com/api/prices/retrieve
+   *
+   * @example
+   * const pr = await payweave.stripe.prices.retrieve("price_123");
+   * console.log(pr.unit_amount, pr.currency);
+   */
+  async retrieve(id) {
+    const priceId = requireId(id, "price");
+    return this.http.request({
+      method: "GET",
+      path: `/v1/prices/${encodeURIComponent(priceId)}`,
+      schema: price
+    });
+  }
+  /**
+   * Update a Price. ONLY `active`, `lookup_key`/`transfer_lookup_key`,
+   * `metadata`, `nickname` and `tax_behavior` (until set) are updatable —
+   * amount/currency/product/recurring are immutable, and prices cannot be
+   * deleted: rotate by creating a new Price and archiving this one with
+   * `active: false` (PW-803's price-change flow). Pass `idempotencyKey` to
+   * make the POST safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/prices/update
+   *
+   * @example
+   * const archived = await payweave.stripe.prices.update("price_123", {
+   *   active: false,
+   * });
+   * console.log(archived.active); // false
+   */
+  async update(id, input = {}, opts = {}) {
+    const priceId = requireId(id, "price");
+    const body = parseRequest(priceUpdateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/prices/${encodeURIComponent(priceId)}`,
+      ...bodyIfNonEmpty3(body),
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: price
+    });
+  }
+  /**
+   * List Prices (newest first). Cursor pagination: `limit` +
+   * `starting_after`/`ending_before`; `created`/`recurring` become bracket
+   * query keys (`recurring[interval]`) and `lookup_keys` explicit indices
+   * (`lookup_keys[0]=...`).
+   *
+   * Docs: https://docs.stripe.com/api/prices/list
+   *
+   * @example
+   * const page = await payweave.stripe.prices.list({ product: "prod_123", active: true });
+   * console.log(page.data.length, page.has_more);
+   */
+  async list(query = {}) {
+    const { lookup_keys, ...rest } = parseRequest(priceListQuery, query);
+    const q = flattenQuery(rest);
+    lookup_keys?.forEach((key, i) => {
+      q[`lookup_keys[${i}]`] = key;
+    });
+    return this.http.request({
+      method: "GET",
+      path: "/v1/prices",
+      query: q,
+      schema: priceListRes
+    });
+  }
+  /**
+   * Async iterator over ALL Prices matching `query`, transparently following
+   * `has_more` with `starting_after = <last id>`.
+   *
+   * Docs: https://docs.stripe.com/api/prices/list
+   *
+   * @example
+   * for await (const pr of payweave.stripe.prices.iterate({ product: "prod_123" })) {
+   *   console.log(pr.id, pr.unit_amount);
+   * }
+   */
+  async *iterate(query = {}) {
+    const { lookup_keys, ...base } = parseRequest(priceListQuery, query);
+    const lookupPairs = {};
+    lookup_keys?.forEach((key, i) => {
+      lookupPairs[`lookup_keys[${i}]`] = key;
+    });
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: "/v1/prices",
+        query: {
+          ...flattenQuery({ ...base, starting_after: startingAfter }),
+          ...lookupPairs
+        },
+        schema: priceListRes
+      })
+    );
+  }
+  /**
+   * Search Prices with Stripe's search query language (e.g.
+   * `active:'true' AND lookup_key:'pro-monthly'`). Pagination is TOKEN-based:
+   * pass the previous page's `next_page` as `page` (never `starting_after`).
+   * Search is eventually consistent — don't use it in read-after-write flows.
+   *
+   * Docs: https://docs.stripe.com/api/prices/search
+   *
+   * @example
+   * const found = await payweave.stripe.prices.search({
+   *   query: "metadata['pwv_reference']:'pwv_plan_pro'",
+   * });
+   * console.log(found.data[0]?.id, found.next_page);
+   */
+  async search(input) {
+    const q = parseRequest(priceSearchReq, input);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/prices/search",
+      query: flattenQuery(q),
+      schema: priceSearchRes
+    });
+  }
+  /**
+   * Async iterator over ALL Prices matching a search query, transparently
+   * following `has_more` with `page = <next_page token>` — search pagination
+   * differs from list pagination (https://docs.stripe.com/api/pagination/search).
+   *
+   * Docs: https://docs.stripe.com/api/prices/search
+   *
+   * @example
+   * for await (const pr of payweave.stripe.prices.iterateSearch({
+   *   query: "type:'recurring'",
+   * })) {
+   *   console.log(pr.id);
+   * }
+   */
+  async *iterateSearch(input) {
+    const base = parseRequest(priceSearchReq, input);
+    yield* iterateStripeSearch(
+      (page) => this.http.request({
+        method: "GET",
+        path: "/v1/prices/search",
+        query: flattenQuery({ ...base, page }),
+        schema: priceSearchRes
+      })
+    );
+  }
+};
+var marketingFeatureInput = z.object({
+  /** ≤80 chars. */
+  name: z.string().max(80)
+});
+var packageDimensionsInput = z.object({
+  /** Inches, ≤2 decimal places. */
+  height: z.number(),
+  /** Inches, ≤2 decimal places. */
+  length: z.number(),
+  /** Ounces, ≤2 decimal places. */
+  weight: z.number(),
+  /** Inches, ≤2 decimal places. */
+  width: z.number()
+});
+var taxDetailsInput = z.object({
+  tax_code: z.string().optional(),
+  /** Tax location id — required/optional/unsupported depending on tax code. */
+  performance_location: z.string().optional()
+});
+var customUnitAmountInput2 = z.object({
+  /** Pass `true` to enable — otherwise omit the whole object. */
+  enabled: z.boolean(),
+  maximum: z.number().int().optional(),
+  minimum: z.number().int().optional(),
+  preset: z.number().int().optional()
+});
+var defaultPriceDataInput = z.object({
+  /** Three-letter ISO currency code, lowercase. Required. */
+  currency: z.string(),
+  /** Integer minor units (or 0 for a free price). */
+  unit_amount: z.number().int().nonnegative().optional(),
+  /** Decimal string alternative to `unit_amount` (≤12 decimal places). */
+  unit_amount_decimal: z.string().optional(),
+  custom_unit_amount: customUnitAmountInput2.optional(),
+  metadata: metadataSchema.optional(),
+  recurring: z.object({
+    interval: z.enum(["day", "week", "month", "year"]),
+    /** Intervals between billings — max 3 years (36 months, 156 weeks). */
+    interval_count: z.number().int().optional()
+  }).optional(),
+  /** Cannot be changed after being set to `inclusive`/`exclusive`. */
+  tax_behavior: z.enum(["inclusive", "exclusive", "unspecified"]).optional()
+});
+var productSharedFields = {
+  /** Available for purchase. Defaults to true; `false` = archived. */
+  active: z.boolean().optional(),
+  description: z.string().optional(),
+  /** Up to 8 image URLs. */
+  images: z.array(z.string()).optional(),
+  /** Up to 15 marketing features (pricing tables). */
+  marketing_features: z.array(marketingFeatureInput).optional(),
+  metadata: metadataSchema.optional(),
+  package_dimensions: packageDimensionsInput.optional(),
+  /** Whether the product is shipped (physical goods). */
+  shippable: z.boolean().optional(),
+  /** ≤22 chars, `type=service` subscriptions only. */
+  statement_descriptor: z.string().max(22).optional(),
+  /** Tax code id — recommended when calculating taxes. */
+  tax_code: z.string().optional(),
+  tax_details: taxDetailsInput.optional(),
+  /** ≤12 chars, `type=service` only. */
+  unit_label: z.string().max(12).optional(),
+  /** Publicly-accessible webpage for the product. */
+  url: z.string().optional()
+};
+var productCreateReq = z.object({
+  /** Displayable product name. Required. */
+  name: z.string(),
+  ...productSharedFields,
+  /** Custom unique id (`prod_*` generated when omitted). */
+  id: z.string().optional(),
+  /** Create the product's default Price in the same call. */
+  default_price_data: defaultPriceDataInput.optional()
+});
+var productUpdateReq = z.object({
+  ...productSharedFields,
+  /** Existing Price id (`price_*`) to make the default for this product. */
+  default_price: z.string().optional(),
+  name: z.string().optional()
+});
+var productListQuery = z.object({
+  ...listCursorFields,
+  /** Only active (or only archived) products. */
+  active: z.boolean().optional(),
+  /** Creation-date window (Unix timestamps). */
+  created: createdRange.optional(),
+  /** Only these product ids — cannot combine with the cursor params. */
+  ids: z.array(z.string()).optional(),
+  /** Only shippable (physical) products. */
+  shippable: z.boolean().optional(),
+  /** Only products with this url. */
+  url: z.string().optional()
+});
+var productSearchReq = z.object({ ...searchReqFields });
+var product = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  active: z.boolean().optional(),
+  created: z.number().optional(),
+  /** Price id string, or an expanded object — kept unknown. */
+  default_price: z.unknown().optional(),
+  description: z.string().nullable().optional(),
+  images: z.array(z.string()).optional(),
+  marketing_features: z.array(z.looseObject({})).optional(),
+  livemode: z.boolean().optional(),
+  metadata: z.record(z.string(), z.string()).nullable().optional(),
+  name: z.string().optional(),
+  package_dimensions: z.looseObject({}).nullable().optional(),
+  shippable: z.boolean().nullable().optional(),
+  statement_descriptor: z.string().nullable().optional(),
+  /** Tax code id string, or an expanded object — kept unknown. */
+  tax_code: z.unknown().optional(),
+  unit_label: z.string().nullable().optional(),
+  updated: z.number().optional(),
+  url: z.string().nullable().optional()
+});
+var deletedProduct = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  deleted: z.boolean()
+});
+
+// src/stripe/resources/products.ts
+var productListRes = stripeList(product);
+var productSearchRes = stripeSearchResult(product);
+function bodyIfNonEmpty4(body) {
+  return Object.keys(body).length > 0 ? { body } : {};
+}
+var Products = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Create a Product. `default_price_data` creates the product's default
+   * Price in the same call — its `unit_amount` is integer MINOR units, sent
+   * to Stripe unchanged. Pass `idempotencyKey` to make the POST safely
+   * replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/products/create
+   *
+   * @example
+   * const prod = await payweave.stripe.products.create({
+   *   name: "Pro Plan",
+   *   metadata: { pwv_reference: "pwv_plan_pro" },
+   *   default_price_data: {
+   *     currency: "usd",
+   *     unit_amount: 1500, // $15.00 in minor units
+   *     recurring: { interval: "month" },
+   *   },
+   * }, { idempotencyKey: "push-pro-plan-v1" });
+   * console.log(prod.id, prod.default_price);
+   */
+  async create(input, opts = {}) {
+    const body = parseRequest(productCreateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: "/v1/products",
+      body,
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: product
+    });
+  }
+  /**
+   * Retrieve a Product by id (`prod_*`). A 404 for an unknown id surfaces as
+   * {@link PayweaveNotFoundError}.
+   *
+   * Docs: https://docs.stripe.com/api/products/retrieve
+   *
+   * @example
+   * const prod = await payweave.stripe.products.retrieve("prod_123");
+   * console.log(prod.name, prod.active);
+   */
+  async retrieve(id) {
+    const productId = requireId(id, "product");
+    return this.http.request({
+      method: "GET",
+      path: `/v1/products/${encodeURIComponent(productId)}`,
+      schema: product
+    });
+  }
+  /**
+   * Update a Product. Fields not provided remain unchanged. `active: false`
+   * ARCHIVES the product (no new purchases) — the sync-flow alternative to
+   * deletion, since products with prices cannot be deleted (PW-803 relies on
+   * this). Pass `idempotencyKey` to make the POST safely replayable (and
+   * retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/products/update
+   *
+   * @example
+   * const archived = await payweave.stripe.products.update("prod_123", { active: false });
+   * console.log(archived.active); // false
+   */
+  async update(id, input = {}, opts = {}) {
+    const productId = requireId(id, "product");
+    const body = parseRequest(productUpdateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/products/${encodeURIComponent(productId)}`,
+      ...bodyIfNonEmpty4(body),
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: product
+    });
+  }
+  /**
+   * Delete a Product. Only succeeds when the product has NO prices attached
+   * (and, for `type=good`, no SKUs) — otherwise Stripe rejects with a 400
+   * (surfaced as {@link PayweaveValidationError}). Sync flows should archive
+   * with `update(id, { active: false })` instead. Returns the deletion stub
+   * `{ id, object: "product", deleted: true }`.
+   *
+   * Docs: https://docs.stripe.com/api/products/delete
+   *
+   * @example
+   * const gone = await payweave.stripe.products.delete("prod_123");
+   * console.log(gone.deleted); // true
+   */
+  async delete(id) {
+    const productId = requireId(id, "product");
+    return this.http.request({
+      method: "DELETE",
+      path: `/v1/products/${encodeURIComponent(productId)}`,
+      schema: deletedProduct
+    });
+  }
+  /**
+   * List Products (newest first). Cursor pagination: `limit` +
+   * `starting_after`/`ending_before`; `created` becomes bracket query keys
+   * and `ids` explicit indices (`ids[0]=...` — cannot combine `ids` with the
+   * cursor params).
+   *
+   * Docs: https://docs.stripe.com/api/products/list
+   *
+   * @example
+   * const page = await payweave.stripe.products.list({ active: true, limit: 50 });
+   * console.log(page.data.length, page.has_more);
+   */
+  async list(query = {}) {
+    const { ids, ...rest } = parseRequest(productListQuery, query);
+    const q = flattenQuery(rest);
+    ids?.forEach((id, i) => {
+      q[`ids[${i}]`] = id;
+    });
+    return this.http.request({
+      method: "GET",
+      path: "/v1/products",
+      query: q,
+      schema: productListRes
+    });
+  }
+  /**
+   * Async iterator over ALL Products matching `query`, transparently
+   * following `has_more` with `starting_after = <last id>` (providers.md
+   * §3.1). `ids` is not supported here — Stripe forbids combining it with
+   * cursors; use {@link Products.list}.
+   *
+   * Docs: https://docs.stripe.com/api/products/list
+   *
+   * @example
+   * for await (const prod of payweave.stripe.products.iterate({ active: true })) {
+   *   console.log(prod.id, prod.name);
+   * }
+   */
+  async *iterate(query = {}) {
+    const base = parseRequest(productListQuery, query);
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: "/v1/products",
+        query: flattenQuery({ ...base, starting_after: startingAfter }),
+        schema: productListRes
+      })
+    );
+  }
+  /**
+   * Search Products with Stripe's search query language (e.g.
+   * `active:'true' AND metadata['order_id']:'6735'`). Pagination is
+   * TOKEN-based: pass the previous page's `next_page` as `page` (never
+   * `starting_after`). Search is eventually consistent — don't use it in
+   * read-after-write flows.
+   *
+   * Docs: https://docs.stripe.com/api/products/search
+   *
+   * @example
+   * const found = await payweave.stripe.products.search({
+   *   query: "metadata['pwv_reference']:'pwv_plan_pro'",
+   * });
+   * console.log(found.data[0]?.id, found.has_more);
+   */
+  async search(input) {
+    const q = parseRequest(productSearchReq, input);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/products/search",
+      query: flattenQuery(q),
+      schema: productSearchRes
+    });
+  }
+  /**
+   * Async iterator over ALL Products matching a search query, transparently
+   * following `has_more` with `page = <next_page token>` — search pagination
+   * differs from list pagination (https://docs.stripe.com/api/pagination/search).
+   *
+   * Docs: https://docs.stripe.com/api/products/search
+   *
+   * @example
+   * for await (const prod of payweave.stripe.products.iterateSearch({
+   *   query: "active:'true'",
+   * })) {
+   *   console.log(prod.id);
+   * }
+   */
+  async *iterateSearch(input) {
+    const base = parseRequest(productSearchReq, input);
+    yield* iterateStripeSearch(
+      (page) => this.http.request({
+        method: "GET",
+        path: "/v1/products/search",
+        query: flattenQuery({ ...base, page }),
+        schema: productSearchRes
+      })
+    );
+  }
+};
+var refundCreateReq = z.object({
+  /**
+   * Positive integer in the smallest currency unit (minor units) — "can
+   * refund only up to the remaining, unrefunded amount of the charge".
+   * Omit to refund in full.
+   */
+  amount: z.number().int().positive().optional(),
+  /** The identifier of the charge to refund (`ch_*`). */
+  charge: z.string().optional(),
+  /**
+   * The identifier of the PaymentIntent to refund (`pi_*`) — the path the
+   * unified layer uses (providers.md §3.3: refunds go against the payment
+   * intent).
+   */
+  payment_intent: z.string().optional(),
+  /**
+   * Reason for the refund. If set: `duplicate` | `fraudulent` |
+   * `requested_by_customer`.
+   */
+  reason: z.enum(["duplicate", "fraudulent", "requested_by_customer"]).optional(),
+  /**
+   * For payment methods without native refund support (e.g. Konbini,
+   * PromptPay) — customer email to receive refund instructions.
+   */
+  instructions_email: z.string().optional(),
+  metadata: metadataSchema.optional(),
+  /**
+   * Origin of the refund. `customer_balance` refunds from a Customer
+   * Balance instead of a Charge/PaymentIntent — when provided, a
+   * Charge/PaymentIntent identifier is not required.
+   */
+  origin: z.enum(["customer_balance"]).optional(),
+  /**
+   * Whether the application fee should be refunded too (refundable only by
+   * the application that created the charge — Connect).
+   */
+  refund_application_fee: z.boolean().optional(),
+  /**
+   * Whether the transfer should be reversed when refunding (reversible only
+   * by the application that created the charge — Connect).
+   */
+  reverse_transfer: z.boolean().optional()
+}).refine(
+  (v) => v.charge !== void 0 || v.payment_intent !== void 0 || v.origin !== void 0,
+  {
+    message: "one of charge, payment_intent, or origin is required (https://docs.stripe.com/api/refunds/create)"
+  }
+);
+var refundUpdateReq = z.object({
+  metadata: metadataSchema.optional()
+});
+var refundListQuery = z.object({
+  ...listCursorFields,
+  /** Only return refunds for this Charge id. */
+  charge: z.string().optional(),
+  /** Only return refunds for this PaymentIntent id. */
+  payment_intent: z.string().optional(),
+  /** Creation-date window (Unix timestamps). */
+  created: createdRange.optional()
+});
+var refund = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  amount: z.number().optional(),
+  /** Balance transaction id string, or an expanded object — kept unknown. */
+  balance_transaction: z.unknown().optional(),
+  /** Charge id string, or an expanded object — kept unknown. */
+  charge: z.unknown().optional(),
+  created: z.number().optional(),
+  currency: z.string().optional(),
+  /** Non-card refunds only. */
+  description: z.string().nullable().optional(),
+  /** Transaction-specific details — child hashes deliberately untyped. */
+  destination_details: z.looseObject({}).nullable().optional(),
+  /** Balance transaction reversing the initial one after a failed refund. */
+  failure_balance_transaction: z.unknown().optional(),
+  /**
+   * `lost_or_stolen_card` | `expired_or_canceled_card` |
+   * `charge_for_pending_refund_disputed` | `insufficient_funds` | `declined` |
+   * `merchant_request` | `unknown` — kept loose (drift logs, never throws).
+   */
+  failure_reason: z.string().nullable().optional(),
+  instructions_email: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.string()).nullable().optional(),
+  /** Present when status is `requires_action` — child shape kept loose. */
+  next_action: z.looseObject({}).nullable().optional(),
+  /** PaymentIntent id string, or an expanded object — kept unknown. */
+  payment_intent: z.unknown().optional(),
+  /** `processing` | `insufficient_funds` | `charge_pending` — kept loose. */
+  pending_reason: z.string().nullable().optional(),
+  /**
+   * `duplicate` | `fraudulent` | `requested_by_customer` or Stripe-generated
+   * `expired_uncaptured_charge` — kept loose.
+   */
+  reason: z.string().nullable().optional(),
+  receipt_number: z.string().nullable().optional(),
+  /** Transfer reversal id string, or an expanded object — kept unknown. */
+  source_transfer_reversal: z.unknown().optional(),
+  /**
+   * `pending` | `requires_action` | `succeeded` | `failed` | `canceled` —
+   * normalization is the unified layer's job.
+   */
+  status: z.string().nullable().optional(),
+  /** Transfer reversal id string, or an expanded object — kept unknown. */
+  transfer_reversal: z.unknown().optional()
+});
+
+// src/stripe/resources/refunds.ts
+var refundListRes = stripeList(refund);
+function bodyIfNonEmpty5(body) {
+  return Object.keys(body).length > 0 ? { body } : {};
+}
+var Refunds = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Create a refund. Target either a `charge` or a `payment_intent` (the
+   * unified layer refunds against the payment intent — providers.md §3.3);
+   * one of the two is required unless `origin: "customer_balance"`. `amount`
+   * is integer MINOR units and defaults to the full remaining unrefunded
+   * amount. Stripe errors if the target is already fully refunded (surfaced
+   * as {@link PayweaveValidationError} with providerCode
+   * `charge_already_refunded` on the 400).
+   *
+   * Money-moving POST: never auto-retried bare — pass `idempotencyKey` to
+   * make it safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/refunds/create
+   *
+   * @example
+   * const re = await payweave.stripe.refunds.create({
+   *   payment_intent: "pi_123",
+   *   amount: 500, // partial refund, minor units
+   *   reason: "requested_by_customer",
+   * }, { idempotencyKey: "order-8123-refund" });
+   * console.log(re.status); // "succeeded" | "pending" | ...
+   */
+  async create(input, opts = {}) {
+    const body = parseRequest(refundCreateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: "/v1/refunds",
+      body,
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: refund
+    });
+  }
+  /**
+   * Retrieve a refund by id (`re_*`). A 404 for an unknown id surfaces as
+   * {@link PayweaveNotFoundError}.
+   *
+   * Docs: https://docs.stripe.com/api/refunds/retrieve
+   *
+   * @example
+   * const re = await payweave.stripe.refunds.retrieve("re_123");
+   * if (re.status === "succeeded") { }
+   */
+  async retrieve(id) {
+    const refundId = requireId(id, "refund");
+    return this.http.request({
+      method: "GET",
+      path: `/v1/refunds/${encodeURIComponent(refundId)}`,
+      schema: refund
+    });
+  }
+  /**
+   * Update a refund. `metadata` is the ONLY updatable field; unset individual
+   * keys by posting an empty string value.
+   *
+   * Docs: https://docs.stripe.com/api/refunds/update
+   *
+   * @example
+   * const re = await payweave.stripe.refunds.update("re_123", {
+   *   metadata: { order_id: "6735" },
+   * });
+   */
+  async update(id, input = {}) {
+    const refundId = requireId(id, "refund");
+    const body = parseRequest(refundUpdateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/refunds/${encodeURIComponent(refundId)}`,
+      ...bodyIfNonEmpty5(body),
+      schema: refund
+    });
+  }
+  /**
+   * Cancel a refund. ONLY valid while the refund's status is
+   * `requires_action` — "you can't cancel refunds in other states" (only
+   * refunds for payment methods that require customer action ever enter that
+   * state); Stripe raises an error otherwise (surfaced as
+   * {@link PayweaveValidationError} on the 400). Takes no body parameters.
+   *
+   * Docs: https://docs.stripe.com/api/refunds/cancel
+   *
+   * @example
+   * const re = await payweave.stripe.refunds.cancel("re_123");
+   * console.log(re.status); // "canceled"
+   */
+  async cancel(id) {
+    const refundId = requireId(id, "refund");
+    return this.http.request({
+      method: "POST",
+      path: `/v1/refunds/${encodeURIComponent(refundId)}/cancel`,
+      schema: refund
+    });
+  }
+  /**
+   * List refunds (newest first). Filter by `charge` or `payment_intent`;
+   * cursor pagination via `limit` + `starting_after`/`ending_before`; the
+   * `created` window becomes bracket query keys (`created[gte]`).
+   *
+   * Docs: https://docs.stripe.com/api/refunds/list
+   *
+   * @example
+   * const page = await payweave.stripe.refunds.list({ payment_intent: "pi_123", limit: 50 });
+   * console.log(page.data.length, page.has_more);
+   */
+  async list(query = {}) {
+    const q = parseRequest(refundListQuery, query);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/refunds",
+      query: flattenQuery(q),
+      schema: refundListRes
+    });
+  }
+  /**
+   * Async iterator over ALL refunds matching `query`, transparently following
+   * `has_more` with `starting_after = <last id>`.
+   *
+   * Docs: https://docs.stripe.com/api/refunds/list
+   *
+   * @example
+   * for await (const re of payweave.stripe.refunds.iterate({ charge: "ch_123" })) {
+   *   console.log(re.id, re.status);
+   * }
+   */
+  async *iterate(query = {}) {
+    const base = parseRequest(refundListQuery, query);
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: "/v1/refunds",
+        query: flattenQuery({ ...base, starting_after: startingAfter }),
+        schema: refundListRes
+      })
+    );
+  }
+};
+var recurring2 = z.object({
+  interval: z.enum(["day", "week", "month", "year"]),
+  interval_count: z.number().int().optional()
+});
+var subscriptionItemPriceData = z.object({
+  /** Three-letter ISO currency code, lowercase (e.g. `usd`). Required. */
+  currency: z.string(),
+  /** Existing Product id (`prod_*`) this price belongs to. Required. */
+  product: z.string(),
+  /** Billing frequency. Required. */
+  recurring: recurring2,
+  tax_behavior: z.enum(["exclusive", "inclusive", "unspecified"]).optional(),
+  /** Amount in the smallest currency unit (minor units) — integer, unchanged. */
+  unit_amount: z.number().int().nonnegative().optional(),
+  /** Decimal string alternative to `unit_amount` (≤12 decimal places). */
+  unit_amount_decimal: z.string().optional()
+});
+var discountParam = z.object({
+  /** Coupon id to create a new discount from. */
+  coupon: z.string().optional(),
+  /** Existing Discount id to reuse. */
+  discount: z.string().optional(),
+  /** Promotion code id to create a new discount from. */
+  promotion_code: z.string().optional()
+});
+var itemBillingThresholds = z.object({
+  usage_gte: z.number().int()
+});
+var paymentBehavior = z.enum([
+  "allow_incomplete",
+  "default_incomplete",
+  "error_if_incomplete",
+  "pending_if_incomplete"
+]);
+var prorationBehavior = z.enum(["always_invoice", "create_prorations", "none"]);
+var subscriptionItemCreateReq = z.object({
+  /** Subscription id (`sub_*`) to add the item to. Required. */
+  subscription: z.string().min(1),
+  /** Saved Price id (`price_*`). Alternative to `price_data`. */
+  price: z.string().optional(),
+  /** Inline price definition. Alternative to `price`. */
+  price_data: subscriptionItemPriceData.optional(),
+  quantity: z.number().int().nonnegative().optional(),
+  metadata: metadataSchema.optional(),
+  billing_thresholds: itemBillingThresholds.optional(),
+  /** Coupons/promotion codes to redeem into discounts for this item. */
+  discounts: z.array(discountParam).optional(),
+  payment_behavior: paymentBehavior.optional(),
+  proration_behavior: prorationBehavior.optional(),
+  /** Unix timestamp — prorate as though the update happened at this time. */
+  proration_date: z.number().int().optional(),
+  /** Tax Rate ids overriding the subscription's `default_tax_rates`. */
+  tax_rates: z.array(z.string()).optional()
+});
+var subscriptionItemUpdateReq = z.object({
+  /** Saved Price id (`price_*`). Alternative to `price_data`. */
+  price: z.string().optional(),
+  /** Inline price definition. Alternative to `price`. */
+  price_data: subscriptionItemPriceData.optional(),
+  quantity: z.number().int().nonnegative().optional(),
+  metadata: metadataSchema.optional(),
+  billing_thresholds: itemBillingThresholds.optional(),
+  /** Coupons/promotion codes to redeem into discounts for this item. */
+  discounts: z.array(discountParam).optional(),
+  /** Customer is not in the flow — attempt payment immediately off-session. */
+  off_session: z.boolean().optional(),
+  payment_behavior: paymentBehavior.optional(),
+  proration_behavior: prorationBehavior.optional(),
+  /** Unix timestamp — prorate as though the update happened at this time. */
+  proration_date: z.number().int().optional(),
+  /** Tax Rate ids overriding the subscription's `default_tax_rates`. */
+  tax_rates: z.array(z.string()).optional()
+});
+var subscriptionItemDeleteReq = z.object({
+  /** Delete all usage for the item — only when the price's `usage_type` is `metered`. */
+  clear_usage: z.boolean().optional(),
+  payment_behavior: paymentBehavior.optional(),
+  proration_behavior: prorationBehavior.optional(),
+  /** Unix timestamp — prorate as though the update happened at this time. */
+  proration_date: z.number().int().optional()
+});
+var subscriptionItemListQuery = z.object({
+  ...listCursorFields,
+  /** Subscription id (`sub_*`) whose items to list. Required. */
+  subscription: z.string().min(1)
+});
+var subscriptionItem = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  /** Parent subscription id (`sub_*`). */
+  subscription: z.string().optional(),
+  /** The Price the customer is subscribed to — kept loose beyond its id. */
+  price: z.looseObject({ id: z.string().optional() }).nullable().optional(),
+  quantity: z.number().nullable().optional(),
+  metadata: z.record(z.string(), z.string()).nullable().optional(),
+  created: z.number().optional(),
+  /** Start of the item's current billing period (Unix timestamp). */
+  current_period_start: z.number().optional(),
+  /** End of the item's current billing period (Unix timestamp). */
+  current_period_end: z.number().optional(),
+  /** Time period the item has been billed for — nullable, expandable. */
+  billed_until: z.unknown().optional(),
+  billing_thresholds: z.looseObject({}).nullable().optional(),
+  /** Discount ids (or expanded objects) — kept unknown. */
+  discounts: z.unknown().optional(),
+  /** Tax Rate objects applied to this item — kept unknown. */
+  tax_rates: z.unknown().optional()
+});
+var subscriptionItemDeleted = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  deleted: z.boolean().optional()
+});
+
+// src/stripe/resources/subscription-items.ts
+var subscriptionItemListRes = stripeList(subscriptionItem);
+function bodyIfNonEmpty6(body) {
+  return Object.keys(body).length > 0 ? { body } : {};
+}
+var SubscriptionItems = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Add a new item (price) to an existing subscription. Prorations follow
+   * `proration_behavior` (default `create_prorations`). Pass `idempotencyKey`
+   * to make the POST safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/subscription_items/create
+   *
+   * @example
+   * const item = await payweave.stripe.subscriptionItems.create({
+   *   subscription: "sub_123",
+   *   price: "price_123",
+   *   quantity: 2,
+   * }, { idempotencyKey: "sub_123-addon-seat" });
+   * console.log(item.id, item.current_period_end);
+   */
+  async create(input, opts = {}) {
+    const body = parseRequest(subscriptionItemCreateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: "/v1/subscription_items",
+      body,
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: subscriptionItem
+    });
+  }
+  /**
+   * Retrieve a subscription item by id (`si_*`). A 404 for an unknown id
+   * surfaces as {@link PayweaveNotFoundError}.
+   *
+   * Docs: https://docs.stripe.com/api/subscription_items/retrieve
+   *
+   * @example
+   * const item = await payweave.stripe.subscriptionItems.retrieve("si_123");
+   * console.log(item.price?.id, item.quantity);
+   */
+  async retrieve(id) {
+    const itemId = requireId(id, "subscription item");
+    return this.http.request({
+      method: "GET",
+      path: `/v1/subscription_items/${encodeURIComponent(itemId)}`,
+      schema: subscriptionItem
+    });
+  }
+  /**
+   * Update a subscription item — switch its `price`, change `quantity`, etc.
+   * Proration parameters (`proration_behavior`, `proration_date`) are passed
+   * through exactly as documented. Pass `idempotencyKey` to make the POST
+   * safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/subscription_items/update
+   *
+   * @example
+   * const item = await payweave.stripe.subscriptionItems.update("si_123", {
+   *   quantity: 5,
+   *   proration_behavior: "create_prorations",
+   * });
+   */
+  async update(id, input = {}, opts = {}) {
+    const itemId = requireId(id, "subscription item");
+    const body = parseRequest(subscriptionItemUpdateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/subscription_items/${encodeURIComponent(itemId)}`,
+      ...bodyIfNonEmpty6(body),
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: subscriptionItem
+    });
+  }
+  /**
+   * Delete an item from its subscription — removing a price the customer was
+   * subscribed to. Optional form params ride the DELETE (`clear_usage` only
+   * for metered prices; prorations per `proration_behavior`). Returns the
+   * `{ id, object, deleted: true }` acknowledgement. A subscription cannot
+   * lose its last item this way — Stripe rejects that with a 400
+   * (surfaced as {@link PayweaveValidationError}); cancel the subscription
+   * instead.
+   *
+   * Docs: https://docs.stripe.com/api/subscription_items/delete
+   *
+   * @example
+   * const gone = await payweave.stripe.subscriptionItems.delete("si_123", {
+   *   proration_behavior: "none",
+   * });
+   * console.log(gone.deleted); // true
+   */
+  async delete(id, input = {}) {
+    const itemId = requireId(id, "subscription item");
+    const body = parseRequest(subscriptionItemDeleteReq, input);
+    return this.http.request({
+      method: "DELETE",
+      path: `/v1/subscription_items/${encodeURIComponent(itemId)}`,
+      ...bodyIfNonEmpty6(body),
+      schema: subscriptionItemDeleted
+    });
+  }
+  /**
+   * List the items of ONE subscription — `subscription` is required by the
+   * API. Cursor pagination: `limit` + `starting_after`/`ending_before`.
+   *
+   * Docs: https://docs.stripe.com/api/subscription_items/list
+   *
+   * @example
+   * const page = await payweave.stripe.subscriptionItems.list({
+   *   subscription: "sub_123",
+   *   limit: 10,
+   * });
+   * console.log(page.data.length, page.has_more);
+   */
+  async list(query) {
+    const q = parseRequest(subscriptionItemListQuery, query);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/subscription_items",
+      query: flattenQuery(q),
+      schema: subscriptionItemListRes
+    });
+  }
+  /**
+   * Async iterator over ALL items of a subscription, transparently following
+   * `has_more` with `starting_after = <last id>`.
+   *
+   * Docs: https://docs.stripe.com/api/subscription_items/list
+   *
+   * @example
+   * for await (const item of payweave.stripe.subscriptionItems.iterate({ subscription: "sub_123" })) {
+   *   console.log(item.id, item.price?.id);
+   * }
+   */
+  async *iterate(query) {
+    const base = parseRequest(subscriptionItemListQuery, query);
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: "/v1/subscription_items",
+        query: flattenQuery({ ...base, starting_after: startingAfter }),
+        schema: subscriptionItemListRes
+      })
+    );
+  }
+};
+var createItemParam = z.object({
+  /** Saved Price id (`price_*`). Alternative to `price_data`. */
+  price: z.string().optional(),
+  /** Inline price definition (recurring required). Alternative to `price`. */
+  price_data: subscriptionItemPriceData.optional(),
+  quantity: z.number().int().nonnegative().optional(),
+  metadata: metadataSchema.optional(),
+  billing_thresholds: itemBillingThresholds.optional(),
+  /** Coupons/promotion codes to redeem into discounts for this item. */
+  discounts: z.array(discountParam).optional(),
+  /** Tax Rate ids overriding the subscription's `default_tax_rates`. */
+  tax_rates: z.array(z.string()).optional()
+});
+var updateItemParam = z.object({
+  /** Existing SubscriptionItem id (`si_*`) to update. */
+  id: z.string().optional(),
+  /** Saved Price id (`price_*`). Alternative to `price_data`. */
+  price: z.string().optional(),
+  /** Inline price definition (recurring required). Alternative to `price`. */
+  price_data: subscriptionItemPriceData.optional(),
+  quantity: z.number().int().nonnegative().optional(),
+  metadata: metadataSchema.optional(),
+  /** Set to `true` to delete the specified item. */
+  deleted: z.boolean().optional(),
+  /** Delete all usage for the item (metered prices). */
+  clear_usage: z.boolean().optional(),
+  billing_thresholds: itemBillingThresholds.optional(),
+  /** Coupons/promotion codes to redeem into discounts for this item. */
+  discounts: z.array(discountParam).optional(),
+  /** Tax Rate ids overriding the subscription's `default_tax_rates`. */
+  tax_rates: z.array(z.string()).optional()
+});
+var cancelAt = z.union([
+  z.number().int(),
+  z.enum(["max_billed_until", "max_period_end", "min_period_end"])
+]);
+var cancellationDetails = z.object({
+  /** Additional comments about why the user canceled. */
+  comment: z.string().optional(),
+  /** The customer-submitted reason for cancellation. */
+  feedback: z.enum([
+    "customer_service",
+    "low_quality",
+    "missing_features",
+    "other",
+    "switched_service",
+    "too_complex",
+    "too_expensive",
+    "unused"
+  ]).optional()
+});
+var trialEnd = z.union([z.literal("now"), z.number().int()]);
+var subscriptionCreateReq = z.object({
+  /**
+   * Customer id (`cus_*`) to subscribe. Stripe requires a customer (the
+   * unverified `customer_account` alternative is untyped in this P0 subset).
+   */
+  customer: z.string().optional(),
+  /** Items being subscribed to — up to 20, each with an attached price. Required. */
+  items: z.array(createItemParam).max(20),
+  /** Past Unix timestamp to backdate the subscription's start date to. */
+  backdate_start_date: z.number().int().optional(),
+  /** Future Unix timestamp anchoring the billing cycle (first full invoice). */
+  billing_cycle_anchor: z.number().int().optional(),
+  /** Unix timestamp or symbolic value at which to auto-cancel. */
+  cancel_at: cancelAt.optional(),
+  /** Cancel at the end of the current period instead of immediately. Default false. */
+  cancel_at_period_end: z.boolean().optional(),
+  collection_method: z.enum(["charge_automatically", "send_invoice"]).optional(),
+  /** Three-letter ISO currency code, lowercase. */
+  currency: z.string().optional(),
+  /** Days until invoices are due — `send_invoice` collection only. */
+  days_until_due: z.number().int().optional(),
+  /** PaymentMethod id (`pm_*`) used as this subscription's default. */
+  default_payment_method: z.string().optional(),
+  /** Source id used as this subscription's default payment source. */
+  default_source: z.string().optional(),
+  /** Tax Rate ids applied by default to the subscription's items. */
+  default_tax_rates: z.array(z.string()).optional(),
+  /** ≤500 chars, displayable to customers. */
+  description: z.string().max(500).optional(),
+  /** Coupons/promotion codes to redeem into discounts for the subscription. */
+  discounts: z.array(discountParam).optional(),
+  metadata: metadataSchema.optional(),
+  /** Customer is not in the checkout flow. Default false. */
+  off_session: z.boolean().optional(),
+  payment_behavior: z.enum(["allow_incomplete", "default_incomplete", "error_if_incomplete"]).optional(),
+  /** Invoice-pending-items schedule between billing cycles. */
+  pending_invoice_item_interval: z.object({
+    interval: z.enum(["day", "month", "week", "year"]),
+    interval_count: z.number().int().optional()
+  }).optional(),
+  proration_behavior: z.enum(["create_prorations", "none"]).optional(),
+  /** Unix timestamp or `"now"` — when the trial ends. */
+  trial_end: trialEnd.optional(),
+  /** Use the price's/plan's trial period. Default false. */
+  trial_from_plan: z.boolean().optional(),
+  /** Trial length in days (alternative to `trial_end`). */
+  trial_period_days: z.number().int().optional(),
+  /** What happens at trial end when no payment method is present. */
+  trial_settings: z.object({
+    end_behavior: z.object({
+      missing_payment_method: z.enum(["cancel", "create_invoice", "pause"])
+    })
+  }).optional()
+});
+var pauseCollection = z.union([
+  z.object({
+    behavior: z.enum(["keep_as_draft", "mark_uncollectible", "void"]),
+    /** Unix timestamp at which collection automatically resumes. */
+    resumes_at: z.number().int().optional()
+  }),
+  z.literal("")
+]);
+var subscriptionUpdateReq = z.object({
+  /** Item changes: update by `id`, add by `price`, remove with `deleted: true`. */
+  items: z.array(updateItemParam).optional(),
+  /** Unix timestamp or symbolic value at which to auto-cancel. */
+  cancel_at: cancelAt.optional(),
+  /** `true` = cancel when the current period ends; `false` = clear a pending one. */
+  cancel_at_period_end: z.boolean().optional(),
+  cancellation_details: cancellationDetails.optional(),
+  /** `now` resets the billing cycle anchor; `unchanged` keeps it. */
+  billing_cycle_anchor: z.enum(["now", "unchanged"]).optional(),
+  collection_method: z.enum(["charge_automatically", "send_invoice"]).optional(),
+  /** Days until invoices are due — `send_invoice` collection only. */
+  days_until_due: z.number().int().optional(),
+  /** PaymentMethod id (`pm_*`) used as this subscription's default. */
+  default_payment_method: z.string().optional(),
+  /** ≤500 chars, displayable to customers. */
+  description: z.string().max(500).optional(),
+  /** Coupons/promotion codes to redeem into discounts for the subscription. */
+  discounts: z.array(discountParam).optional(),
+  metadata: metadataSchema.optional(),
+  /** Customer is not in the checkout flow. Default false. */
+  off_session: z.boolean().optional(),
+  /** Pause payment collection (subscription stays `active`); `""` unsets. */
+  pause_collection: pauseCollection.optional(),
+  payment_behavior: z.enum([
+    "allow_incomplete",
+    "default_incomplete",
+    "error_if_incomplete",
+    "pending_if_incomplete"
+  ]).optional(),
+  proration_behavior: z.enum(["always_invoice", "create_prorations", "none"]).optional(),
+  /** Unix timestamp — prorate as though the update happened at this time. */
+  proration_date: z.number().int().optional(),
+  /** Unix timestamp or `"now"` — when the trial ends. */
+  trial_end: trialEnd.optional()
+});
+var subscriptionCancelReq = z.object({
+  cancellation_details: cancellationDetails.optional(),
+  /** Generate a final invoice for un-invoiced metered usage and pending prorations. Default false. */
+  invoice_now: z.boolean().optional(),
+  /** Credit remaining unused time until the period end via a proration item. Default false. */
+  prorate: z.boolean().optional()
+});
+var subscriptionResumeReq = z.object({
+  /** `now` resets the anchor and starts a new period; `unchanged` keeps it. Default `now`. */
+  billing_cycle_anchor: z.enum(["now", "unchanged"]).optional(),
+  proration_behavior: z.enum(["always_invoice", "create_prorations", "none"]).optional(),
+  /** Unix timestamp — prorate as though resumed at this time. */
+  proration_date: z.number().int().optional()
+});
+var subscriptionListQuery = z.object({
+  ...listCursorFields,
+  /** Filter by Customer id. */
+  customer: z.string().optional(),
+  /** Filter by recurring Price id. */
+  price: z.string().optional(),
+  /**
+   * Status filter. Documented special values (verified 2026-07-12):
+   * `canceled` (includes deleted customers' subscriptions), `ended` (canceled
+   * + expired due to incomplete payment), `all`; omitted = all non-canceled
+   * subscriptions. Kept as an open string — the docs page does not enumerate
+   * a closed value set for this filter (conservative); Stripe
+   * validates server-side.
+   */
+  status: z.string().optional(),
+  collection_method: z.enum(["charge_automatically", "send_invoice"]).optional(),
+  /** Creation-date window (Unix timestamps). */
+  created: createdRange.optional(),
+  /** Current-period-start window (Unix timestamps). */
+  current_period_start: createdRange.optional(),
+  /** Current-period-end window (Unix timestamps). */
+  current_period_end: createdRange.optional()
+});
+var subscription = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  /**
+   * `incomplete` | `incomplete_expired` | `trialing` | `active` | `past_due`
+   * | `canceled` | `unpaid` | `paused` — normalization is the unified layer's
+   * job.
+   */
+  status: z.string().optional(),
+  /** Customer id string, or an expanded object — kept unknown. */
+  customer: z.unknown().optional(),
+  /** Embedded (paginated) list of the subscription's items. */
+  items: stripeList(subscriptionItem).optional(),
+  currency: z.string().optional(),
+  collection_method: z.string().optional(),
+  /** Unix timestamp at which the subscription will auto-cancel. */
+  cancel_at: z.number().nullable().optional(),
+  /** Whether the subscription cancels when the current period ends. */
+  cancel_at_period_end: z.boolean().optional(),
+  /** When the cancellation was requested (Unix timestamp). */
+  canceled_at: z.number().nullable().optional(),
+  /** `{ reason, feedback, comment }` — kept loose. */
+  cancellation_details: z.looseObject({}).nullable().optional(),
+  created: z.number().optional(),
+  /** Start of the subscription (may differ from `created` when backdated). */
+  start_date: z.number().optional(),
+  /** Anchor aligning future billing cycle dates (Unix timestamp). */
+  billing_cycle_anchor: z.number().optional(),
+  trial_start: z.number().nullable().optional(),
+  trial_end: z.number().nullable().optional(),
+  /** When the subscription ended (Unix timestamp). */
+  ended_at: z.number().nullable().optional(),
+  /** Latest Invoice id string, or an expanded object — kept unknown. */
+  latest_invoice: z.unknown().optional(),
+  /** Default PaymentMethod id string, or an expanded object — kept unknown. */
+  default_payment_method: z.unknown().optional(),
+  days_until_due: z.number().nullable().optional(),
+  /** Payment-collection pause state — `{ behavior, resumes_at }`, kept loose. */
+  pause_collection: z.looseObject({}).nullable().optional(),
+  metadata: z.record(z.string(), z.string()).nullable().optional(),
+  description: z.string().nullable().optional(),
+  livemode: z.boolean().optional()
+});
+
+// src/stripe/resources/subscriptions.ts
+var subscriptionListRes = stripeList(subscription);
+function bodyIfNonEmpty7(body) {
+  return Object.keys(body).length > 0 ? { body } : {};
+}
+var Subscriptions = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Create a subscription for an existing customer — the first invoice is
+   * attempted immediately unless a trial or `billing_cycle_anchor` defers it.
+   * `items` (up to 20, each with a `price` or inline `price_data`) is
+   * required. Pass `idempotencyKey` to make the POST safely replayable (and
+   * retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/subscriptions/create
+   *
+   * @example
+   * const sub = await payweave.stripe.subscriptions.create({
+   *   customer: "cus_123",
+   *   items: [{ price: "price_123", quantity: 1 }],
+   *   metadata: { pwv_plan: "pro" },
+   * }, { idempotencyKey: "sub-cus_123-pro" });
+   * console.log(sub.status, sub.items?.data[0]?.current_period_end);
+   */
+  async create(input, opts = {}) {
+    const body = parseRequest(subscriptionCreateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: "/v1/subscriptions",
+      body,
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: subscription
+    });
+  }
+  /**
+   * Retrieve a subscription by id (`sub_*`). A 404 for an unknown id surfaces
+   * as {@link PayweaveNotFoundError}. Period boundaries live on the embedded
+   * items (`sub.items.data[].current_period_start/end`) on the SDK's pinned
+   * API version.
+   *
+   * Docs: https://docs.stripe.com/api/subscriptions/retrieve
+   *
+   * @example
+   * const sub = await payweave.stripe.subscriptions.retrieve("sub_123");
+   * if (sub.status === "active") { }
+   */
+  async retrieve(id) {
+    const subscriptionId = requireId(id, "subscription");
+    return this.http.request({
+      method: "GET",
+      path: `/v1/subscriptions/${encodeURIComponent(subscriptionId)}`,
+      schema: subscription
+    });
+  }
+  /**
+   * Update a subscription: change items/quantities (proration per
+   * `proration_behavior`), schedule an END-OF-PERIOD cancellation with
+   * `cancel_at_period_end: true` (or clear one with `false`), pause payment
+   * collection with `pause_collection` (unset with `""` to resume
+   * collection), etc. For IMMEDIATE cancellation use {@link cancel} instead.
+   * Pass `idempotencyKey` to make the POST safely replayable (and
+   * retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/subscriptions/update
+   *
+   * @example
+   * // Cancel when the current billing period ends — NOT immediate:
+   * const sub = await payweave.stripe.subscriptions.update("sub_123", {
+   *   cancel_at_period_end: true,
+   * });
+   * console.log(sub.status, sub.cancel_at_period_end); // "active", true
+   */
+  async update(id, input = {}, opts = {}) {
+    const subscriptionId = requireId(id, "subscription");
+    const body = parseRequest(subscriptionUpdateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/subscriptions/${encodeURIComponent(subscriptionId)}`,
+      ...bodyIfNonEmpty7(body),
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: subscription
+    });
+  }
+  /**
+   * Cancel a subscription IMMEDIATELY (`DELETE /v1/subscriptions/{id}`) —
+   * the customer is not charged again, and pending prorations are dropped
+   * unless `invoice_now`/`prorate` say otherwise. To cancel at the END of the
+   * current period instead, use
+   * `update(id, { cancel_at_period_end: true })` — the two shapes are
+   * distinct on Stripe and PW-805's state machine relies on that.
+   *
+   * Docs: https://docs.stripe.com/api/subscriptions/cancel
+   *
+   * @example
+   * const sub = await payweave.stripe.subscriptions.cancel("sub_123", {
+   *   invoice_now: true,
+   *   prorate: true,
+   *   cancellation_details: { feedback: "too_expensive" },
+   * });
+   * console.log(sub.status); // "canceled"
+   */
+  async cancel(id, input = {}) {
+    const subscriptionId = requireId(id, "subscription");
+    const body = parseRequest(subscriptionCancelReq, input);
+    return this.http.request({
+      method: "DELETE",
+      path: `/v1/subscriptions/${encodeURIComponent(subscriptionId)}`,
+      ...bodyIfNonEmpty7(body),
+      schema: subscription
+    });
+  }
+  /**
+   * Resume a subscription whose STATUS is `paused` (e.g. a trial that ended
+   * with `trial_settings.end_behavior.missing_payment_method: "pause"`) —
+   * only available under `charge_automatically` collection. Not for paused
+   * payment COLLECTION: unset that via
+   * `update(id, { pause_collection: "" })`. `billing_cycle_anchor` defaults
+   * to `now` (resets the cycle; no prorations); `unchanged` keeps the anchor
+   * and prorates per `proration_behavior`. Pass `idempotencyKey` to make the
+   * POST safely replayable (and retry-eligible).
+   *
+   * Docs: https://docs.stripe.com/api/subscriptions/resume
+   *
+   * @example
+   * const sub = await payweave.stripe.subscriptions.resume("sub_123", {
+   *   billing_cycle_anchor: "now",
+   * });
+   * console.log(sub.status); // "active"
+   */
+  async resume(id, input = {}, opts = {}) {
+    const subscriptionId = requireId(id, "subscription");
+    const body = parseRequest(subscriptionResumeReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/subscriptions/${encodeURIComponent(subscriptionId)}/resume`,
+      ...bodyIfNonEmpty7(body),
+      ...opts.idempotencyKey !== void 0 ? { idempotencyKey: opts.idempotencyKey } : {},
+      schema: subscription
+    });
+  }
+  /**
+   * List subscriptions. By default only non-canceled subscriptions are
+   * returned — pass `status: "canceled"`, `"ended"`, or `"all"` to widen.
+   * Filters are query params; range filters become bracket keys
+   * (`current_period_end[gte]`).
+   *
+   * Docs: https://docs.stripe.com/api/subscriptions/list
+   *
+   * @example
+   * const page = await payweave.stripe.subscriptions.list({
+   *   customer: "cus_123",
+   *   status: "all",
+   *   limit: 50,
+   * });
+   * console.log(page.data.length, page.has_more);
+   */
+  async list(query = {}) {
+    const q = parseRequest(subscriptionListQuery, query);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/subscriptions",
+      query: flattenQuery(q),
+      schema: subscriptionListRes
+    });
+  }
+  /**
+   * Async iterator over ALL subscriptions matching `query`, transparently
+   * following `has_more` with `starting_after = <last id>`.
+   *
+   * Docs: https://docs.stripe.com/api/subscriptions/list
+   *
+   * @example
+   * for await (const sub of payweave.stripe.subscriptions.iterate({ customer: "cus_123" })) {
+   *   console.log(sub.id, sub.status);
+   * }
+   */
+  async *iterate(query = {}) {
+    const base = parseRequest(subscriptionListQuery, query);
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: "/v1/subscriptions",
+        query: flattenQuery({ ...base, starting_after: startingAfter }),
+        schema: subscriptionListRes
+      })
+    );
+  }
+};
+var enabledEvents = z.array(z.string()).min(1);
+var webhookEndpointCreateReq = z.object({
+  /** The URL of the webhook endpoint. Required. */
+  url: z.string(),
+  /**
+   * The list of events to enable for this endpoint; `["*"]` enables all
+   * events except those that require explicit selection. Required. Encodes as
+   * `enabled_events[0]=...`.
+   */
+  enabled_events: enabledEvents,
+  /**
+   * Events sent to this endpoint are rendered with this Stripe version
+   * instead of the account default.
+   */
+  api_version: z.string().optional(),
+  /**
+   * `true` = receive events from connected accounts; `false` (default) = from
+   * your own account.
+   */
+  connect: z.boolean().optional(),
+  /** Optional description of what the webhook is used for. */
+  description: z.string().optional(),
+  metadata: metadataSchema.optional()
+});
+var webhookEndpointUpdateReq = z.object({
+  /** Optional description of what the webhook is used for. */
+  description: z.string().optional(),
+  /** Disable the webhook endpoint if set to true. */
+  disabled: z.boolean().optional(),
+  /** Replacement list of enabled events (`["*"]` = all). */
+  enabled_events: enabledEvents.optional(),
+  metadata: metadataSchema.optional(),
+  /** The URL of the webhook endpoint. */
+  url: z.string().optional()
+});
+var webhookEndpointListQuery = z.object({
+  ...listCursorFields
+});
+var webhookEndpoint = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  /** API version events are rendered as for this endpoint. */
+  api_version: z.string().nullable().optional(),
+  /** ID of the associated Connect application. */
+  application: z.string().nullable().optional(),
+  created: z.number().optional(),
+  description: z.string().nullable().optional(),
+  /** `["*"]` indicates all events (except explicit-selection ones). */
+  enabled_events: z.array(z.string()).optional(),
+  livemode: z.boolean().optional(),
+  metadata: z.record(z.string(), z.string()).nullable().optional(),
+  /**
+   * The endpoint's signing secret (`whsec_*`), used to verify webhook
+   * signatures. ⚠️ "Only returned at creation"
+   * (https://docs.stripe.com/api/webhook_endpoints/object — verified
+   * 2026-07-12) — capture it from the `create` response or it is gone;
+   * retrieve/update/list never include it. Store it as the provider config's
+   * `webhookSecret`; core `redact` masks it from all logs.
+   */
+  secret: z.string().optional(),
+  /** `enabled` | `disabled` — kept loose (drift logs, never throws). */
+  status: z.string().optional(),
+  url: z.string().optional()
+});
+var webhookEndpointDeleted = z.looseObject({
+  id: z.string(),
+  object: z.string().optional(),
+  deleted: z.boolean().optional()
+});
+
+// src/stripe/resources/webhook-endpoints.ts
+var webhookEndpointListRes = stripeList(webhookEndpoint);
+function bodyIfNonEmpty8(body) {
+  return Object.keys(body).length > 0 ? { body } : {};
+}
+var WebhookEndpoints = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Create a webhook endpoint. `url` and `enabled_events` are required;
+   * `enabled_events` bracket-encodes as `enabled_events[0]=...` and `["*"]`
+   * enables all events (except those requiring explicit selection).
+   *
+   * ⚠️ The response is the ONLY place the endpoint's `whsec_*` signing
+   * `secret` is ever returned ("Only returned at creation") — persist it
+   * immediately (e.g. as the `stripe.webhookSecret` config) or it cannot be
+   * recovered; retrieve/update/list responses never include it.
+   *
+   * Docs: https://docs.stripe.com/api/webhook_endpoints/create
+   *
+   * @example
+   * const we = await payweave.stripe.webhookEndpoints.create({
+   *   url: "https://example.com/payweave/webhooks",
+   *   enabled_events: ["checkout.session.completed", "payment_intent.succeeded"],
+   * });
+   * const signingSecret = we.secret; // whsec_* — shown ONCE, store it now
+   */
+  async create(input) {
+    const body = parseRequest(webhookEndpointCreateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: "/v1/webhook_endpoints",
+      body,
+      schema: webhookEndpoint
+    });
+  }
+  /**
+   * Retrieve a webhook endpoint by id (`we_*`). The response does NOT include
+   * the signing `secret` (create-only). A 404 for an unknown id surfaces as
+   * {@link PayweaveNotFoundError}.
+   *
+   * Docs: https://docs.stripe.com/api/webhook_endpoints/retrieve
+   *
+   * @example
+   * const we = await payweave.stripe.webhookEndpoints.retrieve("we_123");
+   * console.log(we.status, we.enabled_events);
+   */
+  async retrieve(id) {
+    const endpointId = requireId(id, "webhook endpoint");
+    return this.http.request({
+      method: "GET",
+      path: `/v1/webhook_endpoints/${encodeURIComponent(endpointId)}`,
+      schema: webhookEndpoint
+    });
+  }
+  /**
+   * Update a webhook endpoint (`description`, `enabled_events`, `url`,
+   * `metadata`, or `disabled: true` to disable it). The response does NOT
+   * include the signing `secret` (create-only).
+   *
+   * Docs: https://docs.stripe.com/api/webhook_endpoints/update
+   *
+   * @example
+   * const we = await payweave.stripe.webhookEndpoints.update("we_123", {
+   *   disabled: true,
+   * });
+   * console.log(we.status); // "disabled"
+   */
+  async update(id, input = {}) {
+    const endpointId = requireId(id, "webhook endpoint");
+    const body = parseRequest(webhookEndpointUpdateReq, input);
+    return this.http.request({
+      method: "POST",
+      path: `/v1/webhook_endpoints/${encodeURIComponent(endpointId)}`,
+      ...bodyIfNonEmpty8(body),
+      schema: webhookEndpoint
+    });
+  }
+  /**
+   * Delete a webhook endpoint. Returns `{ id, object, deleted: true }`;
+   * deleting an already-deleted endpoint raises a Stripe error (404 →
+   * {@link PayweaveNotFoundError}). `payweave listen` calls this on
+   * teardown.
+   *
+   * Docs: https://docs.stripe.com/api/webhook_endpoints/delete
+   *
+   * @example
+   * const gone = await payweave.stripe.webhookEndpoints.delete("we_123");
+   * console.log(gone.deleted); // true
+   */
+  async delete(id) {
+    const endpointId = requireId(id, "webhook endpoint");
+    return this.http.request({
+      method: "DELETE",
+      path: `/v1/webhook_endpoints/${encodeURIComponent(endpointId)}`,
+      schema: webhookEndpointDeleted
+    });
+  }
+  /**
+   * List webhook endpoints. Cursor pagination only (`limit` +
+   * `starting_after`/`ending_before`) — no other documented filters.
+   * Responses never include signing secrets.
+   *
+   * Docs: https://docs.stripe.com/api/webhook_endpoints/list
+   *
+   * @example
+   * const page = await payweave.stripe.webhookEndpoints.list({ limit: 20 });
+   * console.log(page.data.map((we) => we.url));
+   */
+  async list(query = {}) {
+    const q = parseRequest(webhookEndpointListQuery, query);
+    return this.http.request({
+      method: "GET",
+      path: "/v1/webhook_endpoints",
+      query: flattenQuery(q),
+      schema: webhookEndpointListRes
+    });
+  }
+  /**
+   * Async iterator over ALL webhook endpoints, transparently following
+   * `has_more` with `starting_after = <last id>`.
+   *
+   * Docs: https://docs.stripe.com/api/webhook_endpoints/list
+   *
+   * @example
+   * for await (const we of payweave.stripe.webhookEndpoints.iterate()) {
+   *   console.log(we.id, we.url, we.status);
+   * }
+   */
+  async *iterate(query = {}) {
+    const base = parseRequest(webhookEndpointListQuery, query);
+    yield* iterateStripeList(
+      (startingAfter) => this.http.request({
+        method: "GET",
+        path: "/v1/webhook_endpoints",
+        query: flattenQuery({ ...base, starting_after: startingAfter }),
+        schema: webhookEndpointListRes
+      })
+    );
+  }
+};
+
+// src/stripe/client.ts
+var StripeClient = class {
+  /** Shared HTTP client every Stripe resource is constructed with. */
+  http;
+  /** Checkout namespace (`payweave.stripe.checkout.sessions.create(...)`). */
+  checkout;
+  /** PaymentIntents: create, retrieve, confirm, capture, cancel, list/iterate. */
+  paymentIntents;
+  /** Customers: create, retrieve, update, delete, list/iterate, search/iterateSearch. */
+  customers;
+  /** Products: create, retrieve, update, delete, list/iterate, search/iterateSearch. */
+  products;
+  /** Prices: create, retrieve, update, list/iterate, search/iterateSearch (no delete — prices are archived). */
+  prices;
+  /** Subscriptions: create, retrieve, update, cancel, resume, list/iterate. */
+  subscriptions;
+  /** SubscriptionItems: create, retrieve, update, delete, list/iterate. */
+  subscriptionItems;
+  /** Refunds: create (idempotencyKey), retrieve, update, cancel, list/iterate. */
+  refunds;
+  /** WebhookEndpoints: create (secret shown ONCE), retrieve, update, delete, list/iterate. */
+  webhookEndpoints;
+  constructor(http) {
+    this.http = http;
+    this.checkout = { sessions: new CheckoutSessions(this.http) };
+    this.paymentIntents = new PaymentIntents(this.http);
+    this.customers = new Customers(this.http);
+    this.products = new Products(this.http);
+    this.prices = new Prices(this.http);
+    this.subscriptions = new Subscriptions(this.http);
+    this.subscriptionItems = new SubscriptionItems(this.http);
+    this.refunds = new Refunds(this.http);
+    this.webhookEndpoints = new WebhookEndpoints(this.http);
+  }
+};
+function stripeHttp(cfg) {
+  return new HttpClient(stripeHttpOptions(cfg));
+}
+defineProvider({
+  id: "stripe",
+  configKey: "stripe",
+  configSchema: stripeProviderConfigSchema,
+  environments: {
+    // One host for both — Stripe's environment is key-derived, not host-derived.
+    test: { baseUrl: STRIPE_BASE_URL },
+    live: { baseUrl: STRIPE_BASE_URL }
+  },
+  inferEnvironment: (secretKey) => {
+    try {
+      return inferEnvironment("stripe", secretKey);
+    } catch {
+      return null;
+    }
+  },
+  createHttp: stripeHttp,
+  webhooks: {
+    signatureHeader: "stripe-signature",
+    verify: ({ rawBody, headers, secret }) => verifyStripe(rawBody, readHeader(headers, "stripe-signature"), secret),
+    parse: (rawBody) => {
+      const root = JSON.parse(rawBody);
+      return {
+        type: typeof root.type === "string" ? root.type : "unknown",
+        data: root.data,
+        raw: root,
+        ...typeof root.id === "string" ? { id: root.id } : {}
+      };
+    },
+    toUnified: (e) => ({
+      provider: "stripe",
+      type: e.type,
+      unifiedType: toUnifiedEventType("stripe", void 0, e.type, e.data),
+      data: e.data,
+      raw: e.raw
+    })
+  }
+});
+function isBillingCapableProvider(provider) {
+  return BILLING_CAPABLE_PROVIDERS.includes(provider);
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+    );
+    return `{${entries.map(([key, val]) => `${JSON.stringify(key)}:${stableStringify(val)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function planPriceHash(plan2) {
+  const price2 = plan2.price;
+  const payload = price2 ? { amount: price2.amount, currency: price2.currency, interval: price2.interval } : null;
+  return createHash("sha256").update(stableStringify(payload)).digest("hex");
+}
+function planPaystackHash(plan2) {
+  const price2 = plan2.price;
+  const payload = {
+    name: plan2.name ?? null,
+    price: price2 ? { amount: price2.amount, currency: price2.currency, interval: price2.interval } : null
+  };
+  return createHash("sha256").update(stableStringify(payload)).digest("hex");
+}
+function buildFeatures(plan2) {
+  const out = {};
+  for (const inclusion of plan2.includes) {
+    out[inclusion.featureId] = inclusion.type === "boolean" ? { type: "boolean" } : { type: "metered", limit: inclusion.limit, reset: inclusion.reset };
+  }
+  return out;
+}
+async function findStripeProduct(stripe, planId) {
+  const found = await stripe.products.search({ query: `metadata['pwv_plan']:'${planId}'` });
+  return found.data[0];
+}
+async function findStripePrice(stripe, planId, hash) {
+  const found = await stripe.prices.search({
+    query: `metadata['pwv_plan']:'${planId}' AND metadata['pwv_hash']:'${hash}'`
+  });
+  return found.data[0];
+}
+async function syncStripe(stripe, plan2, existingVersion) {
+  const price2 = plan2.price;
+  if (!price2) throw new PayweaveConfigError(`plan "${plan2.id}" has no price to sync to stripe.`);
+  const priceHash = planPriceHash(plan2);
+  const prevRefs = existingVersion?.providerRefs.stripe;
+  const prevProductId = prevRefs?.productId;
+  const prevPriceId = prevRefs?.priceId;
+  const nameChanged = (existingVersion?.name ?? null) !== (plan2.name ?? null);
+  const priceChanged = prevRefs?.hash !== priceHash;
+  if (prevProductId !== void 0 && prevPriceId !== void 0 && !nameChanged && !priceChanged) {
+    return { refs: { productId: prevProductId, priceId: prevPriceId, hash: priceHash }, action: "unchanged" };
+  }
+  let created = false;
+  let adopted = false;
+  let productId = prevProductId;
+  if (productId === void 0) {
+    const found = await findStripeProduct(stripe, plan2.id);
+    if (found) {
+      productId = found.id;
+      adopted = true;
+    } else {
+      const createdProduct = await stripe.products.create(
+        { name: plan2.name ?? plan2.id, metadata: { pwv_plan: plan2.id } },
+        { idempotencyKey: `pwv-push-product-${plan2.id}` }
+      );
+      productId = createdProduct.id;
+      created = true;
+    }
+  } else if (nameChanged) {
+    await stripe.products.update(productId, {
+      name: plan2.name ?? plan2.id,
+      metadata: { pwv_plan: plan2.id }
+    });
+  }
+  let priceId = prevPriceId;
+  if (priceId === void 0 || priceChanged) {
+    const foundPrice = await findStripePrice(stripe, plan2.id, priceHash);
+    if (foundPrice) {
+      priceId = foundPrice.id;
+      adopted = true;
+    } else {
+      const createdPrice = await stripe.prices.create(
+        {
+          currency: price2.currency.toLowerCase(),
+          unit_amount: price2.amount,
+          recurring: { interval: price2.interval },
+          product: productId,
+          metadata: { pwv_plan: plan2.id, pwv_hash: priceHash }
+        },
+        { idempotencyKey: `pwv-push-price-${plan2.id}-${priceHash}` }
+      );
+      priceId = createdPrice.id;
+      created = true;
+    }
+    if (prevPriceId !== void 0 && prevPriceId !== priceId) {
+      await stripe.prices.update(prevPriceId, { active: false });
+    }
+  }
+  return {
+    refs: { productId, priceId, hash: priceHash },
+    action: adopted ? "adopted" : created ? "created" : "unchanged"
+  };
+}
+var PAYSTACK_INTERVAL = {
+  month: "monthly",
+  year: "annually"
+};
+function encodePaystackTag(tag) {
+  return JSON.stringify(tag);
+}
+function decodePaystackTag(description) {
+  if (description === null || description === void 0) return void 0;
+  try {
+    const parsed = JSON.parse(description);
+    if (parsed !== null && typeof parsed === "object" && typeof parsed.pwv_plan === "string" && typeof parsed.pwv_hash === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function findAdoptablePaystackPlan(paystack, planId, hash) {
+  for await (const candidate of paystack.plans.iterate()) {
+    const tag = decodePaystackTag(candidate.description ?? void 0);
+    if (tag?.pwv_plan === planId && tag.pwv_hash === hash) {
+      const code = candidate.plan_code;
+      if (code !== void 0) return code;
+    }
+  }
+  return void 0;
+}
+async function syncPaystack(paystack, plan2, existingVersion) {
+  const price2 = plan2.price;
+  if (!price2) throw new PayweaveConfigError(`plan "${plan2.id}" has no price to sync to paystack.`);
+  const hash = planPaystackHash(plan2);
+  const prevRefs = existingVersion?.providerRefs.paystack;
+  const prevPlanCode = prevRefs?.planCode;
+  if (prevPlanCode !== void 0 && prevRefs?.hash === hash) {
+    return { refs: { planCode: prevPlanCode, hash }, action: "unchanged" };
+  }
+  const adoptedCode = await findAdoptablePaystackPlan(paystack, plan2.id, hash);
+  if (adoptedCode !== void 0) {
+    return { refs: { planCode: adoptedCode, hash }, action: "adopted" };
+  }
+  const created = await paystack.plans.create({
+    name: plan2.name ?? plan2.id,
+    amount: price2.amount,
+    interval: PAYSTACK_INTERVAL[price2.interval],
+    currency: price2.currency,
+    description: encodePaystackTag({ pwv_plan: plan2.id, pwv_hash: hash })
+  });
+  const planCode = created.data.plan_code;
+  if (planCode === void 0) {
+    throw new PayweaveProviderError("paystack created a plan without a plan_code", {
+      provider: "paystack"
+    });
+  }
+  return { refs: { planCode, hash }, action: "created" };
+}
+async function pushPlanToProvider(ctx, provider, plan2, existingVersion) {
+  if (provider === "stripe") {
+    if (!ctx.stripe) throw new PayweaveConfigError("stripe is not configured on this client.");
+    return syncStripe(ctx.stripe, plan2, existingVersion);
+  }
+  if (provider === "paystack") {
+    if (!ctx.paystack) throw new PayweaveConfigError("paystack is not configured on this client.");
+    return syncPaystack(ctx.paystack, plan2, existingVersion);
+  }
+  throw new PayweaveConfigError(
+    `payweave.sync() does not support pushing plans to "${provider}" yet \u2014 its payment-plan mapping is deferred pending further API verification; billing-capable providers: ${BILLING_CAPABLE_PROVIDERS.join(", ")}.`
+  );
+}
+function planVersionInput(plan2, providerRefs) {
+  return {
+    planId: plan2.id,
+    group: resolvePlanGroup(plan2),
+    isDefault: plan2.default,
+    name: plan2.name ?? null,
+    priceMinor: plan2.price?.amount ?? null,
+    priceCurrency: plan2.price?.currency ?? null,
+    priceInterval: plan2.price?.interval ?? null,
+    features: buildFeatures(plan2),
+    providerRefs
+  };
+}
+async function sync(ctx) {
+  const database = ctx.database;
+  if (!database) {
+    throw new PayweaveConfigError(
+      "payweave.sync() needs a database \u2014 pass a payweave/db/* adapter to createPayweave()."
+    );
+  }
+  const products = ctx.products;
+  if (!products) {
+    throw new PayweaveConfigError(
+      "payweave.sync() needs products \u2014 pass a `products` array to createPayweave()."
+    );
+  }
+  const billingProviders = ctx.providers.filter(isBillingCapableProvider);
+  const skippedProviders = ctx.providers.filter((provider) => !isBillingCapableProvider(provider));
+  const plans = [];
+  for (const plan2 of products) {
+    const existingVersion = await database.plans.getActiveVersion(plan2.id);
+    const providerRefs = {};
+    const providerActions = {};
+    if (plan2.price !== void 0) {
+      for (const provider of billingProviders) {
+        const result = await pushPlanToProvider(ctx, provider, plan2, existingVersion);
+        providerRefs[provider] = result.refs;
+        providerActions[provider] = result.action;
+      }
+    }
+    const pushed = await database.plans.pushVersion(planVersionInput(plan2, providerRefs));
+    plans.push({
+      planId: plan2.id,
+      version: pushed.version,
+      versionChanged: existingVersion === null || existingVersion.version !== pushed.version,
+      providers: providerActions
+    });
+  }
+  return { plans, skippedProviders };
+}
+
+// src/products/usage.ts
+function requireDatabase(ctx, method) {
+  if (!ctx.database) {
+    throw new PayweaveConfigError(
+      `payweave.${method}() needs a database \u2014 pass a payweave/db/* adapter to createPayweave().`
+    );
+  }
+  return ctx.database;
+}
+function assertPositiveSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new PayweaveValidationError(`${name} must be a positive safe integer \u2014 got ${value}`);
+  }
+}
+async function resolveFeatureContext(ctx, database, customerId, featureId) {
+  const products = ctx.products ?? [];
+  let type;
+  let group;
+  for (const p of products) {
+    const inc = p.includes.find((i) => i.featureId === featureId);
+    if (inc) {
+      type = inc.type;
+      group = resolvePlanGroup(p);
+      break;
+    }
+  }
+  if (type === void 0 || group === void 0) {
+    throw new PayweaveValidationError(
+      `unknown feature "${featureId}" \u2014 configure it in \`products\`.`
+    );
+  }
+  let customerRow = await database.customers.getByExternalId(customerId);
+  if (customerRow === null) {
+    customerRow = await database.customers.upsert({ externalId: customerId });
+  }
+  const subscription2 = await database.subscriptions.getActive(customerRow.id, group);
+  if (subscription2) {
+    const plan2 = products.find((p) => p.id === subscription2.planId);
+    if (!plan2) {
+      throw new PayweaveValidationError(
+        `customer's active subscription references plan "${subscription2.planId}", which is no longer in \`products\` \u2014 was it renamed or removed?`
+      );
+    }
+    const inclusion2 = plan2.includes.find((i) => i.featureId === featureId);
+    return { group, type, plan: plan2, inclusion: inclusion2, subscription: subscription2, customerRow };
+  }
+  const defaultPlan = products.find((p) => p.default && resolvePlanGroup(p) === group);
+  if (!defaultPlan) {
+    throw new PayweaveConfigError(
+      `group "${group}" has no default plan \u2014 check()/report() need one to answer for a customer with no active subscription in that group.`
+    );
+  }
+  const inclusion = defaultPlan.includes.find((i) => i.featureId === featureId);
+  return { group, type, plan: defaultPlan, inclusion, subscription: null, customerRow };
+}
+async function buildMeteredInit(database, resolved, inclusion, now) {
+  const isPaid = resolved.plan.price !== void 0;
+  const anchor = isPaid && resolved.subscription ? resolved.subscription.currentPeriodStart : now;
+  const planVersion = resolved.subscription ? resolved.subscription.planVersion : (await database.plans.getActiveVersion(resolved.plan.id))?.version ?? 1;
+  return {
+    limit: inclusion.limit,
+    resetInterval: inclusion.reset,
+    anchor,
+    planId: resolved.plan.id,
+    planVersion
+  };
+}
+async function check(ctx, input) {
+  const database = requireDatabase(ctx, "check");
+  const resolved = await resolveFeatureContext(ctx, database, input.customerId, input.featureId);
+  if (resolved.type === "boolean") {
+    return {
+      allowed: resolved.inclusion !== void 0,
+      balance: null,
+      limit: null,
+      resetsAt: null,
+      planId: resolved.plan.id
+    };
+  }
+  if (!resolved.inclusion) {
+    return { allowed: false, balance: null, limit: null, resetsAt: null, planId: resolved.plan.id };
+  }
+  const inclusion = resolved.inclusion;
+  const now = /* @__PURE__ */ new Date();
+  const init = await buildMeteredInit(database, resolved, inclusion, now);
+  const conditional = input.consume === true;
+  const amount = conditional ? 1 : 0;
+  const result = await database.balances.consume({
+    customerId: resolved.customerRow.id,
+    featureId: input.featureId,
+    group: resolved.group,
+    amount,
+    conditional,
+    init,
+    now
+  });
+  const balance = result.limit - result.used;
+  return {
+    allowed: conditional ? result.applied : balance > 0,
+    balance,
+    limit: result.limit,
+    resetsAt: result.periodEnd,
+    planId: resolved.plan.id
+  };
+}
+async function report(ctx, input) {
+  const database = requireDatabase(ctx, "report");
+  const amount = input.amount ?? 1;
+  assertPositiveSafeInteger(amount, "amount");
+  const resolved = await resolveFeatureContext(ctx, database, input.customerId, input.featureId);
+  if (resolved.type === "boolean") {
+    throw new PayweaveValidationError(
+      `report() only accepts metered features \u2014 "${input.featureId}" is a boolean feature.`
+    );
+  }
+  if (!resolved.inclusion) {
+    throw new PayweaveValidationError(
+      `report(): feature "${input.featureId}" is not included in customer "${input.customerId}"'s current plan "${resolved.plan.id}" \u2014 call check() first, which answers { allowed: false } for a plan lacking a feature.`
+    );
+  }
+  const inclusion = resolved.inclusion;
+  const now = /* @__PURE__ */ new Date();
+  const init = await buildMeteredInit(database, resolved, inclusion, now);
+  const result = await database.balances.consume({
+    customerId: resolved.customerRow.id,
+    featureId: input.featureId,
+    group: resolved.group,
+    amount,
+    conditional: false,
+    init,
+    now
+  });
+  return { balance: result.limit - result.used, resetsAt: result.periodEnd };
+}
+
+// src/index.ts
+function buildAuth(resolved) {
+  if (resolved.provider === "flutterwave" && resolved.version === "v4") {
+    if (!resolved.clientId || !resolved.clientSecret || !resolved.tokenUrl) {
+      throw new PayweaveConfigError("Flutterwave v4 requires clientId, clientSecret, and a token URL.", {
+        provider: "flutterwave"
+      });
+    }
+    return oauthClientCredentials({
+      clientId: resolved.clientId,
+      clientSecret: resolved.clientSecret,
+      tokenUrl: resolved.tokenUrl,
+      ...resolved.fetch ? { fetch: resolved.fetch } : {},
+      ...resolved.logger ? { logger: resolved.logger } : {}
+    });
+  }
+  if (!resolved.secretKey) {
+    throw new PayweaveConfigError(`Missing secret key for ${resolved.provider}.`, {
+      provider: resolved.provider
+    });
+  }
+  return bearer(resolved.secretKey);
+}
+function buildHttpClient(resolved) {
+  return new HttpClient({
+    baseUrl: resolved.baseUrl,
+    auth: buildAuth(resolved),
+    provider: resolved.provider,
+    version: resolved.version,
+    timeoutMs: resolved.timeoutMs,
+    maxRetries: resolved.maxRetries,
+    fetch: resolved.fetch,
+    logger: resolved.logger,
+    userAgent: `payweave/${SDK_VERSION} (${resolved.provider})`
+  });
+}
+function stripeUnifiedNamespace() {
+  const notImplemented = (op) => Promise.reject(
+    new PayweaveError(
+      `stripe unified "${op}" is supported in principle but not implemented yet \u2014 the resource endpoints landed, but the unified mapping (\`src/unified/stripe.ts\`) has not. Use the per-call \`provider\` override to route to another configured provider, or call the Surface A \`payweave.stripe.*\` resources directly.`,
+      { provider: "stripe", isRetryable: false }
+    )
+  );
+  const capabilityGap = (op) => {
+    try {
+      assertUnifiedCapability("stripe", op);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    return Promise.reject(new PayweaveError(`${op} is not supported on stripe.`, { provider: "stripe" }));
+  };
+  return {
+    checkout: { create: () => notImplemented("checkout.create") },
+    verify: () => notImplemented("verify"),
+    refunds: { create: () => notImplemented("refunds.create") },
+    transfers: { create: () => capabilityGap("transfers.create") },
+    banks: {
+      list: () => capabilityGap("banks.list"),
+      resolveAccount: () => capabilityGap("banks.resolveAccount")
+    }
+  };
+}
+function createPayweave(config) {
+  const resolved = resolvePayweaveConfig(config);
+  const surfaces = {};
+  const unifiedByProvider = {};
+  for (const key of resolved.providers) {
+    const entry = resolved.providerConfigs[key];
+    if (entry === void 0) continue;
+    if (key === "paystack") {
+      const http = buildHttpClient(entry);
+      surfaces.paystack = new PaystackClient(http);
+      unifiedByProvider.paystack = createPaystackUnified(http);
+    } else if (key === "flutterwave") {
+      const http = buildHttpClient(entry);
+      const version = entry.version === "v4" ? "v4" : "v3";
+      surfaces.flutterwave = new FlutterwaveClient(http, version, entry.encryptionKey);
+      unifiedByProvider.flutterwave = createFlutterwaveUnified(http, version);
+    } else {
+      surfaces.stripe = new StripeClient(new HttpClient(stripeHttpOptions(entry)));
+      unifiedByProvider.stripe = stripeUnifiedNamespace();
+    }
+  }
+  const routeTo = (override) => {
+    const key = override ?? resolved.defaultProvider;
+    const ns = unifiedByProvider[key];
+    if (ns === void 0) {
+      throw new PayweaveConfigError(
+        `provider "${key}" is not configured on this client \u2014 configured: ${resolved.providers.join(", ")}.`,
+        { provider: key }
+      );
+    }
+    return ns;
+  };
+  const guardedRoute = (op, override) => {
+    const ns = routeTo(override);
+    assertUnifiedCapability(override ?? resolved.defaultProvider, op);
+    return ns;
+  };
+  const unified = {
+    checkout: {
+      create: ({ provider, ...input }) => guardedRoute("checkout.create", provider).checkout.create(input)
+    },
+    verify: ({ provider, ...input }) => guardedRoute("verify", provider).verify(input),
+    refunds: {
+      create: ({ provider, ...input }) => guardedRoute("refunds.create", provider).refunds.create(input)
+    },
+    transfers: {
+      create: ({ provider, ...input }) => guardedRoute("transfers.create", provider).transfers.create(input)
+    },
+    banks: {
+      list: ({ provider, ...input }) => guardedRoute("banks.list", provider).banks.list(input),
+      resolveAccount: ({ provider, ...input }) => guardedRoute("banks.resolveAccount", provider).banks.resolveAccount(input)
+    }
+  };
+  function capabilities(provider) {
+    if (provider !== void 0) {
+      if (!resolved.providers.includes(provider)) {
+        throw new PayweaveConfigError(
+          `provider "${provider}" is not configured on this client \u2014 configured: ${resolved.providers.join(", ")}.`,
+          { provider }
+        );
+      }
+      return UNIFIED_CAPABILITY_MATRIX[provider];
+    }
+    const out = {};
+    for (const key of resolved.providers) out[key] = UNIFIED_CAPABILITY_MATRIX[key];
+    return out;
+  }
+  const billingContext = {
+    database: resolved.database,
+    products: resolved.products,
+    providers: resolved.providers,
+    defaultProvider: resolved.defaultProvider,
+    stripe: surfaces.stripe,
+    paystack: surfaces.paystack
+  };
+  const client = {
+    providers: resolved.providers,
+    defaultProvider: resolved.defaultProvider,
+    environment: resolved.environment,
+    // Multi-provider header dispatch: the
+    // provider is detected from the signature header NAME, then verified with
+    // that provider's existing timing-safe verifier — fail closed on
+    // unconfigured/ambiguous/unknown headers. `billingContext` (below) is
+    // threaded through so every constructed event's `.apply()` can
+    // reach the database — the same object the billing surface below uses.
+    webhooks: createWebhookDispatch(resolved, billingContext),
+    checkout: unified.checkout,
+    verify: unified.verify,
+    refunds: unified.refunds,
+    transfers: unified.transfers,
+    banks: unified.banks,
+    capabilities,
+    // See `PayweaveClientBase.database`'s doc comment.
+    database: resolved.database,
+    products: resolved.products,
+    subscribe: (input) => subscribe(billingContext, input),
+    // BillingSync push.
+    sync: () => sync(billingContext),
+    // metered usage (real implementations, not stubs).
+    check: (input) => check(billingContext, input),
+    report: (input) => report(billingContext, input),
+    ...surfaces
+  };
+  return Object.freeze(client);
+}
+
+export { StripeClient, createPayweave };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map