@paygentic/sdk 0.9.12 → 0.9.14

package/src/models/price.ts

@@ -8,39 +8,25 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { PriceFeature, PriceFeature$inboundSchema } from "./pricefeature.js";
+import { PriceModel, PriceModel$inboundSchema } from "./pricemodel.js";
+import {
+  PriceProperties,
+  PriceProperties$inboundSchema,
+} from "./priceproperties.js";
 import { PriceTax, PriceTax$inboundSchema } from "./pricetax.js";
+import { RateType, RateType$inboundSchema } from "./ratetype.js";
 
 export const PriceObject = {
   Price: "price",
 } as const;
 export type PriceObject = ClosedEnum<typeof PriceObject>;
 
-export const PriceModel1 = {
-  Standard: "standard",
-  Dynamic: "dynamic",
-  Volume: "volume",
-  Percentage: "percentage",
-} as const;
-export type PriceModel1 = ClosedEnum<typeof PriceModel1>;
-
 export const PricePaymentTerm = {
   InArrears: "in_arrears",
   InAdvance: "in_advance",
 } as const;
 export type PricePaymentTerm = ClosedEnum<typeof PricePaymentTerm>;
 
-/**
- * What properties.unitPrice is denominated in. 'amount' (the default) is an amount of the invoice currency for each unit metered, so the quantity is the multiplier. 'proportion' is the reverse: a dimensionless share of a currency-denominated quantity, so '0.02' is 2% and the invoice prints '2.00%'. Presentation only. Requires a standard metered price in real currency.
- */
-export const PriceRateType = {
-  Amount: "amount",
-  Proportion: "proportion",
-} as const;
-/**
- * What properties.unitPrice is denominated in. 'amount' (the default) is an amount of the invoice currency for each unit metered, so the quantity is the multiplier. 'proportion' is the reverse: a dimensionless share of a currency-denominated quantity, so '0.02' is 2% and the invoice prints '2.00%'. Presentation only. Requires a standard metered price in real currency.
- */
-export type PriceRateType = ClosedEnum<typeof PriceRateType>;
-
 export type Price = {
   /**
    * Unique identifier for a price
@@ -48,26 +34,37 @@ export type Price = {
   id: string;
   object: PriceObject;
   /**
-   * Unique identifier for an organization
+   * Unique identifier for a billable metric
    */
-  merchantId: string;
   billableMetricId?: string | undefined;
   /**
-   * The unique identifier for the fee referred to by this price
+   * The unique identifier for the fee referred to by this price. Present when price is linked to a fee.
    */
   feeId?: string | undefined;
   /**
-   * ISO 8601 duration for billing frequency (e.g., P1M for monthly)
+   * Unique identifier for a pricing unit
+   */
+  pricingUnitId?: string | undefined;
+  /**
+   * Unique identifier for an organization
+   */
+  merchantId: string;
+  /**
+   * ISO 8601 duration. 'P0D' for one-time, 'P1M' for monthly, 'P1Y' for yearly. Required for fees, optional for billable metrics. Defaults to plan's billingCadence if not specified.
    */
   billingCadence?: string | null | undefined;
   createdAt: Date;
-  currency?: string | undefined;
-  description?: string | undefined;
   invoiceDisplayName: string;
-  model: PriceModel1;
+  /**
+   * Presentation only. Prices sharing this value, within one billing period, print as a single row on the rendered invoice PDF and are described by this string. Every member still bills its own line item on the ledger, this API and the compliance document. The combined row's rate is derived from the members' own rates. Requires the 'standard' pricing model. Sample values: 'Cross Border Fees', 'FX Fees'
+   */
+  invoiceDisplayGroup?: string | null | undefined;
+  /**
+   * Pricing model of a price as returned by the API. Includes the legacy models ('dynamic', 'percentage') retained for existing prices; 'standard' and 'volume' can be created (see PriceModelInput).
+   */
+  model?: PriceModel | undefined;
   paymentTerm: PricePaymentTerm;
-  properties: { [k: string]: any };
-  unitAmount?: string | undefined;
+  properties: PriceProperties;
   updatedAt: Date;
   /**
    * Features associated with this price
@@ -84,21 +81,13 @@ export type Price = {
   /**
    * What properties.unitPrice is denominated in. 'amount' (the default) is an amount of the invoice currency for each unit metered, so the quantity is the multiplier. 'proportion' is the reverse: a dimensionless share of a currency-denominated quantity, so '0.02' is 2% and the invoice prints '2.00%'. Presentation only. Requires a standard metered price in real currency.
    */
-  rateType: PriceRateType;
-  /**
-   * Presentation only. Prices sharing this value, within one billing period, print as a single row on the rendered invoice PDF and are described by this string. Every member still bills its own line item on the ledger, this API and the compliance document. The combined row's rate is derived from the members' own rates. Requires the 'standard' pricing model. Sample values: 'Cross Border Fees', 'FX Fees'
-   */
-  invoiceDisplayGroup?: string | null | undefined;
-  /**
-   * Unique identifier for a pricing unit
-   */
-  pricingUnitId?: string | undefined;
+  rateType?: RateType | undefined;
   /**
    * A price's tax declaration. Optional on write — a price that declares nothing is `IN_SCOPE`, and is billed and taxed exactly as it was before this object existed. Always present on read. Replaced as a whole on update: send the object to change it, omit it to leave it alone.
    */
   tax: PriceTax;
   /**
-   * Quantity used when generating invoice line items for this price. Total per period = quantity × unitPrice. Only supported for fee prices; metered prices derive quantity from usage. Defaults to 1.
+   * Quantity for invoice line items. Total per period = quantity × unitPrice. Only supported for fee prices; metered prices derive quantity from usage. Defaults to 1.
    */
   quantity: number;
 };
