@volter/twin-stripe 3.0.0 → 3.0.1

package/dist/src/semantics/checkout.js

@@ -1,6 +1,15 @@
 import { CS, sessionMethodTypes } from "../engine/checkout.js";
-import { applyCouponDiscount, lineItemEntries, nowUnix, resolveLineItem } from "../engine/stripe.js";
-import { actingAccount, at, checkoutNoDestination, created, discountOf, fail, finder, noLineItems, sessionMissing, sessionTrialRefused } from "./shared.js";
+import { applyCouponDiscount, lineItemEntries, nowUnix, paginate, resolveLineItem } from "../engine/stripe.js";
+import { actingAccount, at, checkoutNoDestination, created, discountOf, fail, finder, noLineItems, path, sessionMissing, sessionTrialRefused } from "./shared.js";
+export async function GetCheckoutSessionsSessionLineItems(ctx) {
+    const s = ctx.get(CS, at(ctx, 'session'));
+    if (!s)
+        return sessionMissing(ctx, at(ctx, 'session'));
+    // source: spec:GetCheckoutSessionsSessionLineItems "There is also a URL where you can retrieve the full (paginated) list of line items."
+    const li = s.line_items;
+    const { page, hasMore } = paginate(Array.isArray(li?.data) ? li.data : [], ctx.params);
+    return ctx.reply({ object: 'list', url: path(ctx), has_more: hasMore, data: page });
+}
 export async function PostCheckoutSessions(ctx) {
     const params = ctx.params;
     const mode = typeof params.mode === 'string' ? params.mode : 'payment';
@@ -9,8 +18,9 @@ export async function PostCheckoutSessions(ctx) {
     const entries = lineItemEntries(params);
     if (mode !== 'setup' && entries.length === 0)
         return noLineItems(ctx);
-    // hosted Checkout (the only ui_mode the twin models) needs success_url
-    if (params.success_url === undefined || params.success_url === '')
+    // source: spec:/paths/~1v1~1checkout~1sessions/post/requestBody/content/application~1x-www-form-urlencoded/schema/properties/ui_mode "The UI mode of the Session."
+    const custom = params.ui_mode === 'custom';
+    if (!custom && (params.success_url === undefined || params.success_url === ''))
         return fail(ctx, 'Missing required param: success_url.', 400, 'parameter_missing');
     const sessionCurrency = typeof params.currency === 'string' ? params.currency : 'usd';
     const resolved = entries.map((e, i) => resolveLineItem(e, i, sessionCurrency, finder(ctx)));
@@ -32,7 +42,10 @@ export async function PostCheckoutSessions(ctx) {
     const fields = {
         mode, status: 'open',
         payment_status: mode === 'setup' ? 'no_payment_required' : 'unpaid',
-        url: `https://checkout.stripe.com/c/pay/${id}`, success_url: params.success_url ?? null, cancel_url: params.cancel_url ?? null,
+        ui_mode: custom ? 'custom' : 'hosted',
+        ...(custom ? { client_secret: `${id}_secret_${await ctx.secret(`checkout-secret:${id}`)}`, return_url: params.return_url ?? null } : {}),
+        allow_promotion_codes: params.allow_promotion_codes === true || params.allow_promotion_codes === 'true',
+        url: custom ? null : `https://checkout.stripe.com/c/pay/${id}`, success_url: params.success_url ?? null, cancel_url: params.cancel_url ?? null,
         customer: params.customer ?? null, client_reference_id: params.client_reference_id ?? null,
         customer_email: params.customer_email ?? null,
         // whether paying makes a customer: in payment mode only when asked (`always`), `if_required` by default
@@ -74,13 +87,3 @@ export async function PostCheckoutSessions(ctx) {
         fields._discount = { coupon: String(discount.coupon.id), promotion_code: discount.promotion ?? null };
     return ctx.reply(await created(ctx, CS, { id, ...fields }, {}));
 }
-export async function PostCheckoutSessionsSessionExpire(ctx) {
-    const id = at(ctx, 'session');
-    const s = ctx.get(CS, id);
-    if (!s)
-        return sessionMissing(ctx, id);
-    const refused = ctx.legal(CS, 'status', 'PostCheckoutSessionsSessionExpire', s.status, undefined, id);
-    if (refused)
-        return ctx.refuse(refused);
-    return ctx.reply(await ctx.write(CS, id, { status: 'expired', url: null }, 'checkout.session.expire'));
-}

package/dist/src/semantics/clock.js

@@ -1,17 +1,11 @@
-import { advanceBilling, advancePayouts, finishClockAdvances, finishReportRuns, lapseCoupons, lapseRealtimeRequests, settleBankDebits, settleHeldRefunds, settleTopups } from "./shared.js";
+import { advanceBilling, advancePayouts, lapseCoupons, lapseRealtimeRequests, settleBankDebits, settleHeldRefunds } from "./shared.js";
 export async function clock(ctx) {
-    // a test clock advanced by the last request has reached its time
-    await finishClockAdvances(ctx);
     // a subscription renews at its period's end, its renewal charged an hour later
     await advanceBilling(ctx);
     // a submitted bank debit settles (in test mode at once)
     await settleBankDebits(ctx);
     // a coupon past its redeem_by is no longer valid
     await lapseCoupons(ctx);
-    // a top-up's funds arrive five days after it is made
-    await settleTopups(ctx);
-    // a report run completes
-    await finishReportRuns(ctx);
     // a real-time authorization request no one answered is decided when its window ends
     await lapseRealtimeRequests(ctx);
     // a refund held for want of balance is made when funds cover it, before any payout takes them

package/dist/src/semantics/customers.d.ts

@@ -1,6 +1,5 @@
 import type { HandlerContext } from '@volter/world-core';
 export declare function GetCustomersCustomer(ctx: HandlerContext): Promise<Response>;
-export declare function GetCustomersCustomerPaymentMethods(ctx: HandlerContext): Promise<Response>;
 export declare function GetCustomersSearch(ctx: HandlerContext): Promise<Response>;
 export declare function PostCustomers(ctx: HandlerContext): Promise<Response>;
-export declare function PostCustomersCustomerBalanceTransactions(ctx: HandlerContext): Promise<Response>;
+export declare function PostCustomersCustomer(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/customers.js

@@ -1,5 +1,6 @@
 import { newCustomer } from "../engine/customers.js";
-import { at, attachable, attachPaymentMethod, created, customerDiscount, customerMissing, expanded, fail, list, newest, redeemCoupon, search, where } from "./shared.js";
+import { nowUnix } from "../engine/stripe.js";
+import { at, attachable, attachPaymentMethod, created, customerMissing, expanded, fail, search } from "./shared.js";
 // "If it’s for a deleted Customer, a subset of the customer’s information is returned, including a `deleted` property
 // that’s set to true" (docs.stripe.com/api/customers/retrieve)
 export async function GetCustomersCustomer(ctx) {
@@ -11,23 +12,10 @@ export async function GetCustomersCustomer(ctx) {
         return ctx.reply({ id, object: 'customer', deleted: true });
     return ctx.reply(expanded(ctx, 'customer', ctx.get('customer', id)));
 }
-// the payment methods attached to a customer (customers.listPaymentMethods), optionally by `type`
-export async function GetCustomersCustomerPaymentMethods(ctx) {
-    const customer = at(ctx, 'customer');
-    if (!ctx.get('customer', customer))
-        return customerMissing(ctx, customer);
-    const items = where(ctx, newest(ctx, 'payment_method').filter((m) => m.customer === customer), { type: (m, v) => m.type === v });
-    return list(ctx, 'payment_method', items);
-}
 export async function GetCustomersSearch(ctx) {
     return search(ctx, 'customer');
 }
 export async function PostCustomers(ctx) {
-    // a `coupon` on create materializes the discount object on the customer (the coupon must exist)
-    const couponId = typeof ctx.params.coupon === 'string' ? ctx.params.coupon : '';
-    const discount = couponId ? customerDiscount(ctx, couponId) : null;
-    if (discount instanceof Response)
-        return discount;
     // `payment_method` attaches that method to the new customer; it is not a field of the customer
     // (docs.stripe.com/api/customers/create#create_customer-payment_method)
     const pmId = typeof ctx.params.payment_method === 'string' ? ctx.params.payment_method : '';
@@ -36,34 +24,40 @@ export async function PostCustomers(ctx) {
     const given = ctx.params;
     const { coupon: _c, payment_method: _pm, ...rest } = given;
     const id = ctx.mint('customer');
-    const customer = await created(ctx, 'customer', { ...rest, id }, { livemode: false, discount: discount ? { ...discount, customer: id } : null, ...newCustomer(id) });
-    if (discount)
-        await redeemCoupon(ctx, couponId);
+    const customer = await created(ctx, 'customer', { ...rest, id }, { livemode: false, discount: null, ...newCustomer(id) });
+    // source: https://docs.stripe.com/billing/customer/balance "Represents the starting value of the customer invoice balance when a customer is created using the API with a non-zero invoice balance."
+    if (Number(customer.balance ?? 0) !== 0) {
+        await created(ctx, 'customer_balance_transaction', {
+            customer: id, amount: Number(customer.balance), ending_balance: Number(customer.balance),
+            currency: customer.currency ?? 'usd', type: 'initial', description: null, metadata: {},
+            livemode: false, invoice: null, credit_note: null, checkout_session: null, customer_account: null,
+        }, {});
+    }
     if (pmId)
         await attachPaymentMethod(ctx, pmId, String(customer.id));
     return ctx.reply(customer);
 }
 // ── the credit-balance ledger: a negative amount is a credit; `ending_balance` is the running sum,
 // mirrored onto the customer's `balance` ──
-export async function PostCustomersCustomerBalanceTransactions(ctx) {
-    const customer = at(ctx, 'customer');
-    if (!ctx.get('customer', customer))
-        return customerMissing(ctx, customer);
-    const params = ctx.params;
-    if (params.amount === undefined)
-        return fail(ctx, 'Missing required param: amount.', 400, 'parameter_missing');
-    const amount = Number(params.amount);
-    if (!Number.isInteger(amount))
-        return fail(ctx, 'Invalid integer: amount.', 400, 'parameter_invalid_integer');
-    if (params.currency === undefined || params.currency === '')
-        return fail(ctx, 'Missing required param: currency.', 400, 'parameter_missing');
-    const prior = ctx.rows('customer_balance_transaction').filter((t) => t.customer === customer).reduce((s, t) => s + (Number(t.amount) || 0), 0);
-    const ending = prior + amount;
-    const body = await created(ctx, 'customer_balance_transaction', { ...params, customer, amount }, {
-        ending_balance: ending, type: 'adjustment', livemode: false, metadata: {},
-        description: params.description ?? null, credit_note: null, invoice: null, checkout_session: null,
-    });
-    // keyed by the new transaction so two adjustments at one instant are two writes, the last winning
-    await ctx.write('customer', customer, { balance: ending }, `customer.balance_adjusted:${String(body.id)}`);
-    return ctx.reply(body);
+// source: spec:PostCustomersCustomer "Updates the specified customer by setting the values of the parameters passed."
+export async function PostCustomersCustomer(ctx) {
+    const id = at(ctx, 'customer');
+    const customer = ctx.get('customer', id);
+    if (!customer)
+        return customerMissing(ctx, id);
+    const { customer: _pathCustomer, ...fields } = ctx.params;
+    // source: https://docs.stripe.com/billing/customer/balance "All modifications to the invoice balance are recorded as Transactions"
+    // source: https://docs.stripe.com/billing/customer/balance "All Transactions created with the API or in the Dashboard have a type value of adjustment"
+    if (typeof fields.balance === 'number' && fields.balance !== Number(customer.balance ?? 0)) {
+        const balance = fields.balance;
+        await created(ctx, 'customer_balance_transaction', {
+            customer: id, amount: balance - Number(customer.balance ?? 0), ending_balance: balance,
+            // Stripe inherits the customer's billing currency. Where no invoice has set it, this World's invoice currency is USD.
+            currency: customer.currency ?? 'usd', type: 'adjustment',
+            description: null, metadata: {}, livemode: false,
+            invoice: null, credit_note: null, checkout_session: null, customer_account: null,
+            created: nowUnix(ctx.occurredAt),
+        }, {});
+    }
+    return ctx.reply(ctx.expand('customer', await ctx.write('customer', id, fields, 'customer.update')));
 }

package/dist/src/semantics/entitlements.d.ts

@@ -1,2 +0,0 @@
-import type { HandlerContext } from '@volter/world-core';
-export declare function GetEntitlementsActiveEntitlements(ctx: HandlerContext): Promise<Response>;

package/dist/src/semantics/entitlements.js

@@ -1,50 +1,4 @@
-import { FEAT } from "../engine/entitlements.js";
-import { subscriptionItemPairs } from "../engine/stripe.js";
-import { fail, newest, path } from "./shared.js";
-// a customer is entitled to every feature granted to a product its live subscriptions bill, as the product stood when
-// the subscription's current period began: "When a customer purchases or subscribes to a product with an attached
-// feature, Stripe creates and manages an Active Entitlement for that customer and feature"; "Existing subscriptions will
-// create active entitlements for any product feature changes at the start of the next billing period"
-// (docs.stripe.com/billing/entitlements). Where the documentation stops and the twin decides: a feature removed from a
-// product is kept, the same way, until the next period begins.
-export async function GetEntitlementsActiveEntitlements(ctx) {
-    const customer = typeof ctx.params.customer === 'string' ? ctx.params.customer : '';
-    if (!customer)
-        return fail(ctx, 'Missing required param: customer.', 400, 'parameter_missing');
-    if (!ctx.row('customer', customer, { withDeleted: true }))
-        return fail(ctx, `No such customer: '${customer}'`, 404, 'resource_missing');
-    // each product a live subscription bills, with the start of the period it is billed for
-    const productIds = new Map();
-    for (const sub of newest(ctx, 'subscription')) {
-        // a subscription entitles while it runs: not before its first payment (incomplete), nor once it has ended
-        // (docs.stripe.com/billing/entitlements; past_due keeps access during retries — that edge is the twin's reading)
-        if (sub.customer !== customer || !['active', 'trialing', 'past_due'].includes(String(sub.status)))
-            continue;
-        const periodStart = Number(sub.current_period_start ?? sub.start_date ?? sub.created ?? 0);
-        for (const it of subscriptionItemPairs(sub)) {
-            const price = ctx.get('price', it.price);
-            if (price && typeof price.product === 'string')
-                productIds.set(price.product, Math.max(productIds.get(price.product) ?? -Infinity, periodStart));
-        }
-    }
-    const seen = new Set();
-    const data = [];
-    for (const pf of ctx.rowsRaw('product_feature', { withDeleted: true })) {
-        const periodStart = productIds.get(String(pf._product));
-        if (periodStart === undefined)
-            continue;
-        // attached by the period's start, and not removed before it
-        if (Number(pf._created ?? 0) > periodStart)
-            continue;
-        if (pf.deleted && !(Number(pf._removed_at) > periodStart))
-            continue;
-        const featId = String(pf._feature ?? pf.entitlement_feature?.id ?? pf.entitlement_feature);
-        if (seen.has(featId))
-            continue;
-        seen.add(featId);
-        const feat = ctx.get(FEAT, featId);
-        if (feat)
-            data.push({ id: `ent_twin_${customer}_${featId}`, object: 'entitlements.active_entitlement', feature: featId, lookup_key: feat.lookup_key, livemode: false });
-    }
-    return ctx.reply({ object: 'list', url: path(ctx), has_more: false, data });
-}
+"use strict";
+// Stripe's entitlements operations (docs/contributing/architecture.md, "What an author writes"): each handler over the
+// handler contract's context, computing with the engine (../engine/).
+// source: spec:PostEntitlementsFeatures "Creates a feature"

package/dist/src/semantics/events.d.ts

@@ -1,7 +1,6 @@
 import type { EventWrite, WriteHookContext } from '@volter/world-core';
-/** An event's `data`: the object the write concerns, as Stripe sends it in the event's API version. A plan is stored as
- *  the recurring price it is, and its own events carry the plan object; an Issuing authorization carries its full card;
- *  the balance notice the drain writes carries the account's Balance. */
+/** An event's `data`: the object the write concerns, as Stripe sends it in the event's API version. An Issuing
+ *  authorization carries its full card; the balance notice the drain writes carries the account's Balance. */
 export declare function data(ctx: WriteHookContext, write: EventWrite): Record<string, unknown>;
 /** An event's further envelope values: the connected account it is about ("Each event for a connected account contains
  *  a top-level `account` property that identifies the connected account", docs.stripe.com/connect/webhooks) — the

package/dist/src/semantics/events.js

@@ -1,16 +1,12 @@
-import { planOf } from "../engine/plans.js";
-import { embedIssuingAuthorizationCard, isValidApiVersion, PLATFORM_ACCOUNT_ID, TWIN_API_VERSION } from "../engine/stripe.js";
+import { isValidApiVersion, PLATFORM_ACCOUNT_ID, TWIN_API_VERSION } from "../engine/stripe.js";
 import { render } from "../engine/version.js";
-import { connectionRevoked, finder } from "./shared.js";
 // ── the events Stripe's writes send (the manifest's `events`: ./shared.ts STRIPE_EVENTS) ──
-/** An event's `data`: the object the write concerns, as Stripe sends it in the event's API version. A plan is stored as
- *  the recurring price it is, and its own events carry the plan object; an Issuing authorization carries its full card;
- *  the balance notice the drain writes carries the account's Balance. */
+/** An event's `data`: the object the write concerns, as Stripe sends it in the event's API version. An Issuing
+ *  authorization carries its full card; the balance notice the drain writes carries the account's Balance. */
 export function data(ctx, write) {
     const object = write.storedType === '_balance_notice' ? write.body.balance
-        : write.storedType === 'price' && write.operation.startsWith('plan.') ? planOf(write.body)
-            : write.storedType === 'issuing_authorization' ? embedIssuingAuthorizationCard({ ...write.body }, finder(ctx))
-                : write.body;
+        : write.storedType === 'issuing_authorization' ? ctx.expand('issuing.authorization', write.body)
+            : write.storedType === 'issuing_card' ? ctx.expand('issuing.card', write.body) : ctx.expand(String(write.body.object ?? write.storedType), write.body);
     return { object: render(object, eventVersion(write)) };
 }
 /** An event's further envelope values: the connected account it is about ("Each event for a connected account contains
@@ -26,8 +22,7 @@ export function values(ctx, write, type) {
         ?? (write.storedType === 'account' && typeof id === 'string' && id !== PLATFORM_ACCOUNT_ID ? id : undefined)
         ?? (write.storedType === '_balance_notice' && typeof write.body.account === 'string' ? write.body.account : undefined)
         ?? (typeof kept === 'string' ? kept : undefined);
-    const withheld = account !== undefined && type !== 'account.application.deauthorized' && connectionRevoked(ctx, account);
-    return { $account: account, $version: eventVersion(write), ...(withheld ? { $send: false } : {}) };
+    return { $account: account, $version: eventVersion(write) };
 }
 /** The API version an event is rendered in: the one the writing request pinned, when it is one, else the served one. */
 const eventVersion = (write) => {

package/dist/src/semantics/index.js

@@ -1,3 +1,4 @@
+import * as account from "./account.js";
 import * as account_links from "./account_links.js";
 import * as accounts from "./accounts.js";
 import * as apps from "./apps.js";
@@ -8,11 +9,9 @@ import * as charges from "./charges.js";
 import * as checkout from "./checkout.js";
 import * as coupons from "./coupons.js";
 import * as customers from "./customers.js";
-import * as disputes from "./disputes.js";
-import * as entitlements from "./entitlements.js";
 import * as invoice_payments from "./invoice_payments.js";
-import * as invoiceitems from "./invoiceitems.js";
 import * as invoices from "./invoices.js";
+import * as issuing from "./issuing.js";
 import * as payment_intents from "./payment_intents.js";
 import * as payment_methods from "./payment_methods.js";
 import * as payouts from "./payouts.js";
@@ -21,19 +20,14 @@ import * as products from "./products.js";
 import * as promotion_codes from "./promotion_codes.js";
 import * as radar from "./radar.js";
 import * as refunds from "./refunds.js";
-import * as setup_intents from "./setup_intents.js";
-import * as subscription_items from "./subscription_items.js";
-import * as subscription_schedules from "./subscription_schedules.js";
 import * as subscriptions from "./subscriptions.js";
 import * as test_helpers from "./test_helpers.js";
 import * as transfers from "./transfers.js";
+import * as webhook_endpoints from "./webhook_endpoints.js";
 export const stripeSemantics = {
-    DeleteInvoiceitemsInvoiceitem: invoiceitems.DeleteInvoiceitemsInvoiceitem,
-    DeleteInvoicesInvoice: invoices.DeleteInvoicesInvoice,
-    DeleteProductsId: products.DeleteProductsId,
-    DeleteSubscriptionItemsItem: subscription_items.DeleteSubscriptionItemsItem,
     DeleteSubscriptionsSubscriptionExposedId: subscriptions.DeleteSubscriptionsSubscriptionExposedId,
-    DeleteTestHelpersTestClocksTestClock: test_helpers.DeleteTestHelpersTestClocksTestClock,
+    DeleteSubscriptionsSubscriptionExposedIdDiscount: subscriptions.DeleteSubscriptionsSubscriptionExposedIdDiscount,
+    GetAccount: account.GetAccount,
     GetAccountsAccountExternalAccounts: accounts.GetAccountsAccountExternalAccounts,
     GetAppsSecretsFind: apps.GetAppsSecretsFind,
     GetBalance: balance.GetBalance,
@@ -41,25 +35,19 @@ export const stripeSemantics = {
     GetBillingPortalConfigurations: billing_portal.GetBillingPortalConfigurations,
     GetCharges: charges.GetCharges,
     GetChargesCharge: charges.GetChargesCharge,
+    GetCheckoutSessionsSessionLineItems: checkout.GetCheckoutSessionsSessionLineItems,
     GetCustomersCustomer: customers.GetCustomersCustomer,
-    GetCustomersCustomerPaymentMethods: customers.GetCustomersCustomerPaymentMethods,
     GetCustomersSearch: customers.GetCustomersSearch,
-    GetDisputesDispute: disputes.GetDisputesDispute,
-    GetEntitlementsActiveEntitlements: entitlements.GetEntitlementsActiveEntitlements,
     GetInvoicePayments: invoice_payments.GetInvoicePayments,
     GetInvoicesInvoice: invoices.GetInvoicesInvoice,
-    GetInvoicesInvoiceLines: invoices.GetInvoicesInvoiceLines,
+    GetIssuingCardsCard: issuing.GetIssuingCardsCard,
     GetPaymentMethodsPaymentMethod: payment_methods.GetPaymentMethodsPaymentMethod,
+    GetPayouts: payouts.GetPayouts,
     GetPrices: prices.GetPrices,
     GetPricesPrice: prices.GetPricesPrice,
     GetProducts: products.GetProducts,
-    GetProductsSearch: products.GetProductsSearch,
     GetPromotionCodes: promotion_codes.GetPromotionCodes,
-    GetRefundsRefund: refunds.GetRefundsRefund,
-    GetSubscriptionItemsItem: subscription_items.GetSubscriptionItemsItem,
-    GetSubscriptionSchedulesSchedule: subscription_schedules.GetSubscriptionSchedulesSchedule,
     GetSubscriptions: subscriptions.GetSubscriptions,
-    GetSubscriptionsSearch: subscriptions.GetSubscriptionsSearch,
     GetSubscriptionsSubscriptionExposedId: subscriptions.GetSubscriptionsSubscriptionExposedId,
     PostAccountLinks: account_links.PostAccountLinks,
     PostAccounts: accounts.PostAccounts,
@@ -67,25 +55,21 @@ export const stripeSemantics = {
     PostAppsSecrets: apps.PostAppsSecrets,
     PostAppsSecretsDelete: apps.PostAppsSecretsDelete,
     PostBillingPortalConfigurations: billing_portal.PostBillingPortalConfigurations,
-    PostBillingPortalConfigurationsConfiguration: billing_portal.PostBillingPortalConfigurationsConfiguration,
     PostBillingPortalSessions: billing_portal.PostBillingPortalSessions,
     PostCheckoutSessions: checkout.PostCheckoutSessions,
-    PostCheckoutSessionsSessionExpire: checkout.PostCheckoutSessionsSessionExpire,
     PostCoupons: coupons.PostCoupons,
     PostCustomers: customers.PostCustomers,
-    PostCustomersCustomerBalanceTransactions: customers.PostCustomersCustomerBalanceTransactions,
-    PostInvoiceitems: invoiceitems.PostInvoiceitems,
+    PostCustomersCustomer: customers.PostCustomersCustomer,
     PostInvoices: invoices.PostInvoices,
     PostInvoicesCreatePreview: invoices.PostInvoicesCreatePreview,
-    PostInvoicesInvoiceFinalize: invoices.PostInvoicesInvoiceFinalize,
     PostInvoicesInvoicePay: invoices.PostInvoicesInvoicePay,
-    PostInvoicesInvoiceSend: invoices.PostInvoicesInvoiceSend,
     PostInvoicesInvoiceVoid: invoices.PostInvoicesInvoiceVoid,
+    PostIssuingAuthorizationsAuthorizationApprove: issuing.PostIssuingAuthorizationsAuthorizationApprove,
+    PostIssuingAuthorizationsAuthorizationDecline: issuing.PostIssuingAuthorizationsAuthorizationDecline,
+    PostIssuingCards: issuing.PostIssuingCards,
+    PostIssuingCardsCard: issuing.PostIssuingCardsCard,
     PostPaymentIntents: payment_intents.PostPaymentIntents,
     PostPaymentIntentsIntentCancel: payment_intents.PostPaymentIntentsIntentCancel,
-    PostPaymentIntentsIntentConfirm: payment_intents.PostPaymentIntentsIntentConfirm,
-    PostPaymentMethods: payment_methods.PostPaymentMethods,
-    PostPaymentMethodsPaymentMethodAttach: payment_methods.PostPaymentMethodsPaymentMethodAttach,
     PostPaymentMethodsPaymentMethodDetach: payment_methods.PostPaymentMethodsPaymentMethodDetach,
     PostPayouts: payouts.PostPayouts,
     PostPrices: prices.PostPrices,
@@ -93,15 +77,9 @@ export const stripeSemantics = {
     PostPromotionCodes: promotion_codes.PostPromotionCodes,
     PostRadarValueListItems: radar.PostRadarValueListItems,
     PostRefunds: refunds.PostRefunds,
-    PostSetupIntents: setup_intents.PostSetupIntents,
-    PostSetupIntentsIntentConfirm: setup_intents.PostSetupIntentsIntentConfirm,
-    PostSubscriptionItems: subscription_items.PostSubscriptionItems,
-    PostSubscriptionItemsItem: subscription_items.PostSubscriptionItemsItem,
-    PostSubscriptionSchedules: subscription_schedules.PostSubscriptionSchedules,
-    PostSubscriptionSchedulesScheduleRelease: subscription_schedules.PostSubscriptionSchedulesScheduleRelease,
-    PostSubscriptions: subscriptions.PostSubscriptions,
     PostSubscriptionsSubscriptionExposedId: subscriptions.PostSubscriptionsSubscriptionExposedId,
-    PostTestHelpersTestClocks: test_helpers.PostTestHelpersTestClocks,
-    PostTestHelpersTestClocksTestClockAdvance: test_helpers.PostTestHelpersTestClocksTestClockAdvance,
+    PostTestHelpersIssuingAuthorizations: test_helpers.PostTestHelpersIssuingAuthorizations,
+    PostTestHelpersIssuingAuthorizationsAuthorizationCapture: test_helpers.PostTestHelpersIssuingAuthorizationsAuthorizationCapture,
     PostTransfers: transfers.PostTransfers,
+    PostWebhookEndpoints: webhook_endpoints.PostWebhookEndpoints,
 };

package/dist/src/semantics/invoices.d.ts

@@ -1,16 +1,11 @@
 import type { HandlerContext } from '@volter/world-core';
-export declare function DeleteInvoicesInvoice(ctx: HandlerContext): Promise<Response>;
 export declare function GetInvoicesInvoice(ctx: HandlerContext): Promise<Response>;
-export declare function GetInvoicesInvoiceLines(ctx: HandlerContext): Promise<Response>;
+export declare function PostInvoicesInvoicePay(ctx: HandlerContext): Promise<Response>;
+export declare function PostInvoicesInvoiceVoid(ctx: HandlerContext): Promise<Response>;
 export declare function PostInvoices(ctx: HandlerContext): Promise<Response>;
 /**
  * A preview of the next invoice for a customer or subscription (create_preview), computed and never
  * stored: the subscription's items at their prices, the customer's pending items, the subscription's
- * discount, and with `subscription_details.proration_date` a credit for the unused period against a
- * charge for the new one (split evenly: there is no clock here to measure the remaining fraction).
+ * discount, and an update's unused-time credit and remaining-time charge at the old and new prices.
  */
 export declare function PostInvoicesCreatePreview(ctx: HandlerContext): Promise<Response>;
-export declare function PostInvoicesInvoiceFinalize(ctx: HandlerContext): Promise<Response>;
-export declare function PostInvoicesInvoicePay(ctx: HandlerContext): Promise<Response>;
-export declare function PostInvoicesInvoiceSend(ctx: HandlerContext): Promise<Response>;
-export declare function PostInvoicesInvoiceVoid(ctx: HandlerContext): Promise<Response>;