@paygentic/sdk 0.9.14 → 0.9.16

package/src/models/subscription.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
@@ -106,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",
@@ -113,6 +128,20 @@ export const SubscriptionStatusEnum = {
 } as const;
 export type SubscriptionStatusEnum = ClosedEnum<typeof SubscriptionStatusEnum>;
 
+/**
+ * Why the subscription was terminated. Null while it is not terminated.
+ */
+export const TerminationChangeReason = {
+  Commercial: "commercial",
+  Correction: "correction",
+  Migration: "migration",
+  Unspecified: "unspecified",
+} as const;
+/**
+ * Why the subscription was terminated. Null while it is not terminated.
+ */
+export type TerminationChangeReason = OpenEnum<typeof TerminationChangeReason>;
+
 export type Merchant = {
   id: string;
   name: string;
@@ -194,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;
   /**
@@ -204,6 +249,10 @@ export type Subscription = {
    * Reason for termination
    */
   terminationReason?: string | undefined;
+  /**
+   * Why the subscription was terminated. Null while it is not terminated.
+   */
+  terminationChangeReason?: TerminationChangeReason | null | undefined;
   /**
    * Test clock ID if this subscription is attached to a test clock. Only present in non-production environments.
    */
@@ -353,11 +402,23 @@ export function paymentUnionFromJSON(
   );
 }
 
+/** @internal */
+export const SubscriptionElapsedPeriodBilling$inboundSchema: z.ZodNativeEnum<
+  typeof SubscriptionElapsedPeriodBilling
+> = z.nativeEnum(SubscriptionElapsedPeriodBilling);
+
 /** @internal */
 export const SubscriptionStatusEnum$inboundSchema: z.ZodNativeEnum<
   typeof SubscriptionStatusEnum
 > = z.nativeEnum(SubscriptionStatusEnum);
 
+/** @internal */
+export const TerminationChangeReason$inboundSchema: z.ZodType<
+  TerminationChangeReason,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(TerminationChangeReason);
+
 /** @internal */
 export const Merchant$inboundSchema: z.ZodType<
   Merchant,
@@ -451,12 +512,24 @@ 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)
   ).optional(),
   terminatedBy: z.string().optional(),
   terminationReason: z.string().optional(),
+  terminationChangeReason: z.nullable(TerminationChangeReason$inboundSchema)
+    .optional(),
   testClockId: z.string().optional(),
   updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
   walletId: z.string().optional(),

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/subscriptionintervalchange.ts

@@ -0,0 +1,66 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChangeReason, ChangeReason$inboundSchema } from "./changereason.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  IntervalChangeMetadata,
+  IntervalChangeMetadata$inboundSchema,
+} from "./intervalchangemetadata.js";
+import {
+  SubscriptionIntervalChangeEntry,
+  SubscriptionIntervalChangeEntry$inboundSchema,
+} from "./subscriptionintervalchangeentry.js";
+
+/**
+ * The record of one change to a subscription's price intervals: what changed, and why.
+ */
+export type SubscriptionIntervalChange = {
+  id: string;
+  merchantId: string;
+  subscriptionId: string;
+  /**
+   * Why a change was made. `correction` fixes data to match what was agreed; `migration` moves a contract from another system; `commercial` is a real change to the deal. Defaults to `unspecified`.
+   */
+  changeReason: ChangeReason;
+  description: string | null;
+  /**
+   * Your own key-value data about the change, such as a CRM deal ID.
+   */
+  metadata: { [k: string]: IntervalChangeMetadata };
+  createdAt: Date;
+  /**
+   * One entry per interval the edit added, changed or removed.
+   */
+  intervals: Array<SubscriptionIntervalChangeEntry>;
+};
+
+/** @internal */
+export const SubscriptionIntervalChange$inboundSchema: z.ZodType<
+  SubscriptionIntervalChange,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  merchantId: z.string(),
+  subscriptionId: z.string(),
+  changeReason: ChangeReason$inboundSchema,
+  description: z.nullable(z.string()),
+  metadata: z.record(IntervalChangeMetadata$inboundSchema),
+  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  intervals: z.array(SubscriptionIntervalChangeEntry$inboundSchema),
+});
+
+export function subscriptionIntervalChangeFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionIntervalChange, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionIntervalChange$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionIntervalChange' from JSON`,
+  );
+}

package/src/models/subscriptionintervalchangecopy.ts

