@paygentic/sdk 0.9.15 → 0.9.16

package/src/models/subscription.ts

@@ -107,6 +107,20 @@ export type PaymentUnion =
   | PaymentPaid
   | PaymentAwaitingApproval;
 
+/**
+ * Whether this subscription's backdated start bills its elapsed periods, as chosen at creation. `null` for a subscription created before the choice existed. `null` is listed in the enum as well as via `nullable` because the response validator checks the enum independently.
+ */
+export const SubscriptionElapsedPeriodBilling = {
+  None: "none",
+  PerPeriod: "per_period",
+} as const;
+/**
+ * Whether this subscription's backdated start bills its elapsed periods, as chosen at creation. `null` for a subscription created before the choice existed. `null` is listed in the enum as well as via `nullable` because the response validator checks the enum independently.
+ */
+export type SubscriptionElapsedPeriodBilling = ClosedEnum<
+  typeof SubscriptionElapsedPeriodBilling
+>;
+
 export const SubscriptionStatusEnum = {
   PendingPayment: "pending_payment",
   Active: "active",
@@ -209,6 +223,22 @@ export type Subscription = {
    */
   minimumAccountBalance?: string | undefined;
   startedAt: Date;
+  /**
+   * Whether this subscription's backdated start bills its elapsed periods, as chosen at creation. `null` for a subscription created before the choice existed. `null` is listed in the enum as well as via `nullable` because the response validator checks the enum independently.
+   */
+  elapsedPeriodBilling: SubscriptionElapsedPeriodBilling | null;
+  /**
+   * The billing start: a charge is billed only if it falls due at or after this moment. Fixed at creation and never changed. It is `startedAt`, unless the start was backdated with `elapsedPeriodBilling` of `none`, in which case it is the moment of creation.
+   */
+  billingStartsAt: Date | null;
+  /**
+   * The instant the subscription's billing periods are anchored on: its billing anchor, else its start. Every recurring period boundary is this instant plus a whole number of cadences.
+   */
+  billingAnchor: Date;
+  /**
+   * The ISO-8601 duration the subscription's billing periods step by where no price sets its own: the subscription's cadence, else its plan's.
+   */
+  billingCadence: string;
   status: SubscriptionStatusEnum;
   terminatedAt?: Date | undefined;
   /**
@@ -372,6 +402,11 @@ export function paymentUnionFromJSON(
   );
 }
 
+/** @internal */
+export const SubscriptionElapsedPeriodBilling$inboundSchema: z.ZodNativeEnum<
+  typeof SubscriptionElapsedPeriodBilling
+> = z.nativeEnum(SubscriptionElapsedPeriodBilling);
+
 /** @internal */
 export const SubscriptionStatusEnum$inboundSchema: z.ZodNativeEnum<
   typeof SubscriptionStatusEnum
@@ -477,6 +512,16 @@ export const Subscription$inboundSchema: z.ZodType<
   prefundAmount: z.string().optional(),
   minimumAccountBalance: z.string().optional(),
   startedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  elapsedPeriodBilling: z.nullable(
+    SubscriptionElapsedPeriodBilling$inboundSchema,
+  ),
+  billingStartsAt: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  billingAnchor: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  billingCadence: z.string(),
   status: SubscriptionStatusEnum$inboundSchema,
   terminatedAt: z.string().datetime({ offset: true }).transform(v =>
     new Date(v)

package/src/models/subscriptionintervaladdop.ts

@@ -22,7 +22,7 @@ export type SubscriptionIntervalAddOpBillingMode = ClosedEnum<
 >;
 
 /**
- * Adds an interval. If the plan version has a line with this priceKey, the interval overrides that line. If not, send priceId. The interval then belongs to this subscription only and keeps the rate that you write. A plan version change does not carry it forward, so it stops billing at the version boundary. If a later plan version adds the same priceKey, the change is refused until the plan drops the key or the interval ends on or before the boundary.
+ * Adds an interval. If the plan version has a line with this priceKey, the interval overrides that line. If not, send priceId. The interval then belongs to this subscription only and keeps the rate that you write. A plan version change keeps it: it continues to bill after the subscription moves to another plan version. If a later plan version adds the same priceKey, the change is refused until the plan drops the key or the interval ends on or before the boundary.
  */
 export type SubscriptionIntervalAddOp = {
   /**

package/src/models/versiontransition.ts

@@ -0,0 +1,104 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * When the move takes effect.
+ */
+export const EffectiveDate = {
+  EndOfCurrentPeriod: "end_of_current_period",
+  Immediate: "immediate",
+} as const;
+/**
+ * When the move takes effect.
+ */
+export type EffectiveDate = ClosedEnum<typeof EffectiveDate>;
+
+/**
+ * How the current period is split. Only `none` is supported.
+ */
+export const Proration = {
+  None: "none",
+} as const;
+/**
+ * How the current period is split. Only `none` is supported.
+ */
+export type Proration = ClosedEnum<typeof Proration>;
+
+/**
+ * When a move to a new plan version takes effect for this plan's subscriptions. `end_of_current_period` (the default) moves everything at the end of the current billing period. `immediate` changes entitlements at the move, in-arrears prices for the whole current period, and in-advance prices from the next period. Neither prorates.
+ */
+export type VersionTransition = {
+  /**
+   * When the move takes effect.
+   */
+  effectiveDate: EffectiveDate;
+  /**
+   * How the current period is split. Only `none` is supported.
+   */
+  proration: Proration;
+};
+
+/** @internal */
+export const EffectiveDate$inboundSchema: z.ZodNativeEnum<
+  typeof EffectiveDate
+> = z.nativeEnum(EffectiveDate);
+/** @internal */
+export const EffectiveDate$outboundSchema: z.ZodNativeEnum<
+  typeof EffectiveDate
+> = EffectiveDate$inboundSchema;
+
+/** @internal */
+export const Proration$inboundSchema: z.ZodNativeEnum<typeof Proration> = z
+  .nativeEnum(Proration);
+/** @internal */
+export const Proration$outboundSchema: z.ZodNativeEnum<typeof Proration> =
+  Proration$inboundSchema;
+
+/** @internal */
+export const VersionTransition$inboundSchema: z.ZodType<
+  VersionTransition,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  effectiveDate: EffectiveDate$inboundSchema,
+  proration: Proration$inboundSchema,
+});
+/** @internal */
+export type VersionTransition$Outbound = {
+  effectiveDate: string;
+  proration: string;
+};
+
+/** @internal */
+export const VersionTransition$outboundSchema: z.ZodType<
+  VersionTransition$Outbound,
+  z.ZodTypeDef,
+  VersionTransition
+> = z.object({
+  effectiveDate: EffectiveDate$outboundSchema,
+  proration: Proration$outboundSchema,
+});
+
+export function versionTransitionToJSON(
+  versionTransition: VersionTransition,
+): string {
+  return JSON.stringify(
+    VersionTransition$outboundSchema.parse(versionTransition),
+  );
+}
+export function versionTransitionFromJSON(
+  jsonString: string,
+): SafeParseResult<VersionTransition, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VersionTransition$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VersionTransition' from JSON`,
+  );
+}

