@paygentic/sdk 0.9.13 → 0.9.15

package/src/models/operations/updatesubscription.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { ClosedEnum } from "../../types/enums.js";
+import * as models from "../index.js";
 
 export const UpdateSubscriptionStatus = {
   Active: "active",
@@ -55,6 +56,10 @@ export type UpdateSubscriptionRequestBody = {
    * Payment term in days ("Net X") applied to subsequently generated invoices: invoice dueAt = invoice issue date + paymentTermDays. A non-zero value is only valid alongside bankTransferOnly=true. Set 0 for "due on issue". Already-issued invoices keep their snapshotted dueAt.
    */
   paymentTermDays?: number | undefined;
+  /**
+   * How the subscription follows new versions of its plan. `floating` follows the plan's default version: when the default changes, the subscription bills from the new default from its next billing period. `pinned` keeps the plan version that the subscription holds. A subscription created without a value is `floating`. A change to this value does not change a billing period that has already started.
+   */
+  versionPolicy?: models.SubscriptionVersionPolicy | undefined;
 };
 
 export type UpdateSubscriptionRequest = {
@@ -80,6 +85,7 @@ export type UpdateSubscriptionRequestBody$Outbound = {
   renewalReminderEnabled?: boolean | null | undefined;
   renewalReminderDays?: number | null | undefined;
   paymentTermDays?: number | undefined;
+  versionPolicy?: string | undefined;
 };
 
 /** @internal */
@@ -99,6 +105,7 @@ export const UpdateSubscriptionRequestBody$outboundSchema: z.ZodType<
   renewalReminderEnabled: z.nullable(z.boolean()).optional(),
   renewalReminderDays: z.nullable(z.number().int()).optional(),
   paymentTermDays: z.number().int().optional(),
+  versionPolicy: models.SubscriptionVersionPolicy$outboundSchema.optional(),
 });
 
 export function updateSubscriptionRequestBodyToJSON(

package/src/models/profitabilityrow.ts

@@ -6,10 +6,6 @@ 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 {
-  ProfitabilityTrend,
-  ProfitabilityTrend$inboundSchema,
-} from "./profitabilitytrend.js";
 
 export type ProfitabilityRow = {
   /**
@@ -36,10 +32,6 @@ export type ProfitabilityRow = {
    * Margin percent (profit / revenue × 100), with two decimals. Null when revenue is zero.
    */
   marginPct: string | null;
-  /**
-   * Per-customer revenue trend over the period. Null for the 'Other' row and when there's insufficient data.
-   */
-  trend: ProfitabilityTrend | null;
 };
 
 /** @internal */
@@ -54,7 +46,6 @@ export const ProfitabilityRow$inboundSchema: z.ZodType<
   totalCost: z.string(),
   profit: z.string(),
   marginPct: z.nullable(z.string()),
-  trend: z.nullable(ProfitabilityTrend$inboundSchema),
 });
 
 export function profitabilityRowFromJSON(

package/src/models/profitabilitysummaryresponse.ts

@@ -49,9 +49,25 @@ export type ProfitabilitySummaryResponse = {
    */
   currency: string;
   /**
-   * Top-N customer rows by profit descending, optionally followed by a single 'Other' row when more than topN customers contributed.
+   * Top-N customer rows by profit descending, optionally followed by a single 'Other' row when more than topN customers contributed. With `excludeEmpty=true`, customers with neither revenue nor cost in the period are left out.
    */
   rows: Array<ProfitabilityRow>;
+  /**
+   * The merchant's customers this summary scored, whether or not they made a row.
+   */
+  customerCount?: number | undefined;
+  /**
+   * Customers with neither revenue nor cost in the period, counted whether or not `excludeEmpty` left them out of `rows`. Null when a cost read failed: their cost was never established, so none is counted and `excludeEmpty` leaves nobody out.
+   */
+  emptyCustomerCount?: number | null | undefined;
+  /**
+   * Customers `rows` does not carry because a cost read failed (see `warnings`) and they had no revenue in the period. Null when every cost read settled.
+   */
+  unloadedCustomerCount?: number | null | undefined;
+  /**
+   * The customers `emptyCustomerCount` counts that `rows` does not carry, either as a row or folded into the 'Other' row, sorted by name, each reading zero with a null margin. Present only when `includeEmpty=true` and the count is answered. They are never ranked, never part of the top-N and never folded into the 'Other' row.
+   */
+  emptyCustomers?: Array<ProfitabilityRow> | undefined;
   /**
    * Non-fatal warnings collected during cost discovery (e.g. an individual cost query failed). Empty array on a clean run.
    */
@@ -122,6 +138,10 @@ export const ProfitabilitySummaryResponse$inboundSchema: z.ZodType<
   object: z.literal("profitability_summary"),
   currency: z.string(),
   rows: z.array(ProfitabilityRow$inboundSchema),
+  customerCount: z.number().int().optional(),
+  emptyCustomerCount: z.nullable(z.number().int()).optional(),
+  unloadedCustomerCount: z.nullable(z.number().int()).optional(),
+  emptyCustomers: z.array(ProfitabilityRow$inboundSchema).optional(),
   warnings: z.array(z.string()).optional(),
   revenueRange: z.nullable(
     z.lazy(() => ProfitabilitySummaryResponseRevenueRange$inboundSchema),

package/src/models/subscription.ts

@@ -4,13 +4,18 @@
 
 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 {
   SubscriptionMetadata,
   SubscriptionMetadata$inboundSchema,
 } from "./subscriptionmetadata.js";
+import {
+  SubscriptionVersionPolicy,
+  SubscriptionVersionPolicy$inboundSchema,
+} from "./subscriptionversionpolicy.js";
 
 export const SubscriptionObject = {
   Subscription: "subscription",
@@ -109,6 +114,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;
@@ -173,6 +192,10 @@ export type Subscription = {
    * The version number of the plan version referenced by planVersionId, as of subscription creation.
    */
   versionNumber?: number | undefined;
+  /**
+   * How the subscription follows new versions of its plan. `floating` follows the plan's default version: when the default changes, the subscription bills from the new default from its next billing period. `pinned` keeps the plan version that the subscription holds. A subscription created without a value is `floating`. A change to this value does not change a billing period that has already started.
+   */
+  versionPolicy: SubscriptionVersionPolicy;
   /**
    * Deprecated. Legacy-only, not populated for new subscriptions.
    *
@@ -196,6 +219,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.
    */
@@ -350,6 +377,13 @@ 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,
@@ -439,6 +473,7 @@ export const Subscription$inboundSchema: z.ZodType<
   planId: z.string(),
   planVersionId: z.string().optional(),
   versionNumber: z.number().int().optional(),
+  versionPolicy: SubscriptionVersionPolicy$inboundSchema,
   prefundAmount: z.string().optional(),
   minimumAccountBalance: z.string().optional(),
   startedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
@@ -448,6 +483,8 @@ export const Subscription$inboundSchema: z.ZodType<
   ).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/subscriptioninterval.ts

@@ -0,0 +1,152 @@
+/*
+ * 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";
+
+/**
+ * plan_line if the plan version has a line with this priceKey. subscription_owned if it does not, so the interval belongs to this subscription only. After an add, check the kind. A mistyped priceKey creates a subscription_owned interval.
+ */
+export const SubscriptionIntervalKind = {
+  PlanLine: "plan_line",
+  SubscriptionOwned: "subscription_owned",
+} as const;
+/**
+ * plan_line if the plan version has a line with this priceKey. subscription_owned if it does not, so the interval belongs to this subscription only. After an add, check the kind. A mistyped priceKey creates a subscription_owned interval.
+ */
+export type SubscriptionIntervalKind = ClosedEnum<
+  typeof SubscriptionIntervalKind
+>;
+
+export type SubscriptionIntervalQuantityTransition = {
+  effectiveDate: Date;
+  quantity: string;
+};
+
+export const SubscriptionIntervalBillingMode = {
+  Advance: "advance",
+  Arrears: "arrears",
+} as const;
+export type SubscriptionIntervalBillingMode = ClosedEnum<
+  typeof SubscriptionIntervalBillingMode
+>;
+
+/**
+ * A price interval of the subscription.
+ */
+export type SubscriptionInterval = {
+  id: string;
+  /**
+   * The catalog price this interval bills.
+   */
+  priceId: string;
+  /**
+   * Identifies the price line. An override keeps the key of the plan price that it replaces.
+   */
+  priceKey: string;
+  /**
+   * plan_line if the plan version has a line with this priceKey. subscription_owned if it does not, so the interval belongs to this subscription only. After an add, check the kind. A mistyped priceKey creates a subscription_owned interval.
+   */
+  kind: SubscriptionIntervalKind;
+  /**
+   * The plan version of this interval.
+   */
+  planVersionId: string;
+  /**
+   * Signed net unit price for each period, as a decimal string. Null means the interval bills the catalog price.
+   */
+  unitPrice: string | null;
+  /**
+   * Quantity at interval start, as a decimal string.
+   */
+  baseQuantity: string;
+  quantityTransitions: Array<SubscriptionIntervalQuantityTransition>;
+  /**
+   * ISO-8601 duration or 'one_off'
+   */
+  billingCadence: string;
+  billingMode: SubscriptionIntervalBillingMode;
+  /**
+   * The one-time date this interval bills on. Set iff billingCadence is 'one_off'; null for a recurring interval.
+   */
+  billDate: Date | null;
+  startDate: Date;
+  /**
+   * Null for an open-ended interval.
+   */
+  endDate: Date | null;
+};
+
+/** @internal */
+export const SubscriptionIntervalKind$inboundSchema: z.ZodNativeEnum<
+  typeof SubscriptionIntervalKind
+> = z.nativeEnum(SubscriptionIntervalKind);
+
+/** @internal */
+export const SubscriptionIntervalQuantityTransition$inboundSchema: z.ZodType<
+  SubscriptionIntervalQuantityTransition,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  effectiveDate: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  quantity: z.string(),
+});
+
+export function subscriptionIntervalQuantityTransitionFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionIntervalQuantityTransition, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SubscriptionIntervalQuantityTransition$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionIntervalQuantityTransition' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriptionIntervalBillingMode$inboundSchema: z.ZodNativeEnum<
+  typeof SubscriptionIntervalBillingMode
+> = z.nativeEnum(SubscriptionIntervalBillingMode);
+
+/** @internal */
+export const SubscriptionInterval$inboundSchema: z.ZodType<
+  SubscriptionInterval,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  priceId: z.string(),
+  priceKey: z.string(),
+  kind: SubscriptionIntervalKind$inboundSchema,
+  planVersionId: z.string(),
+  unitPrice: z.nullable(z.string()),
+  baseQuantity: z.string(),
+  quantityTransitions: z.array(
+    z.lazy(() => SubscriptionIntervalQuantityTransition$inboundSchema),
+  ),
+  billingCadence: z.string(),
+  billingMode: SubscriptionIntervalBillingMode$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 subscriptionIntervalFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionInterval, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionInterval$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionInterval' from JSON`,
+  );
+}