@@ -107,50 +96,38 @@ export type Price = {
 export const PriceObject$inboundSchema: z.ZodNativeEnum<typeof PriceObject> = z
   .nativeEnum(PriceObject);
 
-/** @internal */
-export const PriceModel1$inboundSchema: z.ZodNativeEnum<typeof PriceModel1> = z
-  .nativeEnum(PriceModel1);
-
 /** @internal */
 export const PricePaymentTerm$inboundSchema: z.ZodNativeEnum<
   typeof PricePaymentTerm
 > = z.nativeEnum(PricePaymentTerm);
 
-/** @internal */
-export const PriceRateType$inboundSchema: z.ZodNativeEnum<
-  typeof PriceRateType
-> = z.nativeEnum(PriceRateType);
-
 /** @internal */
 export const Price$inboundSchema: z.ZodType<Price, z.ZodTypeDef, unknown> = z
   .object({
     id: z.string(),
     object: PriceObject$inboundSchema.default("price"),
-    merchantId: z.string(),
     billableMetricId: z.string().optional(),
     feeId: z.string().optional(),
+    pricingUnitId: z.string().optional(),
+    merchantId: z.string(),
     billingCadence: z.nullable(z.string()).optional(),
     createdAt: z.string().datetime({ offset: true }).transform(v =>
       new Date(v)
     ),
-    currency: z.string().optional(),
-    description: z.string().optional(),
     invoiceDisplayName: z.string(),
-    model: PriceModel1$inboundSchema,
+    invoiceDisplayGroup: z.nullable(z.string()).optional(),
+    model: PriceModel$inboundSchema.optional(),
     paymentTerm: PricePaymentTerm$inboundSchema,
-    properties: z.record(z.any()),
-    unitAmount: z.string().optional(),
+    properties: PriceProperties$inboundSchema,
     updatedAt: z.string().datetime({ offset: true }).transform(v =>
       new Date(v)
     ),
     features: z.array(PriceFeature$inboundSchema).optional(),
     grantDiscountEnabled: z.boolean().default(false),
     isObligation: z.boolean().default(false),
-    rateType: PriceRateType$inboundSchema.default("amount"),
-    invoiceDisplayGroup: z.nullable(z.string()).optional(),
-    pricingUnitId: z.string().optional(),
+    rateType: RateType$inboundSchema.optional(),
     tax: PriceTax$inboundSchema,
-    quantity: z.number().int().default(1),
+    quantity: z.number().int(),
   });
 
 export function priceFromJSON(

package/src/models/subscription.ts

@@ -11,6 +11,10 @@ import {
   SubscriptionMetadata,
   SubscriptionMetadata$inboundSchema,
 } from "./subscriptionmetadata.js";
+import {
+  SubscriptionVersionPolicy,
+  SubscriptionVersionPolicy$inboundSchema,
+} from "./subscriptionversionpolicy.js";
 
 export const SubscriptionObject = {
   Subscription: "subscription",
@@ -173,6 +177,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.
    *
@@ -439,6 +447,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)),

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

@@ -0,0 +1,166 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../types/enums.js";
+
+export type SubscriptionIntervalEditOpQuantityTransition = {
+  effectiveDate: Date;
+  /**
+   * Non-negative decimal string.
+   */
+  quantity: string;
+};
+
+/**
+ * Not editable. Must match the interval's current value if supplied.
+ */
+export const SubscriptionIntervalEditOpBillingMode = {
+  Advance: "advance",
+  Arrears: "arrears",
+} as const;
+/**
+ * Not editable. Must match the interval's current value if supplied.
+ */
+export type SubscriptionIntervalEditOpBillingMode = ClosedEnum<
+  typeof SubscriptionIntervalEditOpBillingMode
+>;
+
+/**
+ * Edits an interval by id. You can change unitPrice, baseQuantity, quantityTransitions, and endDate. Other fields must match the current value if you send them. To bill a different priceId, remove the interval and add a new one.
+ */
+export type SubscriptionIntervalEditOp = {
+  /**
+   * The interval being edited.
+   */
+  id: string;
+  /**
+   * Signed per-period net unit price as a decimal string. Set to null to revert to the catalog price. Omit to leave unchanged.
+   */
+  unitPrice?: string | null | undefined;
+  /**
+   * Quantity at interval start, as a non-negative decimal string. Omit to leave unchanged.
+   */
+  baseQuantity?: string | undefined;
+  /**
+   * Step changes in quantity partway through the interval. Omit to leave unchanged.
+   */
+  quantityTransitions?:
+    | Array<SubscriptionIntervalEditOpQuantityTransition>
+    | undefined;
+  /**
+   * Not editable. Must match the interval's current value if supplied.
+   */
+  priceId?: string | undefined;
+  /**
+   * Not editable. Must match the interval's current value if supplied.
+   */
+  priceKey?: string | undefined;
+  /**
+   * Not editable. Must match the interval's current value if supplied.
+   */
+  planVersionId?: string | undefined;
+  /**
+   * Not editable. Must match the interval's current value if supplied.
+   */
+  billingCadence?: string | undefined;
+  /**
+   * Not editable. Must match the interval's current value if supplied.
+   */
+  billingMode?: SubscriptionIntervalEditOpBillingMode | undefined;
+  /**
+   * Not editable. Must match the interval's current value if supplied.
+   */
+  billDate?: Date | null | undefined;
+  /**
+   * Not editable. Must match the interval's current value if supplied.
+   */
+  startDate?: Date | undefined;
+  /**
+   * When the interval stops billing. Send a date on or inside one of the billing periods to close the price. Send null to re-open it. Omit to keep the current value.
+   */
+  endDate?: Date | null | undefined;
+};
+
+/** @internal */
+export type SubscriptionIntervalEditOpQuantityTransition$Outbound = {
+  effectiveDate: string;
+  quantity: string;
+};
+
+/** @internal */
+export const SubscriptionIntervalEditOpQuantityTransition$outboundSchema:
+  z.ZodType<
+    SubscriptionIntervalEditOpQuantityTransition$Outbound,
+    z.ZodTypeDef,
+    SubscriptionIntervalEditOpQuantityTransition
+  > = z.object({
+    effectiveDate: z.date().transform(v => v.toISOString()),
+    quantity: z.string(),
+  });
+
+export function subscriptionIntervalEditOpQuantityTransitionToJSON(
+  subscriptionIntervalEditOpQuantityTransition:
+    SubscriptionIntervalEditOpQuantityTransition,
+): string {
+  return JSON.stringify(
+    SubscriptionIntervalEditOpQuantityTransition$outboundSchema.parse(
+      subscriptionIntervalEditOpQuantityTransition,
+    ),
+  );
+}
+
+/** @internal */
+export const SubscriptionIntervalEditOpBillingMode$outboundSchema:
+  z.ZodNativeEnum<typeof SubscriptionIntervalEditOpBillingMode> = z.nativeEnum(
+    SubscriptionIntervalEditOpBillingMode,
+  );
+
+/** @internal */
+export type SubscriptionIntervalEditOp$Outbound = {
+  id: string;
+  unitPrice?: string | null | undefined;
+  baseQuantity?: string | undefined;
+  quantityTransitions?:
+    | Array<SubscriptionIntervalEditOpQuantityTransition$Outbound>
+    | undefined;
+  priceId?: string | undefined;
+  priceKey?: string | undefined;
+  planVersionId?: string | undefined;
+  billingCadence?: string | undefined;
+  billingMode?: string | undefined;
+  billDate?: string | null | undefined;
+  startDate?: string | undefined;
+  endDate?: string | null | undefined;
+};
+
+/** @internal */
+export const SubscriptionIntervalEditOp$outboundSchema: z.ZodType<
+  SubscriptionIntervalEditOp$Outbound,
+  z.ZodTypeDef,
+  SubscriptionIntervalEditOp
+> = z.object({
+  id: z.string(),
+  unitPrice: z.nullable(z.string()).optional(),
+  baseQuantity: z.string().optional(),
+  quantityTransitions: z.array(
+    z.lazy(() => SubscriptionIntervalEditOpQuantityTransition$outboundSchema),
+  ).optional(),
+  priceId: z.string().optional(),
+  priceKey: z.string().optional(),
+  planVersionId: z.string().optional(),
+  billingCadence: z.string().optional(),
+  billingMode: SubscriptionIntervalEditOpBillingMode$outboundSchema.optional(),
+  billDate: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+  startDate: z.date().transform(v => v.toISOString()).optional(),
+  endDate: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+});
+
+export function subscriptionIntervalEditOpToJSON(
+  subscriptionIntervalEditOp: SubscriptionIntervalEditOp,
+): string {
+  return JSON.stringify(
+    SubscriptionIntervalEditOp$outboundSchema.parse(subscriptionIntervalEditOp),
+  );
+}