@fantastic.dev/better-stripe 0.14.0 → 0.16.0

package/src/client/billing/intents.ts

@@ -0,0 +1,120 @@
+import type Stripe from "stripe";
+import type { Component, RunCtx } from "../helpers.js";
+import { stripReservedMetadata } from "../helpers.js";
+import { idempotencyOptions } from "../core/idempotency.js";
+import { componentRef } from "../webhooks/helpers.js";
+
+/** Host must derive userId from authentication and authorize the purchase. */
+export type IntentScope = {
+  userId: string;
+  customerAccount?: string;
+  /** Persist the logical request and its immutable inputs before calling. */
+  idempotencyKey: string;
+  /** Server-selected attribution only. Never forward arbitrary browser metadata. */
+  metadata?: Record<string, string>;
+};
+export type CreatePaymentIntentOptions = IntentScope & {
+  stripePriceId: string;
+  receiptEmail?: string;
+  /** Card-only by default; automatic preserves host-selected local payment methods. */
+  paymentMethods?: "card" | "automatic";
+};
+export type CreateSetupIntentOptions = IntentScope & {
+  customerAccount: string;
+  usage: "on_session" | "off_session";
+  /** Host records consent for the selected usage before provisioning. */
+  consent: true;
+};
+async function authorize(component: Component, ctx: RunCtx, opts: IntentScope) {
+  if (typeof opts.idempotencyKey !== "string")
+    throw new Error("An explicit idempotency key is required.");
+  const request = idempotencyOptions(opts.idempotencyKey)!;
+  if (opts.customerAccount === undefined) return request;
+  if (!opts.userId || !/^acct_[a-zA-Z0-9]+$/.test(opts.customerAccount))
+    throw new Error(
+      "An authenticated user and V2 customer account are required.",
+    );
+  const account = await ctx.runQuery(
+    componentRef(component, "core/queries/getAccountByStripeId"),
+    { stripeAccountId: opts.customerAccount },
+  );
+  if (!account || account.userId !== opts.userId)
+    throw new Error(
+      "Customer account does not belong to the authenticated user.",
+    );
+  return request;
+}
+export async function createPaymentIntent(
+  stripe: Stripe,
+  component: Component,
+  ctx: RunCtx,
+  opts: CreatePaymentIntentOptions,
+) {
+  const request = await authorize(component, ctx, opts);
+  const price = await stripe.prices.retrieve(opts.stripePriceId, {
+    expand: ["product"],
+  });
+  const product = price.product;
+  if (
+    !price.active ||
+    price.type !== "one_time" ||
+    !Number.isSafeInteger(price.unit_amount) ||
+    price.unit_amount! <= 0 ||
+    typeof product === "string" ||
+    product.deleted ||
+    !product.active
+  )
+    throw new Error(
+      "Payment Intents require an active product and a positive fixed one-time price.",
+    );
+  const intent = await stripe.paymentIntents.create(
+    {
+      amount: price.unit_amount!,
+      currency: price.currency,
+      customer_account: opts.customerAccount,
+      receipt_email: opts.receiptEmail,
+      ...(opts.paymentMethods === "automatic"
+        ? { automatic_payment_methods: { enabled: true } }
+        : { allowed_payment_method_types: ["card" as const] }),
+      metadata: {
+        ...stripReservedMetadata(opts.metadata),
+        userId: opts.userId,
+        stripePriceId: price.id,
+        stripeProductId: product.id,
+      },
+    },
+    request,
+  );
+  if (!intent.client_secret)
+    throw new Error("Stripe did not return a payment secret.");
+  return { paymentIntentId: intent.id, clientSecret: intent.client_secret };
+}
+export async function createSetupIntent(
+  stripe: Stripe,
+  component: Component,
+  ctx: RunCtx,
+  opts: CreateSetupIntentOptions,
+) {
+  if (!opts.customerAccount)
+    throw new Error("A customer account is required for setup.");
+  const request = await authorize(component, ctx, opts);
+  if (opts.consent !== true)
+    throw new Error("Explicit saved-card consent is required.");
+  if (opts.usage !== "on_session" && opts.usage !== "off_session")
+    throw new Error("Unsupported SetupIntent usage.");
+  const intent = await stripe.setupIntents.create(
+    {
+      customer_account: opts.customerAccount,
+      usage: opts.usage,
+      allowed_payment_method_types: ["card"],
+      metadata: {
+        ...stripReservedMetadata(opts.metadata),
+        userId: opts.userId,
+      },
+    },
+    request,
+  );
+  if (!intent.client_secret)
+    throw new Error("Stripe did not return a setup secret.");
+  return { setupIntentId: intent.id, clientSecret: intent.client_secret };
+}