@@ -0,0 +1,130 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type SubscriptionIntervalChangeCopyQuantityTransition = {
+  effectiveDate: Date;
+  quantity: string;
+};
+
+export const SubscriptionIntervalChangeCopyBillingMode = {
+  Advance: "advance",
+  Arrears: "arrears",
+} as const;
+export type SubscriptionIntervalChangeCopyBillingMode = OpenEnum<
+  typeof SubscriptionIntervalChangeCopyBillingMode
+>;
+
+/**
+ * What an interval billed at one point in time.
+ */
+export type SubscriptionIntervalChangeCopy = {
+  priceId: string;
+  priceKey: string;
+  /**
+   * The plan version the interval belongs to.
+   */
+  planVersionId: string;
+  /**
+   * The rate as a decimal string, or null when the interval bills the catalog rate.
+   */
+  unitPrice: string | null;
+  /**
+   * The per-unit rate the interval charged when the change was made.
+   */
+  resolvedUnitPrice: string;
+  baseQuantity: string;
+  quantityTransitions: Array<SubscriptionIntervalChangeCopyQuantityTransition>;
+  /**
+   * ISO-8601 duration or 'one_off'
+   */
+  billingCadence: string;
+  billingMode: SubscriptionIntervalChangeCopyBillingMode;
+  /**
+   * When a one-off interval bills. Null for every other cadence.
+   */
+  billDate: Date | null;
+  startDate: Date;
+  endDate: Date | null;
+};
+
+/** @internal */
+export const SubscriptionIntervalChangeCopyQuantityTransition$inboundSchema:
+  z.ZodType<
+    SubscriptionIntervalChangeCopyQuantityTransition,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    effectiveDate: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ),
+    quantity: z.string(),
+  });
+
+export function subscriptionIntervalChangeCopyQuantityTransitionFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  SubscriptionIntervalChangeCopyQuantityTransition,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SubscriptionIntervalChangeCopyQuantityTransition$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'SubscriptionIntervalChangeCopyQuantityTransition' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriptionIntervalChangeCopyBillingMode$inboundSchema: z.ZodType<
+  SubscriptionIntervalChangeCopyBillingMode,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(SubscriptionIntervalChangeCopyBillingMode);
+
+/** @internal */
+export const SubscriptionIntervalChangeCopy$inboundSchema: z.ZodType<
+  SubscriptionIntervalChangeCopy,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  priceId: z.string(),
+  priceKey: z.string(),
+  planVersionId: z.string(),
+  unitPrice: z.nullable(z.string()),
+  resolvedUnitPrice: z.string(),
+  baseQuantity: z.string(),
+  quantityTransitions: z.array(
+    z.lazy(() =>
+      SubscriptionIntervalChangeCopyQuantityTransition$inboundSchema
+    ),
+  ),
+  billingCadence: z.string(),
+  billingMode: SubscriptionIntervalChangeCopyBillingMode$inboundSchema,
+  billDate: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  startDate: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  endDate: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+});
+
+export function subscriptionIntervalChangeCopyFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionIntervalChangeCopy, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionIntervalChangeCopy$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionIntervalChangeCopy' from JSON`,
+  );
+}

package/src/models/subscriptionintervalchangeentry.ts

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  SubscriptionIntervalChangeCopy,
+  SubscriptionIntervalChangeCopy$inboundSchema,
+} from "./subscriptionintervalchangecopy.js";
+
+/**
+ * One interval that the change added, edited or removed, with its state before and after.
+ */
+export type SubscriptionIntervalChangeEntry = {
+  intervalId: string;
+  /**
+   * The interval before the edit. Null when the edit added it.
+   */
+  before: SubscriptionIntervalChangeCopy | null;
+  /**
+   * The interval after the edit. Null when the edit removed it.
+   */
+  after: SubscriptionIntervalChangeCopy | null;
+};
+
+/** @internal */
+export const SubscriptionIntervalChangeEntry$inboundSchema: z.ZodType<
+  SubscriptionIntervalChangeEntry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  intervalId: z.string(),
+  before: z.nullable(SubscriptionIntervalChangeCopy$inboundSchema),
+  after: z.nullable(SubscriptionIntervalChangeCopy$inboundSchema),
+});
+
+export function subscriptionIntervalChangeEntryFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionIntervalChangeEntry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionIntervalChangeEntry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionIntervalChangeEntry' from JSON`,
+  );
+}

package/src/models/subscriptionintervalchangesresponse.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  OffsetPagination,
+  OffsetPagination$inboundSchema,
+} from "./offsetpagination.js";
+import {
+  SubscriptionIntervalChange,
+  SubscriptionIntervalChange$inboundSchema,
+} from "./subscriptionintervalchange.js";
+
+export type SubscriptionIntervalChangesResponse = {
+  data: Array<SubscriptionIntervalChange>;
+  /**
+   * Offset-based pagination response.
+   */
+  pagination: OffsetPagination;
+};
+
+/** @internal */
+export const SubscriptionIntervalChangesResponse$inboundSchema: z.ZodType<
+  SubscriptionIntervalChangesResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.array(SubscriptionIntervalChange$inboundSchema),
+  pagination: OffsetPagination$inboundSchema,
+});
+
+export function subscriptionIntervalChangesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionIntervalChangesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SubscriptionIntervalChangesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionIntervalChangesResponse' from JSON`,
+  );
+}

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`,
+  );
+}