@flexprice/sdk 2.1.47 → 2.1.48-dev.2

package/src/sdk/commitments.ts

@@ -3,10 +3,15 @@
  */
 
 import { commitmentsCreateCommitment } from "../funcs/commitments-create-commitment.js";
+import { commitmentsGetCommitmentBillingTerms } from "../funcs/commitments-get-commitment-billing-terms.js";
 import { commitmentsGetCommitment } from "../funcs/commitments-get-commitment.js";
+import { commitmentsListCommitmentInstalments } from "../funcs/commitments-list-commitment-instalments.js";
+import { commitmentsPreviewCommitmentBillingTerms } from "../funcs/commitments-preview-commitment-billing-terms.js";
 import { commitmentsPreviewCommitment } from "../funcs/commitments-preview-commitment.js";
 import { commitmentsQueryCommitment } from "../funcs/commitments-query-commitment.js";
+import { commitmentsReplaceCommitmentBillingTerms } from "../funcs/commitments-replace-commitment-billing-terms.js";
 import { commitmentsTerminateCommitment } from "../funcs/commitments-terminate-commitment.js";
+import { commitmentsTriggerCommitmentInstalment } from "../funcs/commitments-trigger-commitment-instalment.js";
 import { commitmentsUpdateCommitment } from "../funcs/commitments-update-commitment.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -100,11 +105,106 @@ export class Commitments extends ClientSDK {
     ));
   }
 