package/src/client/billing/intentsTransport.test.ts

@@ -0,0 +1,94 @@
+import type Stripe from "stripe";
+import { componentsGeneric } from "convex/server";
+import { expect, it, vi } from "vitest";
+import { BetterStripe } from "../index.js";
+import { getStripeClient, type Component, type RunCtx } from "../helpers.js";
+it.each([undefined, "2026-09-30.preview"] as const)(
+  "sends customer-bound intents using configured Stripe version %s",
+  async (version) => {
+    const key = `sk_test_intent_transport_${crypto.randomUUID()}`;
+    const client = new BetterStripe(
+      componentsGeneric().betterStripe as unknown as Component,
+      { STRIPE_SECRET_KEY: key, stripeApiVersion: version },
+    );
+    const sdk = getStripeClient(key, version);
+    const calls: {
+      path: string;
+      version: string;
+      key?: string;
+      body: string;
+    }[] = [];
+    (
+      sdk as unknown as { _setApiField: (name: string, value: unknown) => void }
+    )._setApiField("httpClient", {
+      getClientName: () => "intent-contract-test",
+      makeRequest: async (
+        ...[, , path, , headers, body]: Parameters<
+          ReturnType<typeof Stripe.createNodeHttpClient>["makeRequest"]
+        >
+      ) => {
+        calls.push({
+          path,
+          version: String(headers["Stripe-Version"]),
+          key: headers["Idempotency-Key"] as string | undefined,
+          body,
+        });
+        const data = path.startsWith("/v1/prices/")
+          ? {
+              id: "price_one",
+              active: true,
+              type: "one_time",
+              unit_amount: 100,
+              currency: "usd",
+              product: { id: "prod_one", active: true },
+            }
+          : {
+              id: path.includes("setup_intents") ? "seti_one" : "pi_one",
+              client_secret: "secret",
+            };
+        return {
+          getStatusCode: () => 200,
+          getHeaders: () => ({}),
+          getRawResponse: () => ({}),
+          toJSON: async () => data,
+          toStream: () => {
+            throw new Error("Unexpected stream");
+          },
+        };
+      },
+    });
+    const ctx = {
+      runQuery: vi.fn().mockResolvedValue({ userId: "buyer" }),
+    } as unknown as RunCtx;
+    const scope = {
+      userId: "buyer",
+      customerAccount: "acct_buyer",
+      idempotencyKey: "save-one",
+    };
+    await client.createSetupIntent(ctx, {
+      ...scope,
+      usage: "off_session",
+      consent: true,
+    });
+    await client.createPaymentIntent(ctx, {
+      ...scope,
+      idempotencyKey: "pay-one",
+      stripePriceId: "price_one",
+    });
+    expect(calls.map((c) => c.version)).toEqual(
+      Array(3).fill(version ?? "2026-09-30.endive"),
+    );
+    const writes = calls.filter((c) => c.key);
+    expect(writes.map((c) => c.key)).toEqual(["save-one", "pay-one"]);
+    for (const call of writes) {
+      const params = new URLSearchParams(call.body);
+      expect(params.get("customer_account")).toBe("acct_buyer");
+      expect(params.get("allowed_payment_method_types[0]")).toBe("card");
+      expect(params.has("customer")).toBe(false);
+    }
+    expect(new URLSearchParams(writes[0].body).get("usage")).toBe(
+      "off_session",
+    );
+    expect(new URLSearchParams(writes[1].body).get("amount")).toBe("100");
+  },
+);

package/src/client/connect/payoutSnapshot.test.ts

@@ -89,3 +89,30 @@ it("reports bounded upcoming previews and not-ready accounts explicitly", async
     reason: "account_unavailable",
   });
 });