package/src/models/webhookportal.ts

@@ -0,0 +1,61 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * Object type identifier
+ */
+export const WebhookPortalObject = {
+  WebhookPortal: "webhookPortal",
+} as const;
+/**
+ * Object type identifier
+ */
+export type WebhookPortalObject = ClosedEnum<typeof WebhookPortalObject>;
+
+export type WebhookPortal = {
+  /**
+   * Object type identifier
+   */
+  object: WebhookPortalObject;
+  /**
+   * When the portal link expires
+   */
+  expiresAt: Date;
+  /**
+   * Magic link URL to access the webhook portal
+   */
+  url: string;
+};
+
+/** @internal */
+export const WebhookPortalObject$inboundSchema: z.ZodNativeEnum<
+  typeof WebhookPortalObject
+> = z.nativeEnum(WebhookPortalObject);
+
+/** @internal */
+export const WebhookPortal$inboundSchema: z.ZodType<
+  WebhookPortal,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: WebhookPortalObject$inboundSchema,
+  expiresAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  url: z.string(),
+});
+
+export function webhookPortalFromJSON(
+  jsonString: string,
+): SafeParseResult<WebhookPortal, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WebhookPortal$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WebhookPortal' from JSON`,
+  );
+}

package/src/models/webhooks.ts

@@ -0,0 +1,76 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * Object type identifier
+ */
+export const WebhooksObject = {
+  Webhooks: "webhooks",
+} as const;
+/**
+ * Object type identifier
+ */
+export type WebhooksObject = ClosedEnum<typeof WebhooksObject>;
+
+export type Webhooks = {
+  /**
+   * Object type identifier
+   */
+  object: WebhooksObject;
+  /**
+   * Svix application identifier
+   */
+  applicationId: string;
+  /**
+   * When webhooks were first enabled
+   */
+  createdAt: Date;
+  /**
+   * Whether webhooks are enabled
+   */
+  enabled: boolean;
+  /**
+   * Merchant identifier
+   */
+  merchantId: string;
+  /**
+   * When webhooks were last updated
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const WebhooksObject$inboundSchema: z.ZodNativeEnum<
+  typeof WebhooksObject
+> = z.nativeEnum(WebhooksObject);
+
+/** @internal */
+export const Webhooks$inboundSchema: z.ZodType<
+  Webhooks,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: WebhooksObject$inboundSchema,
+  applicationId: z.string(),
+  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  enabled: z.boolean(),
+  merchantId: z.string(),
+  updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+});
+
+export function webhooksFromJSON(
+  jsonString: string,
+): SafeParseResult<Webhooks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Webhooks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Webhooks' from JSON`,
+  );
+}