+  /**
+   * Get billing terms
+   *
+   * @remarks
+   * Returns the commitment's current billing terms with its scheduled and invoiced instalments in billing order. Invoiced instalments may come from terms an edit replaced. Cancelled instalments are listed by the instalments endpoint.
+   */
+  async getCommitmentBillingTerms(
+    id: string,
+    options?: RequestOptions,
+  ): Promise<models.BillingTermsResponse> {
+    return unwrapAsync(commitmentsGetCommitmentBillingTerms(
+      this,
+      id,
+      options,
+    ));
+  }
+
+  /**
+   * Edit billing terms
+   *
+   * @remarks
+   * Replaces the whole set of billing terms of an active commitment. Its scheduled instalments are cancelled and the new terms generate instalments for what the invoiced ones leave of the commitment total; invoiced instalments and their invoices are kept. A term without bill_on or start_date starts at the billing period holding now, or at the commitment start once its term has ended. Returns the new terms with the scheduled and invoiced instalments in billing order.
+   */
+  async replaceCommitmentBillingTerms(
+    id: string,
+    body: models.ReplaceBillingTermsRequest,
+    options?: RequestOptions,
+  ): Promise<models.BillingTermsResponse> {
+    return unwrapAsync(commitmentsReplaceCommitmentBillingTerms(
+      this,
+      id,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Preview billing terms edit
+   *
+   * @remarks
+   * Returns what editing the billing terms would produce, without saving anything: the new terms with the invoiced and new instalments in billing order.
+   */
+  async previewCommitmentBillingTerms(
+    id: string,
+    body: models.ReplaceBillingTermsRequest,
+    options?: RequestOptions,
+  ): Promise<models.BillingTermsResponse> {
+    return unwrapAsync(commitmentsPreviewCommitmentBillingTerms(
+      this,
+      id,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * List instalments
+   *
+   * @remarks
+   * Lists the instalments of the commitment in billing order. Without a status filter every instalment is listed, cancelled ones included.
+   */
+  async listCommitmentInstalments(
+    id: string,
+    status?: Array<string> | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListInstalmentsResponse> {
+    return unwrapAsync(commitmentsListCommitmentInstalments(
+      this,
+      id,
+      status,
+      options,
+    ));
+  }
+
+  /**
+   * Trigger instalment
+   *
+   * @remarks
+   * Bills a manual instalment of an active commitment on bill_on, now by default, which must fall within the commitment term. The instalment goes on the first subscription invoice at or after that date, or on its own invoice once due when the commitment's instalment_invoicing is separate_invoice. Either way it waits while the subscription is trialing or paused. Until it is triggered, a manual instalment waits at the end of the term, and bill_on can only move earlier; edit the billing terms to bill it later.
+   */
+  async triggerCommitmentInstalment(
+    id: string,
+    instalmentId: string,
+    body?: models.TriggerInstalmentRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.BillingtermInstalment> {
+    return unwrapAsync(commitmentsTriggerCommitmentInstalment(
+      this,
+      id,
+      instalmentId,
+      body,
+      options,
+    ));
+  }
+
   /**
    * Terminate commitment
    *
    * @remarks
-   * Ends a commitment early, effective at the given time or now.
+   * Ends a commitment immediately. effective_at defaults to now and cannot be in the future. Under billing terms, its scheduled instalments are cancelled and any amount it earned beyond what is already invoiced is billed as a settlement. The settlement and a fixed cancellation fee, when given, are billed together on one one-off invoice.
    */
   async terminateCommitment(
     id: string,

package/src/sdk/models/billing-term-input.ts

@@ -0,0 +1,116 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import {
+  BillingTermKind,
+  BillingTermKind$outboundSchema,
+} from "./billing-term-kind.js";
+import {
+  BillingTermSplit,
+  BillingTermSplit$outboundSchema,
+} from "./billing-term-split.js";
+import {
+  BillingTermValueType,
+  BillingTermValueType$outboundSchema,
+} from "./billing-term-value-type.js";
+import {
+  InstalmentBillTrigger,
+  InstalmentBillTrigger$outboundSchema,
+} from "./instalment-bill-trigger.js";
+import {
+  InvoiceCadence,
+  InvoiceCadence$outboundSchema,
+} from "./invoice-cadence.js";
+
+export type BillingTermInput = {
+  /**
+   * BillOn is a whole second, the commitment start by default. On an edit it defaults to the start of the billing
+   *
+   * @remarks
+   * period holding now, or to the commitment start once the term has ended.
+   */
+  billOn?: string | undefined;
+  billTrigger?: InstalmentBillTrigger | undefined;
+  endDate?: Date | undefined;
+  invoiceCadence?: InvoiceCadence | undefined;
+  /**
+   * InvoiceLabel names the term's instalments on the invoice, "Instalment {n} of {of}" by default. {n} and {of} are
+   *
+   * @remarks
+   * filled with each instalment's place among all of the commitment's instalments and their count.
+   */
+  invoiceLabel?: string | undefined;
+  kind: BillingTermKind;
+  metadata?: { [k: string]: string } | undefined;
+  periodCount?: number | undefined;
+  split?: BillingTermSplit | undefined;
+  /**
+   * StartDate defaults like BillOn; EndDate defaults to the commitment end. Both are whole seconds.
+   */
+  startDate?: Date | undefined;
+  value?: string | undefined;
+  /**
+   * fixed or remainder; percentage is reserved and rejected as not supported yet
+   */
+  valueType: BillingTermValueType;
+};
+
+/** @internal */
+export type BillingTermInput$Outbound = {
+  bill_on?: string | undefined;
+  bill_trigger?: string | undefined;
+  end_date?: string | undefined;
+  invoice_cadence?: string | undefined;
+  invoice_label?: string | undefined;
+  kind: string;
+  metadata?: { [k: string]: string } | undefined;
+  period_count?: number | undefined;
+  split?: string | undefined;
+  start_date?: string | undefined;
+  value?: string | undefined;
+  value_type: string;
+};
+
+/** @internal */
+export const BillingTermInput$outboundSchema: z.ZodMiniType<
+  BillingTermInput$Outbound,
+  BillingTermInput
+> = z.pipe(
+  z.object({
+    billOn: z.optional(z.string()),
+    billTrigger: z.optional(InstalmentBillTrigger$outboundSchema),
+    endDate: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+    invoiceCadence: z.optional(InvoiceCadence$outboundSchema),
+    invoiceLabel: z.optional(z.string()),
+    kind: BillingTermKind$outboundSchema,
+    metadata: z.optional(z.record(z.string(), z.string())),
+    periodCount: z.optional(z.int()),
+    split: z.optional(BillingTermSplit$outboundSchema),
+    startDate: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+    value: z.optional(z.string()),
+    valueType: BillingTermValueType$outboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      billOn: "bill_on",
+      billTrigger: "bill_trigger",
+      endDate: "end_date",
+      invoiceCadence: "invoice_cadence",
+      invoiceLabel: "invoice_label",
+      periodCount: "period_count",
+      startDate: "start_date",
+      valueType: "value_type",
+    });
+  }),
+);
+
+export function billingTermInputToJSON(
+  billingTermInput: BillingTermInput,
+): string {
+  return JSON.stringify(
+    BillingTermInput$outboundSchema.parse(billingTermInput),
+  );
+}

package/src/sdk/models/billing-term-kind.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const BillingTermKind = {
+  Once: "once",
+  Recurring: "recurring",
+} as const;
+export type BillingTermKind = OpenEnum<typeof BillingTermKind>;
+
+/** @internal */
+export const BillingTermKind$inboundSchema: z.ZodMiniType<
+  BillingTermKind,
+  unknown
+> = openEnums.inboundSchema(BillingTermKind);
+/** @internal */
+export const BillingTermKind$outboundSchema: z.ZodMiniType<
+  string,
+  BillingTermKind
+> = openEnums.outboundSchema(BillingTermKind);

package/src/sdk/models/billing-term-owner-type.ts

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const BillingTermOwnerType = {
+  Commitment: "commitment",
+} as const;
+export type BillingTermOwnerType = ClosedEnum<typeof BillingTermOwnerType>;
+
+/** @internal */
+export const BillingTermOwnerType$inboundSchema: z.ZodMiniEnum<
+  typeof BillingTermOwnerType
+> = z.enum(BillingTermOwnerType);

package/src/sdk/models/billing-term-split.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const BillingTermSplit = {
+  Even: "even",
+  Proportional: "proportional",
+} as const;
+export type BillingTermSplit = OpenEnum<typeof BillingTermSplit>;
+
+/** @internal */
+export const BillingTermSplit$inboundSchema: z.ZodMiniType<
+  BillingTermSplit,
+  unknown
+> = openEnums.inboundSchema(BillingTermSplit);
+/** @internal */
+export const BillingTermSplit$outboundSchema: z.ZodMiniType<
+  string,
+  BillingTermSplit
+> = openEnums.outboundSchema(BillingTermSplit);

package/src/sdk/models/billing-term-value-type.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+/**
+ * fixed or remainder; percentage is reserved and rejected as not supported yet
+ */
+export const BillingTermValueType = {
+  Fixed: "fixed",
+  Percentage: "percentage",
+  Remainder: "remainder",
+} as const;
+/**
+ * fixed or remainder; percentage is reserved and rejected as not supported yet
+ */
+export type BillingTermValueType = OpenEnum<typeof BillingTermValueType>;
+
+/** @internal */
+export const BillingTermValueType$inboundSchema: z.ZodMiniType<
+  BillingTermValueType,
+  unknown
+> = openEnums.inboundSchema(BillingTermValueType);
+/** @internal */
+export const BillingTermValueType$outboundSchema: z.ZodMiniType<
+  string,
+  BillingTermValueType
+> = openEnums.outboundSchema(BillingTermValueType);

package/src/sdk/models/billing-terms-response.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import {
+  BillingtermInstalment,
+  BillingtermInstalment$inboundSchema,
+} from "./billingterm-instalment.js";
+import {
+  BillingtermTerm,
+  BillingtermTerm$inboundSchema,
+} from "./billingterm-term.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type BillingTermsResponse = {
+  billingTerms?: Array<BillingtermTerm> | undefined;
+  instalments?: Array<BillingtermInstalment> | undefined;
+};
+
+/** @internal */
+export const BillingTermsResponse$inboundSchema: z.ZodMiniType<
+  BillingTermsResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    billing_terms: types.optional(z.array(BillingtermTerm$inboundSchema)),
+    instalments: types.optional(z.array(BillingtermInstalment$inboundSchema)),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "billing_terms": "billingTerms",
+    });
+  }),
+);
+
+export function billingTermsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<BillingTermsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BillingTermsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BillingTermsResponse' from JSON`,
+  );
+}