+
+it("exposes optional provider failure details in history", async () => {
+  const stripe = {
+    balance: { retrieve: async () => ({ available: [], pending: [] }) },
+    payouts: {
+      list: async (args: { status?: string }) => ({
+        data: args.status
+          ? []
+          : [
+              {
+                ...payout("po_failed", "failed"),
+                failure_code: "account_closed",
+                failure_message: "Bank account closed",
+              },
+            ],
+        has_more: false,
+      }),
+    },
+  };
+  const result = await getPayoutSnapshot(stripe as unknown as Stripe, {
+    stripeAccountId: "acct_a",
+  });
+  expect(result.payouts[0]).toMatchObject({
+    failureCode: "account_closed",
+    failureMessage: "Bank account closed",
+  });
+});

package/src/client/connect/payoutSnapshot.ts

@@ -8,6 +8,8 @@ export type RecipientPayoutRow = {
   status: string;
   arrivalDate: number | null;
   created: number;
+  failureCode?: string;
+  failureMessage?: string;
 };
 export type RecipientPayoutSnapshot = {
   balances: AccountBalance[];
@@ -31,6 +33,8 @@ const row = (p: Stripe.Payout): RecipientPayoutRow => ({
   status: p.status,
   arrivalDate: p.arrival_date ? p.arrival_date * 1000 : null,
   created: p.created * 1000,
+  ...(p.failure_code != null ? { failureCode: p.failure_code } : {}),
+  ...(p.failure_message != null ? { failureMessage: p.failure_message } : {}),
 });
 /** Account-scoped live balance and cursor history. Upcoming truncation is explicit. */
 export async function getPayoutSnapshot(

package/src/client/core/fees.ts

@@ -273,3 +273,11 @@ export function validateSplit(recipients: SplitRecipient[]): void {
     throw new Error(`split percents sum to ${percentSum}, which exceeds 100`);
   }
 }
+
+/** Deep-copy a platform fee config so stored/returned values can't be mutated. */
+export function clonePlatformFee(config: PlatformFeeConfig): PlatformFeeConfig {
+  return {
+    ...config,
+    tiers: config.tiers?.map((tier) => ({ ...tier })),
+  };
+}

package/src/client/index.ts

@@ -1,3 +1,8 @@
+import type { CreateCheckoutSessionOptions } from "./billing/checkoutOptions.js";
+export type { CreateCheckoutSessionOptions } from "./billing/checkoutOptions.js";
+import * as intentsImpl from "./billing/intents.js";
+export type * from "./billing/intents.js";
+import { ReadContractClient } from "./readContracts.js";
 import { CostRecoveryClient } from "./costRecovery.js";
 export * from "./charge-currency.js";
 export * from "./costRecovery.js";
@@ -88,7 +93,7 @@ import * as transfersImpl from "./connect/transfers.js";
 import * as accountLinksImpl from "./core/accountLinks.js";
 import * as accountsImpl from "./core/accounts.js";
 import * as configImpl from "./core/config.js";
-import { resolveFeeConfig, validatePlatformFee } from "./core/fees.js";
+import * as fees from "./core/fees.js";
 import { validateStatementDescriptorSuffix } from "./core/descriptors.js";
 export { computeFee, computeSplit } from "./core/fees.js";
 export type { FeeBreakdown, SplitResult, SplitTransfer } from "./core/fees.js";
@@ -103,7 +108,7 @@ export type { RefundActor } from "./connect/refunds.js";
 import type { RefundActor } from "./connect/refunds.js";
 export type { AccountBalance } from "./connect/payouts.js";
 export type { WedgedReversalClaim } from "./connect/transfers.js";
-import type { Component, RunCtx } from "./helpers.js";
+import type { RunCtx } from "./helpers.js";
 import { getStripeClient } from "./helpers.js";
 import type {
   V2AccountRetrieveInclude,
@@ -204,18 +209,9 @@ export type {
 
 export type BetterStripeComponent = ComponentApi;
 
-/** Deep-copy a platform fee config so stored/returned values can't be mutated. */
-function clonePlatformFee(config: PlatformFeeConfig): PlatformFeeConfig {
-  return {
-    ...config,
-    tiers: config.tiers?.map((tier) => ({ ...tier })),
-  };
-}
-
 // BETTER STRIPE CLIENT
 
-export class BetterStripe {
-  public component: Component;
+export class BetterStripe extends ReadContractClient {
   readonly stripeApiVersion: SupportedStripeApiVersion;
   private _apiKey?: string;
   private _triggers?: SyncTriggers;
@@ -224,16 +220,16 @@ export class BetterStripe {
   private _statementDescriptorSuffix?: string;
 
   constructor(component: BetterStripeComponent, options?: BetterStripeOptions) {
-    this.component = component;
+    super(component);
     this.stripeApiVersion = resolveStripeApiVersion(options?.stripeApiVersion);
     this._apiKey = options?.STRIPE_SECRET_KEY;
     this._triggers = options?.triggers;
     this._hooks = options?.hooks;
     if (options?.platformFee !== undefined) {
-      validatePlatformFee(options.platformFee);
+      fees.validatePlatformFee(options.platformFee);
       // Store a defensive copy so later mutation of the caller's object can't
       // silently bypass validation or change runtime behavior.
-      this._platformFee = clonePlatformFee(options.platformFee);
+      this._platformFee = fees.clonePlatformFee(options.platformFee);
     }
     if (options?.statementDescriptorSuffix !== undefined) {
       this._statementDescriptorSuffix = validateStatementDescriptorSuffix(
@@ -252,7 +248,7 @@ export class BetterStripe {
 
   /** The configured default platform fee (the platform's take), if any. */
   get platformFee(): PlatformFeeConfig | undefined {
-    return this._platformFee && clonePlatformFee(this._platformFee);
+    return this._platformFee && fees.clonePlatformFee(this._platformFee);
   }
 
   /**
@@ -260,8 +256,8 @@ export class BetterStripe {
    * default. The fee math itself is applied at charge time (M2).
    */
   resolveFee(override?: FeeOverride): PlatformFeeConfig | undefined {
-    const resolved = resolveFeeConfig(this._platformFee, override);
-    return resolved && clonePlatformFee(resolved);
+    const resolved = fees.resolveFeeConfig(this._platformFee, override);
+    return resolved && fees.clonePlatformFee(resolved);
   }
 
   get apiKey(): string {
@@ -657,34 +653,35 @@ export class BetterStripe {
     return pricesImpl.listStripePrices(this.stripe(), ctx, opts);
   }
 
-  // CHECKOUT METHODS
+  /** Card-only one-time checkout. Host authorizes price and authenticated customer. */
+  async createPaymentIntent(
+    ctx: RunCtx,
+    opts: intentsImpl.CreatePaymentIntentOptions,
+  ) {
+    return intentsImpl.createPaymentIntent(
+      this.stripe(),
+      this.component,
+      ctx,
+      opts,
+    );
+  }
 
-  async createCheckoutSession(
+  /** Provision consented card setup; confirmation and authentication happen in Stripe.js. */
+  async createSetupIntent(
     ctx: RunCtx,
-    opts: {
-      idempotencyKey?: string;
-      userId: string;
-      orgId?: string;
-      stripePriceId: string;
-      mode: "payment" | "subscription" | "setup";
-      uiMode?: "embedded" | "redirect" | "custom" | "form";
-      quantity?: number;
-      returnUrl: string;
-      trialDays?: number;
-      accountId?: string;
-      customerEmail?: string;
-      /** Seller/recipient connected account to route funds to (destination charge). */
-      destinationAccountId?: string;
-      /** Multiple recipients (store + affiliate[s]); >1 routes via separate charges & transfers. */
-      split?: SplitRecipient[];
-      /** Per-call platform fee override; falls back to the configured default. */
-      fee?: FeeOverride;
-      /** Charge total (minor units) for one-time payment fee computation. */
-      amount?: number;
-      metadata?: Record<string, string>;
-      sessionOverrides?: Record<string, unknown>;
-    },
+    opts: intentsImpl.CreateSetupIntentOptions,
   ) {
+    return intentsImpl.createSetupIntent(
+      this.stripe(),
+      this.component,
+      ctx,
+      opts,
+    );
+  }
+
+  // CHECKOUT METHODS
+
+  async createCheckoutSession(ctx: RunCtx, opts: CreateCheckoutSessionOptions) {
     const { fee, ...rest } = opts;
     return checkoutImpl.createCheckoutSession(
       this.stripe(),

package/src/client/readContracts.ts

@@ -0,0 +1,90 @@
+import type { ComponentApi } from "../component/_generated/component.js";
+import type { PaginationOptions, PaginationResult } from "convex/server";
+import type { Component, RunCtx } from "./helpers.js";
+import type { PayoutStatus } from "../component/connect/validators.js";
+import type {
+  StripeComponentPayout,
+  StripeComponentProduct,
+  StripeComponentPrice,
+} from "./types/documents.js";
+import { componentRef } from "./webhooks/helpers.js";
+/** Shared component readers inherited by BetterStripe. */
+export class ReadContractClient {
+  constructor(public component: Component) {}
+  async paginateProducts(
+    ctx: RunCtx,
+    opts: {
+      accountId?: string;
+      active?: boolean;
+      paginationOpts: PaginationOptions;
+    },
+  ): Promise<PaginationResult<StripeComponentProduct>> {
+    return ctx.runQuery(
+      componentRef(this.component, "products/queries/paginateProducts"),
+      opts,
+    );
+  }
+  async paginatePrices(
+    ctx: RunCtx,
+    opts: {
+      productId?: string;
+      active?: boolean;
+      paginationOpts: PaginationOptions;
+    },
+  ): Promise<PaginationResult<StripeComponentPrice>> {
+    return ctx.runQuery(
+      componentRef(this.component, "products/queries/paginatePrices"),
+      opts,
+    );
+  }
+  async paginatePayouts(
+    ctx: RunCtx,
+    opts: {
+      accountId: string;
+      status?: PayoutStatus;
+      paginationOpts: PaginationOptions;
+    },
+  ): Promise<PaginationResult<StripeComponentPayout>> {
+    return ctx.runQuery(
+      componentRef(this.component, "connect/queries/paginatePayouts"),
+      opts,
+    );
+  }
+
+  async getAccountEarningsByCurrency(
+    ctx: RunCtx,
+    opts: { destinationAccountId: string; previewLimit?: number },
+  ): Promise<{
+    totals: {
+      currency: string;
+      gross: number;
+      reversed: number;
+      net: number;
+      transferCount: number;
+    }[];
+    transfers: ComponentApi["connect"]["queries"]["getAccountEarningsByCurrency"]["_returnType"]["transfers"];
+  }> {
+    return ctx.runQuery(
+      componentRef(
+        this.component,
+        "connect/queries/getAccountEarningsByCurrency",
+      ),
+      opts,
+    );
+  }
+  async getAccountPayoutsByCurrency(
+    ctx: RunCtx,
+    opts: { accountId: string; previewLimit?: number },
+  ): Promise<{
+    totals: { currency: string; paidOut: number; payoutCount: number }[];
+    payouts: StripeComponentPayout[];
+  }> {
+    return ctx.runQuery(
+      componentRef(
+        this.component,
+        "connect/queries/getAccountPayoutsByCurrency",
+      ),
+      opts,
+    );
+  }
+}

package/src/client/readPagination.test.ts

@@ -0,0 +1,62 @@
+import { expect, it, vi } from "vitest";
+import { BetterStripe } from "./index.js";
+import { components } from "./setup.test.js";
+it("forwards typed component cursors and account scope through public readers", async () => {
+  const bs = new BetterStripe(components.betterStripe, {
+    STRIPE_SECRET_KEY: "sk_test_reader_fixture",
+  });
+  const page = { page: [], isDone: true, continueCursor: "end" };
+  const ctx = { runQuery: vi.fn().mockResolvedValue(page) };
+  const paginationOpts = { numItems: 10, cursor: "opaque" };
+  expect(
+    await bs.paginatePayouts(ctx, {
+      accountId: "acct_a",
+      status: "paid",
+      paginationOpts,
+    }),
+  ).toBe(page);
+  expect(ctx.runQuery).toHaveBeenLastCalledWith(
+    components.betterStripe.connect.queries.paginatePayouts,
+    { accountId: "acct_a", status: "paid", paginationOpts },
+  );
+  expect(
+    await bs.paginateProducts(ctx, {
+      accountId: "acct_a",
+      active: true,
+      paginationOpts,
+    }),
+  ).toBe(page);
+  expect(ctx.runQuery).toHaveBeenLastCalledWith(
+    components.betterStripe.products.queries.paginateProducts,
+    { accountId: "acct_a", active: true, paginationOpts },
+  );
+  expect(
+    await bs.paginatePrices(ctx, {
+      productId: "prod_a",
+      active: false,
+      paginationOpts,
+    }),
+  ).toBe(page);
+  expect(ctx.runQuery).toHaveBeenLastCalledWith(
+    components.betterStripe.products.queries.paginatePrices,
+    { productId: "prod_a", active: false, paginationOpts },
+  );
+});
+it("forwards exact currency summary reads through the public client", async () => {
+  const bs = new BetterStripe(components.betterStripe);
+  const ctx = { runQuery: vi.fn().mockResolvedValue({ totals: [] }) };
+  expect(
+    await bs.getAccountEarningsByCurrency(ctx, {
+      destinationAccountId: "acct_a",
+    }),
+  ).toEqual({ totals: [] });
+  expect(ctx.runQuery).toHaveBeenLastCalledWith(
+    components.betterStripe.connect.queries.getAccountEarningsByCurrency,
+    { destinationAccountId: "acct_a" },
+  );
+  await bs.getAccountPayoutsByCurrency(ctx, { accountId: "acct_a" });
+  expect(ctx.runQuery).toHaveBeenLastCalledWith(
+    components.betterStripe.connect.queries.getAccountPayoutsByCurrency,
+    { accountId: "acct_a" },
+  );
+});

package/src/client/types/documents.ts

@@ -124,6 +124,8 @@ export type StripeComponentPayout = {
   status: PayoutStatus;
   arrivalDate?: string;
   method?: string;
+  failureCode?: string;
+  failureMessage?: string;
   metadata?: Record<string, unknown>;
 };
 

package/src/client/webhooks/payout-canceled.integration.test.ts

@@ -190,3 +190,28 @@ it.each([
     expect(transport).not.toHaveBeenCalled();
   },
 );
+
+it("persists signed failure details and clears them on a later snapshot", async () => {
+  const f = fixture("payout.failed", "failed");
+  f.event.data.object.failure_code = "account_closed";
+  f.event.data.object.failure_message = "Bank account closed";
+  expect((await f.deliver()).status).toBe(200);
+  const failed = await f.payout();
+  expect(failed).toMatchObject({
+    failureCode: "account_closed",
+    failureMessage: "Bank account closed",
+    accountId: "acct_qa_recipient",
+  });
+  expect((await f.deliver()).body).toMatchObject({ deduplicated: true });
+  expect(await f.payout()).toEqual(failed);
+  f.event.id = "evt_failure_cleared";
+  f.event.type = "payout.updated";
+  f.event.data.object.status = "pending";
+  f.event.data.object.failure_code = null;
+  f.event.data.object.failure_message = null;
+  expect((await f.deliver()).status).toBe(200);
+  const cleared = await f.payout();
+  expect(cleared?._id).toBe(failed?._id);
+  expect(cleared).not.toHaveProperty("failureCode");
+  expect(cleared).not.toHaveProperty("failureMessage");
+});

package/src/client/webhooks/processors.ts

@@ -921,6 +921,8 @@ async function handlePayoutEvent(
       "pending" | "paid" | "failed" | "canceled" | "in_transit",
     arrivalDate: epochToIso(payout.arrival_date),
     method: payout.method ?? undefined,
+    failureCode: payout.failure_code ?? undefined,
+    failureMessage: payout.failure_message ?? undefined,
     metadata: payout.metadata ?? undefined,
   });
 }

package/src/component/_generated/api.ts

@@ -24,6 +24,10 @@ import type * as costRecovery_imports from "../costRecovery/imports.js";
 import type * as costRecovery_mutations from "../costRecovery/mutations.js";
 import type * as costRecovery_queries from "../costRecovery/queries.js";
 import type * as costRecovery_reservations from "../costRecovery/reservations.js";
+import type * as earnings_legacyReads from "../earnings/legacyReads.js";
+import type * as earnings_mutations from "../earnings/mutations.js";
+import type * as earnings_reads from "../earnings/reads.js";
+import type * as earnings_triggers from "../earnings/triggers.js";
 import type * as lib_fees from "../lib/fees.js";
 import type * as lib_idempotency from "../lib/idempotency.js";
 import type * as lib_paymentSeller from "../lib/paymentSeller.js";
@@ -62,6 +66,10 @@ const fullApi: ApiFromModules<{
   "costRecovery/mutations": typeof costRecovery_mutations;
   "costRecovery/queries": typeof costRecovery_queries;
   "costRecovery/reservations": typeof costRecovery_reservations;
+  "earnings/legacyReads": typeof earnings_legacyReads;
+  "earnings/mutations": typeof earnings_mutations;
+  "earnings/reads": typeof earnings_reads;
+  "earnings/triggers": typeof earnings_triggers;
   "lib/fees": typeof lib_fees;
   "lib/idempotency": typeof lib_idempotency;
   "lib/paymentSeller": typeof lib_paymentSeller;