package/src/sdk/invoicesv2.ts

@@ -10,6 +10,9 @@ import { invoicesV2GetLineItems } from "../funcs/invoicesV2GetLineItems.js";
 import { invoicesV2List } from "../funcs/invoicesV2List.js";
 import { invoicesV2ListInvoiceRefunds } from "../funcs/invoicesV2ListInvoiceRefunds.js";
 import { invoicesV2ListLineItems } from "../funcs/invoicesV2ListLineItems.js";
+import { invoicesV2ListProjectedInvoices } from "../funcs/invoicesV2ListProjectedInvoices.js";
+import { invoicesV2RecordInvoicePayment } from "../funcs/invoicesV2RecordInvoicePayment.js";
+import { invoicesV2RetryInvoicePayment } from "../funcs/invoicesV2RetryInvoicePayment.js";
 import { invoicesV2VoidInvoiceRefund } from "../funcs/invoicesV2VoidInvoiceRefund.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as models from "../models/index.js";
@@ -68,6 +71,23 @@ export class InvoicesV2 extends ClientSDK {
     ));
   }
 
+  /**
+   * List projected
+   *
+   * @remarks
+   * List the invoices a subscription will issue in a range of invoice moments, one projected invoice for each distinct invoice moment. Projected invoices are derived on each read and never stored. Each has status PROJECTED, and its id is stable between reads, but GET /v2/invoices/{id} returns 404 for it. Totals EXCLUDE usage: metered charges are not projected, and an invoice moment that has only metered charges is omitted. Tax and sequenceNumber are estimates. The range filters on the invoice moment (invoiceAt) in [from, to). A from before now is treated as now. to must be after from and at most one year after now; now is the subscription's test-clock time when it has a test clock. A terminated subscription returns an empty list. Each invoice carries its lines in lineItems. Authorization is the same as listing invoices.
+   */
+  async listProjectedInvoices(
+    request: operations.ListProjectedInvoicesRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ListProjectedInvoicesResponse> {
+    return unwrapAsync(invoicesV2ListProjectedInvoices(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Get
    *
@@ -119,6 +139,32 @@ export class InvoicesV2 extends ClientSDK {
     ));
   }
 
+  /**
+   * Settle Invoice Payment
+   *
+   * @remarks
+   * Settle an unpaid invoice in status `ISSUED` or `PAYMENT_FAILED`. The `method` field selects how.
+   *
+   * - `hosted_link`: create a new hosted payment link and email it to the customer. The invoice stays unpaid until the customer pays on the link. Each call replaces the previous link. A payment link expires after 30 days; to collect an invoice whose link has expired, call this method again.
+   * - `out_of_band`: record a payment that you collected outside Paygentic. The invoice changes to `PAID` immediately. A second call returns 409.
+   *
+   * For `hosted_link`, an invoice that does not exist returns 403, the same as an invoice of another merchant.
+   *
+   * Paygentic selects the payment provider from your connected payment account. The response reports the provider.
+   *
+   * **Warning:** each `hosted_link` call creates a new link and sends the customer a new email. Do not retry a `hosted_link` call after a timeout: first read the invoice to see if a new link exists.
+   */
+  async recordInvoicePayment(
+    request: operations.RecordInvoicePaymentRequest,
+    options?: RequestOptions,
+  ): Promise<operations.RecordInvoicePaymentResponse> {
+    return unwrapAsync(invoicesV2RecordInvoicePayment(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Refund Invoice
    *
@@ -169,4 +215,42 @@ export class InvoicesV2 extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * Retry Payment
+   *
+   * @remarks
+   * Charge the customer's saved payment method again for an unpaid invoice.
+   *
+   * The invoice must be in status `ISSUED` or `PAYMENT_FAILED`, auto-charge must be on for its subscription, and the invoice must have a payment session. If not, the response is 400.
+   *
+   * The response status tells you the result. Only 200 means that the charge succeeded. Every other response from this operation that has a `retry_payment_result` body has `success: false`, and `error.code` gives the reason:
+   *
+   * | Status | `error.code` | Meaning |
+   * | --- | --- | --- |
+   * | 200 | — | The charge succeeded, the provider had already collected it, or no amount is unpaid. |
+   * | 202 | `processing` | The provider accepted the charge. It settles later (for example, a bank debit). |
+   * | 402 | a decline code, for example `card_declined`, `insufficient_funds`, `do_not_honor`, `authentication_required` | The provider declined the payment method. |
+   * | 409 | `concurrent_attempt` | Another payment attempt for this invoice is in progress. |
+   * | 409 | `PAYMENT_SESSION_EXPIRED` | The payment link expired (after 30 days). Create a new link with `POST /v2/invoices/{id}/payment` and `method: hosted_link`, then retry. If the customer also has no usable saved payment method, the response is 422 instead. |
+   * | 409 | another value, or no `code` | The payment session cannot be charged in its current state (for example `session_unusable`, `non_confirmable`, `PAYMENT_PROCESSING`, `PAYMENT_ALREADY_COMPLETED`). Read `error.message` for the cause. |
+   * | 422 | `no_payment_method` | The customer has no usable saved payment method. Send a payment link instead. |
+   * | 502 | `provider_unavailable` or none | The payment provider did not answer, or the provider failed the charge for a reason that is not known. Retry later. |
+   *
+   * A 500 response has the standard error body, not `retry_payment_result`. It is an internal error, and a retry does not fix it.
+   *
+   * An invoice that does not exist returns 403, the same as an invoice of another merchant.
+   *
+   * This operation is rate limited to one call each minute for each invoice.
+   */
+  async retryInvoicePayment(
+    request: operations.RetryInvoicePaymentRequest,
+    options?: RequestOptions,
+  ): Promise<models.RetryPaymentResponse> {
+    return unwrapAsync(invoicesV2RetryInvoicePayment(
+      this,
+      request,
+      options,
+    ));
+  }
 }

package/src/sdk/merchants.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { merchantsReset } from "../funcs/merchantsReset.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Merchants extends ClientSDK {
+  /**
+   * Reset a merchant's data
+   *
+   * @remarks
+   * With `scope: merchant`, deletes the merchant's customers and everything attached to them: subscriptions, invoices, line items, payments, entitlements, grants, orders, test clocks, usage events, invoice documents and, when tax is enabled, the documents in the merchant's Quaderno sandbox account. `keepCatalog: true` keeps the catalog (products, plans, prices, fees, features, billable metrics), and `keepCatalog: false` deletes it too; the merchant's configuration is always kept. With `scope: customer`, deletes one customer and what is attached to it; test clocks and the Quaderno account's documents are kept, since they belong to no single customer.
+   *
+   * A `204` means every delete is done or scheduled: usage events and Quaderno documents finish in the background, and usage events still being ingested while it runs can survive it. A `502` means a store outside Postgres failed; the customers are already out of the API, and calling again with the same body finishes the reset. Calling again is always safe. While a customer waits for that, its external id is free for a new customer to take; a retry then deletes usage events by customer id only.
+   *
+   * Not available in production.
+   */
+  async reset(
+    request: operations.ResetMerchantRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(merchantsReset(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/profitability.ts

@@ -13,7 +13,7 @@ export class Profitability extends ClientSDK {
    * Get profitability summary
    *
    * @remarks
-   * Returns a per-customer profitability summary for a merchant over a date range. Each row aggregates revenue (from issued + paid invoices), cost (from metered cost discovery), profit, and margin. Customers are ranked by profit descending and capped at topN; the remainder is rolled into a single self-consistent 'Other' row whose revenue, cost, and profit reflect the same set of customers. Rows are inner-joined against the merchant's customer list, so orphaned meter subjects from deleted or unknown customers are dropped.
+   * Returns a per-customer profitability summary for a merchant over a date range. Each row aggregates revenue (invoices issued in the period, whatever their status since, less refunds, both excluding tax; the same figure /v0/revenue reports), cost (from metered cost discovery), profit, and margin. Customers are ranked by profit descending and capped at topN; the remainder is rolled into a single self-consistent 'Other' row whose revenue, cost, and profit reflect the same set of customers. Rows are joined against the merchant's customer list, so meter subjects that match no customer are dropped. Soft-deleted customers with revenue or cost in the period are folded into a single 'deleted' row, which always comes last, after 'Other', and takes no top-N slot.
    */
   async getProfitability(
     request: operations.GetProfitabilityRequest,

package/src/sdk/revenue.ts

@@ -13,7 +13,7 @@ export class Revenue extends ClientSDK {
    * Get revenue summary
    *
    * @remarks
-   * Returns revenue summary with invoice and payment breakdowns (outstanding/paid/writtenOff), plus a time-series trend. Revenue is sourced from all issued invoices (v0 + v1) and completed payments.
+   * Returns revenue summary with invoice and payment breakdowns (outstanding/paid/writtenOff), plus a time-series trend. Revenue is what was billed in the period (by default, invoices issued in it; see periodBasis), whatever their status since, less refunds, both excluding tax; completed payments are reported under payments, never in revenue.
    */
   async get(
     request: operations.GetRevenueRequest,

package/src/sdk/sdk.ts

@@ -16,6 +16,7 @@ import { Fees } from "./fees.js";
 import { InvoicesV2 } from "./invoicesv2.js";
 import { Items } from "./items.js";
 import { MerchantIntegrations } from "./merchantintegrations.js";
+import { Merchants } from "./merchants.js";
 import { Orders } from "./orders.js";
 import { Payments } from "./payments.js";
 import { PaymentSessions } from "./paymentsessions.js";
@@ -29,6 +30,7 @@ import { Sources } from "./sources.js";
 import { Subscriptions } from "./subscriptions.js";
 import { TestClocks } from "./testclocks.js";
 import { Users } from "./users.js";
+import { Webhooks } from "./webhooks.js";
 
 export class Paygentic extends ClientSDK {
   private _billableMetrics?: BillableMetrics;
@@ -126,6 +128,11 @@ export class Paygentic extends ClientSDK {
     return (this._testClocks ??= new TestClocks(this._options));
   }
 
+  private _merchants?: Merchants;
+  get merchants(): Merchants {
+    return (this._merchants ??= new Merchants(this._options));
+  }
+
   private _externalReferences?: ExternalReferences;
   get externalReferences(): ExternalReferences {
     return (this._externalReferences ??= new ExternalReferences(this._options));
@@ -162,4 +169,9 @@ export class Paygentic extends ClientSDK {
   get approvals(): Approvals {
     return (this._approvals ??= new Approvals(this._options));
   }
+
+  private _webhooks?: Webhooks;
+  get webhooks(): Webhooks {
+    return (this._webhooks ??= new Webhooks(this._options));
+  }
 }

package/src/sdk/subscriptions.ts

@@ -13,6 +13,7 @@ import { subscriptionsList } from "../funcs/subscriptionsList.js";
 import { subscriptionsListIntervalChanges } from "../funcs/subscriptionsListIntervalChanges.js";
 import { subscriptionsListSubscriptionAdjustments } from "../funcs/subscriptionsListSubscriptionAdjustments.js";
 import { subscriptionsListSubscriptionIntervalChanges } from "../funcs/subscriptionsListSubscriptionIntervalChanges.js";
+import { subscriptionsMigrateSubscriptionVersion } from "../funcs/subscriptionsMigrateSubscriptionVersion.js";
 import { subscriptionsReconcileSubscriptionFeatures } from "../funcs/subscriptionsReconcileSubscriptionFeatures.js";
 import { subscriptionsTerminate } from "../funcs/subscriptionsTerminate.js";
 import { subscriptionsUpdateSubscription } from "../funcs/subscriptionsUpdateSubscription.js";
@@ -115,6 +116,23 @@ export class Subscriptions extends ClientSDK {
     ));
   }
 
+  /**
+   * Migrate To A Plan Version
+   *
+   * @remarks
+   * Moves the subscription to a named version of its plan. By default the move follows the plan's versionTransition. With timing next_period, the move takes effect at the end of the current billing period: the current period bills as before, and each period that starts at or after that boundary bills from the target version. With timing immediate, entitlements change at once, in-arrears prices bill the whole current period at the target version, and in-advance prices change at the end of the current period, with no proration. The target can be an older or a newer published version. A migration always sets versionPolicy to pinned, so a later change of the plan's default version does not move the subscription. To follow the plan default again, call PATCH /v0/subscriptions/{id} with versionPolicy: 'floating'. A second migration before the boundary replaces the first. Migrating to the version the subscription is already on changes nothing except that it pins a floating subscription, so it is safe to repeat. A version number that does not exist on the plan and an archived version both return 404. The request is refused with 409 and a code when: the subscription is not live; the subscription ends at or before the boundary; a kept override has a rate that would mean something else on the new price; a feature's reset period, metric or pricing unit changes; or the new version sells a price that a continuing interval already covers.
+   */
+  async migrateSubscriptionVersion(
+    request: operations.MigrateSubscriptionVersionRequest,
+    options?: RequestOptions,
+  ): Promise<models.MigrateSubscriptionVersionResponse> {
+    return unwrapAsync(subscriptionsMigrateSubscriptionVersion(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * List Interval Changes
    *

package/src/sdk/webhooks.ts

@@ -0,0 +1,100 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { webhooksDisable } from "../funcs/webhooksDisable.js";
+import { webhooksEnable } from "../funcs/webhooksEnable.js";
+import { webhooksGet } from "../funcs/webhooksGet.js";
+import { webhooksGetPortal } from "../funcs/webhooksGetPortal.js";
+import { webhooksUpdate } from "../funcs/webhooksUpdate.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Webhooks extends ClientSDK {
+  /**
+   * Get
+   *
+   * @remarks
+   * Returns the webhook configuration for your account. Returns 404 if webhooks have never been enabled.
+   */
+  async get(
+    request?: operations.GetWebhooksRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.Webhooks> {
+    return unwrapAsync(webhooksGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Enable
+   *
+   * @remarks
+   * Turns on webhook delivery for your account. Call it once: when a configuration already exists, enabled or disabled, the response is 400 with code `DUPLICATE_RESOURCE`. Use the update operation to turn delivery on or off after that. Endpoint URLs, event subscriptions and the signing secret are managed in the webhook portal.
+   */
+  async enable(
+    request?: operations.CreateWebhooksRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.Webhooks> {
+    return unwrapAsync(webhooksEnable(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update
+   *
+   * @remarks
+   * Turns webhook delivery on or off. Set `enabled` to `false` to pause delivery and to `true` to resume it. Endpoints and their event subscriptions are kept. Returns 404 if webhooks have never been enabled.
+   */
+  async update(
+    request: operations.UpdateWebhooksRequest,
+    options?: RequestOptions,
+  ): Promise<models.Webhooks> {
+    return unwrapAsync(webhooksUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Disable
+   *
+   * @remarks
+   * Pauses webhook delivery. This has the same effect as the update operation with `enabled: false`: it does not delete the configuration, the endpoints or their event subscriptions. Use the update operation with `enabled: true` to resume delivery. Returns 404 if webhooks have never been enabled.
+   */
+  async disable(
+    request?: operations.DeleteWebhooksRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(webhooksDisable(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Portal Access
+   *
+   * @remarks
+   * Returns a link to the webhook portal, where you add endpoints, choose event types, read the signing secret and inspect deliveries. The link opens without a login and expires one hour after it is issued, at `expiresAt`. Treat it as a secret. Returns 404 unless webhooks are enabled.
+   */
+  async getPortal(
+    request?: operations.GetWebhookPortalRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.WebhookPortal> {
+    return unwrapAsync(webhooksGetPortal(
+      this,
+      request,
+      options,
+    ));
+  }
+}