package/src/sdk/models/billingterm-instalment.ts

@@ -0,0 +1,128 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import {
+  BillingTermOwnerType,
+  BillingTermOwnerType$inboundSchema,
+} from "./billing-term-owner-type.js";
+import {
+  InstalmentBillTrigger,
+  InstalmentBillTrigger$inboundSchema,
+} from "./instalment-bill-trigger.js";
+import {
+  InstalmentDelivery,
+  InstalmentDelivery$inboundSchema,
+} from "./instalment-delivery.js";
+import {
+  InstalmentKind,
+  InstalmentKind$inboundSchema,
+} from "./instalment-kind.js";
+import {
+  InstalmentStatus,
+  InstalmentStatus$inboundSchema,
+} from "./instalment-status.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+import { Status, Status$inboundSchema } from "./status.js";
+
+export type BillingtermInstalment = {
+  amount?: string | undefined;
+  billOn?: string | undefined;
+  billTrigger?: InstalmentBillTrigger | undefined;
+  billingTermId?: string | undefined;
+  createdAt?: Date | undefined;
+  createdBy?: string | undefined;
+  currency?: string | undefined;
+  customerId?: string | undefined;
+  delivery?: InstalmentDelivery | undefined;
+  environmentId?: string | undefined;
+  id?: string | undefined;
+  instalmentStatus?: InstalmentStatus | undefined;
+  invoiceId?: string | undefined;
+  invoiceLabel?: string | undefined;
+  kind?: InstalmentKind | undefined;
+  metadata?: { [k: string]: string } | undefined;
+  ownerId?: string | undefined;
+  ownerType?: BillingTermOwnerType | undefined;
+  servicePeriodEnd?: Date | undefined;
+  servicePeriodStart?: Date | undefined;
+  status?: Status | undefined;
+  subscriptionId?: string | undefined;
+  tenantId?: string | undefined;
+  triggeredAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+  updatedBy?: string | undefined;
+};
+
+/** @internal */
+export const BillingtermInstalment$inboundSchema: z.ZodMiniType<
+  BillingtermInstalment,
+  unknown
+> = z.pipe(
+  z.object({
+    amount: types.optional(types.string()),
+    bill_on: types.optional(types.string()),
+    bill_trigger: types.optional(InstalmentBillTrigger$inboundSchema),
+    billing_term_id: types.optional(types.string()),
+    created_at: types.optional(types.date()),
+    created_by: types.optional(types.string()),
+    currency: types.optional(types.string()),
+    customer_id: types.optional(types.string()),
+    delivery: types.optional(InstalmentDelivery$inboundSchema),
+    environment_id: types.optional(types.string()),
+    id: types.optional(types.string()),
+    instalment_status: types.optional(InstalmentStatus$inboundSchema),
+    invoice_id: types.optional(types.string()),
+    invoice_label: types.optional(types.string()),
+    kind: types.optional(InstalmentKind$inboundSchema),
+    metadata: types.optional(z.record(z.string(), types.string())),
+    owner_id: types.optional(types.string()),
+    owner_type: types.optional(BillingTermOwnerType$inboundSchema),
+    service_period_end: types.optional(types.date()),
+    service_period_start: types.optional(types.date()),
+    status: types.optional(Status$inboundSchema),
+    subscription_id: types.optional(types.string()),
+    tenant_id: types.optional(types.string()),
+    triggered_at: types.optional(types.date()),
+    updated_at: types.optional(types.date()),
+    updated_by: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "bill_on": "billOn",
+      "bill_trigger": "billTrigger",
+      "billing_term_id": "billingTermId",
+      "created_at": "createdAt",
+      "created_by": "createdBy",
+      "customer_id": "customerId",
+      "environment_id": "environmentId",
+      "instalment_status": "instalmentStatus",
+      "invoice_id": "invoiceId",
+      "invoice_label": "invoiceLabel",
+      "owner_id": "ownerId",
+      "owner_type": "ownerType",
+      "service_period_end": "servicePeriodEnd",
+      "service_period_start": "servicePeriodStart",
+      "subscription_id": "subscriptionId",
+      "tenant_id": "tenantId",
+      "triggered_at": "triggeredAt",
+      "updated_at": "updatedAt",
+      "updated_by": "updatedBy",
+    });
+  }),
+);
+
+export function billingtermInstalmentFromJSON(
+  jsonString: string,
+): SafeParseResult<BillingtermInstalment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BillingtermInstalment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BillingtermInstalment' from JSON`,
+  );
+}

