@paygentic/sdk 0.9.11 → 0.9.13

package/src/models/paymentsession.ts

@@ -9,16 +9,13 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export const PaymentSessionObject = {
-  PaymentSession: "paymentSession",
+  PaymentSession: "payment_session",
 } as const;
 export type PaymentSessionObject = ClosedEnum<typeof PaymentSessionObject>;
 
-export const Mode = {
-  Payment: "payment",
-  Setup: "setup",
-} as const;
-export type Mode = ClosedEnum<typeof Mode>;
-
+/**
+ * Lifecycle status of the session.
+ */
 export const PaymentSessionStatus = {
   Pending: "pending",
   Processing: "processing",
@@ -27,26 +24,55 @@ export const PaymentSessionStatus = {
   Expired: "expired",
   Cancelled: "cancelled",
 } as const;
+/**
+ * Lifecycle status of the session.
+ */
 export type PaymentSessionStatus = ClosedEnum<typeof PaymentSessionStatus>;
 
 export type PaymentSession = {
   object: PaymentSessionObject;
   /**
-   * Payment session identifier (e.g. `ps_...`).
+   * Payment session ID (ps_*).
    */
   id: string;
-  mode: Mode;
+  /**
+   * Type of entity the session pays for (invoice, subscription, payment, topup).
+   */
+  entityType: string;
+  /**
+   * ID of the entity the session pays for.
+   */
+  entityId: string;
+  /**
+   * Display label for the entity — invoice number, payment-link reference, or subscription name. Null when no label is available.
+   */
+  entityLabel?: string | null | undefined;
+  /**
+   * Amount in decimal dollars.
+   */
+  amount: string;
+  /**
+   * ISO 4217 currency code.
+   */
+  currency: string;
+  /**
+   * Lifecycle status of the session.
+   */
   status: PaymentSessionStatus;
   /**
-   * Hosted page URL. Redirect the customer here, or load it inside an iframe — when iframed, the page reports outcomes via `postMessage` (`payment_success` / `payment_error`) to the parent window.
+   * Stripe Connect account ID (acct_*) when the session is routed to a connected account.
+   */
+  merchantPaymentAccountId?: string | null | undefined;
+  /**
+   * Provider payment intent reference — Stripe PaymentIntent ID (pi_*) or Airwallex intent ID (int_*). Null until the intent is created on first checkout load.
+   */
+  providerPaymentRef?: string | null | undefined;
+  /**
+   * Timestamp the session reached terminal completion. Null until the session completes.
    */
-  url: string;
-  successRedirectUrl?: string | null | undefined;
-  failureRedirectUrl?: string | null | undefined;
-  metadata?: { [k: string]: any } | undefined;
-  expiresAt: Date;
   completedAt?: Date | null | undefined;
   createdAt: Date;
+  updatedAt: Date;
 };
 
 /** @internal */
@@ -54,11 +80,6 @@ export const PaymentSessionObject$inboundSchema: z.ZodNativeEnum<
   typeof PaymentSessionObject
 > = z.nativeEnum(PaymentSessionObject);
 
-/** @internal */
-export const Mode$inboundSchema: z.ZodNativeEnum<typeof Mode> = z.nativeEnum(
-  Mode,
-);
-
 /** @internal */
 export const PaymentSessionStatus$inboundSchema: z.ZodNativeEnum<
   typeof PaymentSessionStatus
@@ -72,17 +93,19 @@ export const PaymentSession$inboundSchema: z.ZodType<
 > = z.object({
   object: PaymentSessionObject$inboundSchema,
   id: z.string(),
-  mode: Mode$inboundSchema,
+  entityType: z.string(),
+  entityId: z.string(),
+  entityLabel: z.nullable(z.string()).optional(),
+  amount: z.string(),
+  currency: z.string(),
   status: PaymentSessionStatus$inboundSchema,
-  url: z.string(),
-  successRedirectUrl: z.nullable(z.string()).optional(),
-  failureRedirectUrl: z.nullable(z.string()).optional(),
-  metadata: z.record(z.any()).optional(),
-  expiresAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  merchantPaymentAccountId: z.nullable(z.string()).optional(),
+  providerPaymentRef: z.nullable(z.string()).optional(),
   completedAt: z.nullable(
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ).optional(),
   createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
 });
 
 export function paymentSessionFromJSON(

package/src/models/plan.ts

@@ -12,7 +12,7 @@ import {
   PlanCreditAllocation,
   PlanCreditAllocation$inboundSchema,
 } from "./plancreditallocation.js";
-import { Price, Price$inboundSchema } from "./price.js";
+import { PlanPrice, PlanPrice$inboundSchema } from "./planprice.js";
 
 export const PlanObject = {
   Plan: "plan",
@@ -84,7 +84,7 @@ export type Plan = {
   merchantId: string;
   name: string;
   paymentTerm?: PlanPaymentTerm | undefined;
-  prices?: Array<Price> | undefined;
+  prices?: Array<PlanPrice> | undefined;
   /**
    * Unique identifier for a product
    */
@@ -186,7 +186,7 @@ export const Plan$inboundSchema: z.ZodType<Plan, z.ZodTypeDef, unknown> = z
     merchantId: z.string(),
     name: z.string(),
     paymentTerm: z.lazy(() => PlanPaymentTerm$inboundSchema).optional(),
-    prices: z.array(Price$inboundSchema).optional(),
+    prices: z.array(PlanPrice$inboundSchema).optional(),
     productId: z.string(),
     taxBehavior: TaxBehavior$inboundSchema.optional(),
     updatedAt: z.string().datetime({ offset: true }).transform(v =>

package/src/models/planlineinput.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+/**
+ * One line of a plan: the price it bills, and the key that names it.
+ */
+export type PlanLineInput = {
+  /**
+   * Unique identifier for a price
+   */
+  priceId: string;
+  /**
+   * The name you give one line of a plan, for example `platform_fee`. It starts with a lowercase letter or a digit, contains only lowercase letters, digits, hyphens and underscores, and is at most 64 characters. A key names one line for the life of the plan: every version that keeps the line carries the same key, and a key that you drop from one version and supply again on a later version says that the line resumed. Keys are compared exactly, so `Platform_Fee` is not accepted.
+   */
+  key?: string | undefined;
+};
+
+/** @internal */
+export type PlanLineInput$Outbound = {
+  priceId: string;
+  key?: string | undefined;
+};
+
+/** @internal */
+export const PlanLineInput$outboundSchema: z.ZodType<
+  PlanLineInput$Outbound,
+  z.ZodTypeDef,
+  PlanLineInput
+> = z.object({
+  priceId: z.string(),
+  key: z.string().optional(),
+});
+
+export function planLineInputToJSON(planLineInput: PlanLineInput): string {
+  return JSON.stringify(PlanLineInput$outboundSchema.parse(planLineInput));
+}

package/src/models/planlineref.ts

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  PlanLineInput,
+  PlanLineInput$Outbound,
+  PlanLineInput$outboundSchema,
+} from "./planlineinput.js";
+
+/**
+ * Either a price ID on its own, or a price ID with the key that names its line.
+ */
+export type PlanLineRef = PlanLineInput | string;
+
+/** @internal */
+export type PlanLineRef$Outbound = PlanLineInput$Outbound | string;
+
+/** @internal */
+export const PlanLineRef$outboundSchema: z.ZodType<
+  PlanLineRef$Outbound,
+  z.ZodTypeDef,
+  PlanLineRef
+> = z.union([PlanLineInput$outboundSchema, z.string()]);
+
+export function planLineRefToJSON(planLineRef: PlanLineRef): string {
+  return JSON.stringify(PlanLineRef$outboundSchema.parse(planLineRef));
+}

package/src/models/{schemasprice.ts → planprice.ts}

@@ -8,65 +8,66 @@ 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 SchemasPriceObject = {
+export const PlanPriceObject = {
   Price: "price",
 } as const;
-export type SchemasPriceObject = ClosedEnum<typeof SchemasPriceObject>;
+export type PlanPriceObject = ClosedEnum<typeof PlanPriceObject>;
 
-export const SchemasPricePaymentTerm = {
+export const PlanPriceModel = {
+  Standard: "standard",
+  Dynamic: "dynamic",
+  Volume: "volume",
+  Percentage: "percentage",
+} as const;
+export type PlanPriceModel = ClosedEnum<typeof PlanPriceModel>;
+
+export const PlanPricePaymentTerm = {
   InArrears: "in_arrears",
   InAdvance: "in_advance",
 } as const;
-export type SchemasPricePaymentTerm = ClosedEnum<
-  typeof SchemasPricePaymentTerm
->;
+export type PlanPricePaymentTerm = ClosedEnum<typeof PlanPricePaymentTerm>;
+
+/**
+ * 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 PlanPriceRateType = {
+  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 PlanPriceRateType = ClosedEnum<typeof PlanPriceRateType>;
 
-export type SchemasPrice = {
+export type PlanPrice = {
   /**
    * Unique identifier for a price
    */
   id: string;
-  object: SchemasPriceObject;
+  object: PlanPriceObject;
   /**
-   * Unique identifier for a billable metric
+   * Unique identifier for an organization
    */
+  merchantId: string;
   billableMetricId?: string | undefined;
   /**
-   * The unique identifier for the fee referred to by this price. Present when price is linked to a fee.
+   * The unique identifier for the fee referred to by this price
    */
   feeId?: string | undefined;
   /**
-   * 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.
+   * ISO 8601 duration for billing frequency (e.g., P1M for monthly)
    */
   billingCadence?: string | null | undefined;
   createdAt: Date;
+  currency?: string | undefined;
+  description?: string | undefined;
   invoiceDisplayName: string;
-  /**
-   * 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: SchemasPricePaymentTerm;
-  properties: PriceProperties;
+  model: PlanPriceModel;
+  paymentTerm: PlanPricePaymentTerm;
+  properties: { [k: string]: any };
+  unitAmount?: string | undefined;
   updatedAt: Date;
   /**
    * Features associated with this price
@@ -83,61 +84,82 @@ export type SchemasPrice = {
   /**
    * 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?: RateType | undefined;
+  rateType: PlanPriceRateType;
+  /**
+   * 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;
   /**
    * 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 for invoice line items. Total per period = quantity × unitPrice. Only supported for fee prices; metered prices derive quantity from usage. Defaults to 1.
+   * 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: number;
 };
 
 /** @internal */
-export const SchemasPriceObject$inboundSchema: z.ZodNativeEnum<
-  typeof SchemasPriceObject
-> = z.nativeEnum(SchemasPriceObject);
+export const PlanPriceObject$inboundSchema: z.ZodNativeEnum<
+  typeof PlanPriceObject
+> = z.nativeEnum(PlanPriceObject);
 
 /** @internal */
-export const SchemasPricePaymentTerm$inboundSchema: z.ZodNativeEnum<
-  typeof SchemasPricePaymentTerm
-> = z.nativeEnum(SchemasPricePaymentTerm);
+export const PlanPriceModel$inboundSchema: z.ZodNativeEnum<
+  typeof PlanPriceModel
+> = z.nativeEnum(PlanPriceModel);
 
 /** @internal */
-export const SchemasPrice$inboundSchema: z.ZodType<
-  SchemasPrice,
+export const PlanPricePaymentTerm$inboundSchema: z.ZodNativeEnum<
+  typeof PlanPricePaymentTerm
+> = z.nativeEnum(PlanPricePaymentTerm);
+
+/** @internal */
+export const PlanPriceRateType$inboundSchema: z.ZodNativeEnum<
+  typeof PlanPriceRateType
+> = z.nativeEnum(PlanPriceRateType);
+
+/** @internal */
+export const PlanPrice$inboundSchema: z.ZodType<
+  PlanPrice,
   z.ZodTypeDef,
   unknown
 > = z.object({
   id: z.string(),
-  object: SchemasPriceObject$inboundSchema.default("price"),
+  object: PlanPriceObject$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(),
-  invoiceDisplayGroup: z.nullable(z.string()).optional(),
-  model: PriceModel$inboundSchema.optional(),
-  paymentTerm: SchemasPricePaymentTerm$inboundSchema,
-  properties: PriceProperties$inboundSchema,
+  model: PlanPriceModel$inboundSchema,
+  paymentTerm: PlanPricePaymentTerm$inboundSchema,
+  properties: z.record(z.any()),
+  unitAmount: z.string().optional(),
   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: RateType$inboundSchema.optional(),
+  rateType: PlanPriceRateType$inboundSchema.default("amount"),
+  invoiceDisplayGroup: z.nullable(z.string()).optional(),
+  pricingUnitId: z.string().optional(),
   tax: PriceTax$inboundSchema,
-  quantity: z.number().int(),
+  quantity: z.number().int().default(1),
 });
 
-export function schemasPriceFromJSON(
+export function planPriceFromJSON(
   jsonString: string,
-): SafeParseResult<SchemasPrice, SDKValidationError> {
+): SafeParseResult<PlanPrice, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => SchemasPrice$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SchemasPrice' from JSON`,
+    (x) => PlanPrice$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanPrice' from JSON`,
   );
 }

package/src/models/planversionpriceslot.ts

@@ -50,7 +50,7 @@ export type PlanVersionPriceSlotRateType = ClosedEnum<
 >;
 
 /**
- * One price slot on a plan version. Every `Price` field is present, plus `priceDeleted` layered on top.
+ * One price slot on a plan version. Every `Price` field is present, plus `key` and `priceDeleted` layered on top.
  */
 export type PlanVersionPriceSlot = {
   /**
@@ -112,6 +112,10 @@ export type PlanVersionPriceSlot = {
    * 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: number;
+  /**
+   * The name of this line. Send it as the `key` of a subscription price-interval operation to address this line. A line created before keys could be supplied carries a generated key, which does not match the format that this API accepts for new keys.
+   */
+  key: string;
   /**
    * True when the underlying price this slot references has been soft-deleted.
    */
@@ -167,6 +171,7 @@ export const PlanVersionPriceSlot$inboundSchema: z.ZodType<
   pricingUnitId: z.string().optional(),
   tax: PriceTax$inboundSchema,
   quantity: z.number().int().default(1),
+  key: z.string(),
   priceDeleted: z.boolean(),
 });
 

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

@@ -21,7 +21,7 @@ export type ProfitabilityRow = {
    */
   customerName: string;
   /**
-   * Net revenue (paid + outstanding) in unit currency, with two decimals.
+   * Revenue excluding tax (paid + outstanding invoices issued in the period), in unit currency, with two decimals.
    */
   netRevenue: string;
   /**

package/src/models/revenuesummaryresponse.ts

@@ -47,11 +47,11 @@ export type RevenueSummaryResponse = {
    */
   object: "revenue_summary";
   /**
-   * Net collected revenue in dollars (paid invoices + completed payments), already net of non-voided refunds. Omitted when groupBy=currency is active.
+   * Revenue in dollars, excluding tax: invoices issued in the period plus completed payments, less non-voided refunds issued in the period. Invoices and refunds are counted excluding tax. Omitted when groupBy=currency is active.
    */
   netRevenue?: string | undefined;
   /**
-   * Gross total of non-voided refunds (credit notes) issued in the period, in dollars. Already subtracted from netRevenue and invoice totals. Omitted when groupBy=currency is active.
+   * Total of non-voided refunds (credit notes) issued in the period, in dollars, including tax. netRevenue subtracts these refunds excluding tax. Omitted when groupBy=currency is active.
    */
   totalRefunds?: string | undefined;
   /**

package/src/models/revenuetrendbucket.ts

@@ -17,7 +17,7 @@ export type RevenueTrendBucket = {
    */
   timestamp: Date;
   /**
-   * Total amount of all invoices issued in this bucket (all statuses, by issuedAt)
+   * Total amount of all invoices issued in this bucket (all statuses, by issuedAt), excluding tax
    */
   issuedInvoices: string;
   /**