package/src/models/subscriptionintervaladdop.ts

@@ -0,0 +1,148 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../types/enums.js";
+
+export type SubscriptionIntervalAddOpQuantityTransition = {
+  effectiveDate: Date;
+  /**
+   * Non-negative decimal string.
+   */
+  quantity: string;
+};
+
+export const SubscriptionIntervalAddOpBillingMode = {
+  Advance: "advance",
+  Arrears: "arrears",
+} as const;
+export type SubscriptionIntervalAddOpBillingMode = ClosedEnum<
+  typeof SubscriptionIntervalAddOpBillingMode
+>;
+
+/**
+ * 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.
+ */
+export type SubscriptionIntervalAddOp = {
+  /**
+   * The price line that this interval bills. Use a priceKey from the plan version. A new key must start with a lowercase letter or a digit, use only lowercase letters, digits, hyphens, and underscores, and have 64 characters or fewer.
+   */
+  priceKey: string;
+  /**
+   * The catalog price to bill. Required if priceKey is not on the plan version. If it is on the plan, omit this field or send the price of that line. The price must belong to your merchant account.
+   */
+  priceId?: string | undefined;
+  /**
+   * Optional. If the subscription is on a different plan version, the request fails with 409.
+   */
+  planVersionId?: string | undefined;
+  /**
+   * Signed net unit price for each period, as a decimal string. Null bills the catalog price. For a subscription-only interval, null saves the current catalog price.
+   */
+  unitPrice: string | null;
+  /**
+   * Quantity at interval start, as a non-negative decimal string.
+   */
+  baseQuantity: string;
+  /**
+   * Step changes in quantity partway through the interval.
+   */
+  quantityTransitions?:
+    | Array<SubscriptionIntervalAddOpQuantityTransition>
+    | undefined;
+  /**
+   * ISO-8601 duration or 'one_off'
+   */
+  billingCadence: string;
+  billingMode: SubscriptionIntervalAddOpBillingMode;
+  /**
+   * Required when billingCadence is 'one_off'; must be absent otherwise.
+   */
+  billDate?: Date | null | undefined;
+  startDate: Date;
+  /**
+   * Null for an open-ended interval; when set, must be strictly after startDate.
+   */
+  endDate?: Date | null | undefined;
+};
+
+/** @internal */
+export type SubscriptionIntervalAddOpQuantityTransition$Outbound = {
+  effectiveDate: string;
+  quantity: string;
+};
+
+/** @internal */
+export const SubscriptionIntervalAddOpQuantityTransition$outboundSchema:
+  z.ZodType<
+    SubscriptionIntervalAddOpQuantityTransition$Outbound,
+    z.ZodTypeDef,
+    SubscriptionIntervalAddOpQuantityTransition
+  > = z.object({
+    effectiveDate: z.date().transform(v => v.toISOString()),
+    quantity: z.string(),
+  });
+
+export function subscriptionIntervalAddOpQuantityTransitionToJSON(
+  subscriptionIntervalAddOpQuantityTransition:
+    SubscriptionIntervalAddOpQuantityTransition,
+): string {
+  return JSON.stringify(
+    SubscriptionIntervalAddOpQuantityTransition$outboundSchema.parse(
+      subscriptionIntervalAddOpQuantityTransition,
+    ),
+  );
+}
+
+/** @internal */
+export const SubscriptionIntervalAddOpBillingMode$outboundSchema:
+  z.ZodNativeEnum<typeof SubscriptionIntervalAddOpBillingMode> = z.nativeEnum(
+    SubscriptionIntervalAddOpBillingMode,
+  );
+
+/** @internal */
+export type SubscriptionIntervalAddOp$Outbound = {
+  priceKey: string;
+  priceId?: string | undefined;
+  planVersionId?: string | undefined;
+  unitPrice: string | null;
+  baseQuantity: string;
+  quantityTransitions?:
+    | Array<SubscriptionIntervalAddOpQuantityTransition$Outbound>
+    | undefined;
+  billingCadence: string;
+  billingMode: string;
+  billDate?: string | null | undefined;
+  startDate: string;
+  endDate?: string | null | undefined;
+};
+
+/** @internal */
+export const SubscriptionIntervalAddOp$outboundSchema: z.ZodType<
+  SubscriptionIntervalAddOp$Outbound,
+  z.ZodTypeDef,
+  SubscriptionIntervalAddOp
+> = z.object({
+  priceKey: z.string(),
+  priceId: z.string().optional(),
+  planVersionId: z.string().optional(),
+  unitPrice: z.nullable(z.string()),
+  baseQuantity: z.string(),
+  quantityTransitions: z.array(
+    z.lazy(() => SubscriptionIntervalAddOpQuantityTransition$outboundSchema),
+  ).optional(),
+  billingCadence: z.string(),
+  billingMode: SubscriptionIntervalAddOpBillingMode$outboundSchema,
+  billDate: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+  startDate: z.date().transform(v => v.toISOString()),
+  endDate: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+});
+
+export function subscriptionIntervalAddOpToJSON(
+  subscriptionIntervalAddOp: SubscriptionIntervalAddOp,
+): string {
+  return JSON.stringify(
+    SubscriptionIntervalAddOp$outboundSchema.parse(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`,
+  );
+}