package/src/sdk/models/billingterm-term.ts

@@ -0,0 +1,136 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import {
+  BillingTermKind,
+  BillingTermKind$inboundSchema,
+} from "./billing-term-kind.js";
+import {
+  BillingTermOwnerType,
+  BillingTermOwnerType$inboundSchema,
+} from "./billing-term-owner-type.js";
+import {
+  BillingTermSplit,
+  BillingTermSplit$inboundSchema,
+} from "./billing-term-split.js";
+import {
+  BillingTermValueType,
+  BillingTermValueType$inboundSchema,
+} from "./billing-term-value-type.js";
+import {
+  InstalmentBillTrigger,
+  InstalmentBillTrigger$inboundSchema,
+} from "./instalment-bill-trigger.js";
+import {
+  InvoiceCadence,
+  InvoiceCadence$inboundSchema,
+} from "./invoice-cadence.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+import { Status, Status$inboundSchema } from "./status.js";
+
+export type BillingtermTerm = {
+  billOn?: string | undefined;
+  billTrigger?: InstalmentBillTrigger | undefined;
+  createdAt?: Date | undefined;
+  createdBy?: string | undefined;
+  endDate?: Date | undefined;
+  environmentId?: string | undefined;
+  id?: string | undefined;
+  invoiceCadence?: InvoiceCadence | undefined;
+  /**
+   * InvoiceLabel names its instalments on the invoice, after the owner's label. It may use {n} and {of}, which number
+   *
+   * @remarks
+   * all of the owner's instalments together.
+   */
+  invoiceLabel?: string | undefined;
+  kind?: BillingTermKind | undefined;
+  metadata?: { [k: string]: string } | undefined;
+  ownerId?: string | undefined;
+  ownerType?: BillingTermOwnerType | undefined;
+  periodCount?: number | undefined;
+  split?: BillingTermSplit | undefined;
+  /**
+   * Recurring terms.
+   */
+  startDate?: Date | undefined;
+  status?: Status | undefined;
+  tenantId?: string | undefined;
+  updatedAt?: Date | undefined;
+  updatedBy?: string | undefined;
+  /**
+   * Value is the amount of a fixed term, per instalment on a recurring one; it is nil for a remainder term.
+   */
+  value?: string | undefined;
+  /**
+   * fixed or remainder; percentage is reserved and rejected as not supported yet
+   */
+  valueType?: BillingTermValueType | undefined;
+};
+
+/** @internal */
+export const BillingtermTerm$inboundSchema: z.ZodMiniType<
+  BillingtermTerm,
+  unknown
+> = z.pipe(
+  z.object({
+    bill_on: types.optional(types.string()),
+    bill_trigger: types.optional(InstalmentBillTrigger$inboundSchema),
+    created_at: types.optional(types.date()),
+    created_by: types.optional(types.string()),
+    end_date: types.optional(types.date()),
+    environment_id: types.optional(types.string()),
+    id: types.optional(types.string()),
+    invoice_cadence: types.optional(InvoiceCadence$inboundSchema),
+    invoice_label: types.optional(types.string()),
+    kind: types.optional(BillingTermKind$inboundSchema),
+    metadata: types.optional(z.record(z.string(), types.string())),
+    owner_id: types.optional(types.string()),
+    owner_type: types.optional(BillingTermOwnerType$inboundSchema),
+    period_count: types.optional(types.number()),
+    split: types.optional(BillingTermSplit$inboundSchema),
+    start_date: types.optional(types.date()),
+    status: types.optional(Status$inboundSchema),
+    tenant_id: types.optional(types.string()),
+    updated_at: types.optional(types.date()),
+    updated_by: types.optional(types.string()),
+    value: types.optional(types.string()),
+    value_type: types.optional(BillingTermValueType$inboundSchema),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "bill_on": "billOn",
+      "bill_trigger": "billTrigger",
+      "created_at": "createdAt",
+      "created_by": "createdBy",
+      "end_date": "endDate",
+      "environment_id": "environmentId",
+      "invoice_cadence": "invoiceCadence",
+      "invoice_label": "invoiceLabel",
+      "owner_id": "ownerId",
+      "owner_type": "ownerType",
+      "period_count": "periodCount",
+      "start_date": "startDate",
+      "tenant_id": "tenantId",
+      "updated_at": "updatedAt",
+      "updated_by": "updatedBy",
+      "value_type": "valueType",
+    });
+  }),
+);
+
+export function billingtermTermFromJSON(
+  jsonString: string,
+): SafeParseResult<BillingtermTerm, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BillingtermTerm$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BillingtermTerm' from JSON`,
+  );
+}

package/src/sdk/models/cancellation-fee-input.ts

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import {
+  CancellationFeeType,
+  CancellationFeeType$outboundSchema,
+} from "./cancellation-fee-type.js";
+
+export type CancellationFeeInput = {
+  /**
+   * fixed; percentage is reserved and rejected as not supported yet
+   */
+  type: CancellationFeeType;
+  value: string;
+};
+
+/** @internal */
+export type CancellationFeeInput$Outbound = {
+  type: string;
+  value: string;
+};
+
+/** @internal */
+export const CancellationFeeInput$outboundSchema: z.ZodMiniType<
+  CancellationFeeInput$Outbound,
+  CancellationFeeInput
+> = z.object({
+  type: CancellationFeeType$outboundSchema,
+  value: z.string(),
+});
+
+export function cancellationFeeInputToJSON(
+  cancellationFeeInput: CancellationFeeInput,
+): string {
+  return JSON.stringify(
+    CancellationFeeInput$outboundSchema.parse(cancellationFeeInput),
+  );
+}