@paygentic/sdk 0.7.20 → 0.8.1

package/src/models/operations/updateprice.ts

@@ -7,20 +7,6 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { ClosedEnum } from "../../types/enums.js";
 import * as models from "../index.js";
 
-/**
- * The pricing model to be used, which can be standard, dynamic, volume-based, or percentage-based.
- */
-export const UpdatePriceModel = {
-  Standard: "standard",
-  Dynamic: "dynamic",
-  Volume: "volume",
-  Percentage: "percentage",
-} as const;
-/**
- * The pricing model to be used, which can be standard, dynamic, volume-based, or percentage-based.
- */
-export type UpdatePriceModel = ClosedEnum<typeof UpdatePriceModel>;
-
 /**
  * Billing timing preference. For billable metrics: 'instant' (charges immediately) or 'in_arrears' (charges at period end). For fees: 'in_advance' (charges upfront) or 'in_arrears' (charges at period end).
  */
@@ -39,14 +25,18 @@ export type UpdatePriceRequestBody = {
    * Unique identifier for a billable metric
    */
   billableMetricId?: string | undefined;
+  /**
+   * Denominate this metered price in a pricing unit (credits). Set to a pricing unit ID to draw down a credit pool, null to revert to real currency, or omit to leave unchanged.
+   */
+  pricingUnitId?: string | null | undefined;
   /**
    * Updated invoice line item label. Sample values: 'LLM Token Usage', 'Storage Charges', 'API Call Fees'
    */
   invoiceDisplayName?: string | undefined;
   /**
-   * The pricing model to be used, which can be standard, dynamic, volume-based, or percentage-based.
+   * The pricing model to set. Only 'standard' is accepted. Legacy 'dynamic'/'volume'/'percentage' prices can still be edited (other fields) but cannot be switched to those models. Percentage/revenue-share is expressed via 'standard' with a unit-price multiplier.
    */
-  model?: UpdatePriceModel | undefined;
+  model?: models.PriceModelInput | undefined;
   properties?: models.PricePropertiesUnion | undefined;
   /**
    * Billing timing preference. For billable metrics: 'instant' (charges immediately) or 'in_arrears' (charges at period end). For fees: 'in_advance' (charges upfront) or 'in_arrears' (charges at period end).
@@ -78,11 +68,6 @@ export type UpdatePriceRequest = {
   requestBody: UpdatePriceRequestBody;
 };
 
-/** @internal */
-export const UpdatePriceModel$outboundSchema: z.ZodNativeEnum<
-  typeof UpdatePriceModel
-> = z.nativeEnum(UpdatePriceModel);
-
 /** @internal */
 export const UpdatePricePaymentTerm$outboundSchema: z.ZodNativeEnum<
   typeof UpdatePricePaymentTerm
@@ -91,6 +76,7 @@ export const UpdatePricePaymentTerm$outboundSchema: z.ZodNativeEnum<
 /** @internal */
 export type UpdatePriceRequestBody$Outbound = {
   billableMetricId?: string | undefined;
+  pricingUnitId?: string | null | undefined;
   invoiceDisplayName?: string | undefined;
   model?: string | undefined;
   properties?: models.PricePropertiesUnion$Outbound | undefined;
@@ -108,8 +94,9 @@ export const UpdatePriceRequestBody$outboundSchema: z.ZodType<
   UpdatePriceRequestBody
 > = z.object({
   billableMetricId: z.string().optional(),
+  pricingUnitId: z.nullable(z.string()).optional(),
   invoiceDisplayName: z.string().optional(),
-  model: UpdatePriceModel$outboundSchema.optional(),
+  model: models.PriceModelInput$outboundSchema.optional(),
   properties: models.PricePropertiesUnion$outboundSchema.optional(),
   paymentTerm: UpdatePricePaymentTerm$outboundSchema.optional(),
   billingCadence: z.nullable(z.string()).optional(),

package/src/models/plan.ts

@@ -8,6 +8,10 @@ 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";
+import {
+  PlanCreditAllocation,
+  PlanCreditAllocation$inboundSchema,
+} from "./plancreditallocation.js";
 import { Price, Price$inboundSchema } from "./price.js";
 
 export const PlanObject = {
@@ -110,6 +114,10 @@ export type Plan = {
    * ISO 8601 datetime reference point for billing period alignment. Must be in the past or present at the time of creation or update. When set, all subscriptions created under this plan align their first billing period to the next recurrence of this anchor. Null means each subscription uses its own start time (hour-rounded) as the anchor.
    */
   billingAnchor?: Date | null | undefined;
+  /**
+   * Credit-pool funding declarations for this plan. Each entry funds a distinct pricing unit's credit pool when a subscription to this plan activates: the allocated amount is minted as a credit grant on the customer's pool for that pricing unit, once at activation, or on a recurring basis only when that allocation explicitly sets recurrencePeriod. A plan may declare zero or more allocations; no two allocations on the same plan target the same pricingUnitId.
+   */
+  creditAllocations?: Array<PlanCreditAllocation> | undefined;
 };
 
 /** @internal */
@@ -182,6 +190,7 @@ export const Plan$inboundSchema: z.ZodType<Plan, z.ZodTypeDef, unknown> = z
     billingAnchor: z.nullable(
       z.string().datetime({ offset: true }).transform(v => new Date(v)),
     ).optional(),
+    creditAllocations: z.array(PlanCreditAllocation$inboundSchema).optional(),
   });
 
 export function planFromJSON(

package/src/models/plancreditallocation.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type PlanCreditAllocation = {
+  /**
+   * Unique identifier for a pricing unit
+   */
+  pricingUnitId: string;
+  /**
+   * Number of credits minted into the customer's pool for this pricing unit each time the allocation is provisioned. Must be a positive number.
+   */
+  amount: number;
+  /**
+   * ISO 8601 duration (e.g. 'P1M') controlling how often the allocation's credits are re-minted on the customer's pool. Recurrence is opt-in: when omitted, the allocation is minted once at subscription activation and never refills — even on a recurring plan. Set this field explicitly for credits that should replenish each period.
+   */
+  recurrencePeriod?: string | undefined;
+};
+
+/** @internal */
+export const PlanCreditAllocation$inboundSchema: z.ZodType<
+  PlanCreditAllocation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  pricingUnitId: z.string(),
+  amount: z.number(),
+  recurrencePeriod: z.string().optional(),
+});
+/** @internal */
+export type PlanCreditAllocation$Outbound = {
+  pricingUnitId: string;
+  amount: number;
+  recurrencePeriod?: string | undefined;
+};
+
+/** @internal */
+export const PlanCreditAllocation$outboundSchema: z.ZodType<
+  PlanCreditAllocation$Outbound,
+  z.ZodTypeDef,
+  PlanCreditAllocation
+> = z.object({
+  pricingUnitId: z.string(),
+  amount: z.number(),
+  recurrencePeriod: z.string().optional(),
+});
+
+export function planCreditAllocationToJSON(
+  planCreditAllocation: PlanCreditAllocation,
+): string {
+  return JSON.stringify(
+    PlanCreditAllocation$outboundSchema.parse(planCreditAllocation),
+  );
+}
+export function planCreditAllocationFromJSON(
+  jsonString: string,
+): SafeParseResult<PlanCreditAllocation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlanCreditAllocation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlanCreditAllocation' from JSON`,
+  );
+}

package/src/models/price.ts

@@ -14,13 +14,13 @@ export const PriceObject = {
 } as const;
 export type PriceObject = ClosedEnum<typeof PriceObject>;
 
-export const PriceModel = {
+export const PriceModel1 = {
   Standard: "standard",
   Dynamic: "dynamic",
   Volume: "volume",
   Percentage: "percentage",
 } as const;
-export type PriceModel = ClosedEnum<typeof PriceModel>;
+export type PriceModel1 = ClosedEnum<typeof PriceModel1>;
 
 export const PricePaymentTerm = {
   Instant: "instant",
@@ -52,7 +52,7 @@ export type Price = {
   currency?: string | undefined;
   description?: string | undefined;
   invoiceDisplayName: string;
-  model: PriceModel;
+  model: PriceModel1;
   paymentTerm: PricePaymentTerm;
   properties: { [k: string]: any };
   unitAmount?: string | undefined;
@@ -76,8 +76,8 @@ export const PriceObject$inboundSchema: z.ZodNativeEnum<typeof PriceObject> = z
   .nativeEnum(PriceObject);
 
 /** @internal */
-export const PriceModel$inboundSchema: z.ZodNativeEnum<typeof PriceModel> = z
-  .nativeEnum(PriceModel);
+export const PriceModel1$inboundSchema: z.ZodNativeEnum<typeof PriceModel1> = z
+  .nativeEnum(PriceModel1);
 
 /** @internal */
 export const PricePaymentTerm$inboundSchema: z.ZodNativeEnum<
@@ -99,7 +99,7 @@ export const Price$inboundSchema: z.ZodType<Price, z.ZodTypeDef, unknown> = z
     currency: z.string().optional(),
     description: z.string().optional(),
     invoiceDisplayName: z.string(),
-    model: PriceModel$inboundSchema,
+    model: PriceModel1$inboundSchema,
     paymentTerm: PricePaymentTerm$inboundSchema,
     properties: z.record(z.any()),
     unitAmount: z.string().optional(),

package/src/models/pricemodel.ts

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+
+/**
+ * Pricing model of a price as returned by the API. Includes legacy models ('dynamic', 'volume', 'percentage') retained for existing prices; only 'standard' can be created (see PriceModelInput).
+ */
+export const PriceModel = {
+  Standard: "standard",
+  Dynamic: "dynamic",
+  Volume: "volume",
+  Percentage: "percentage",
+} as const;
+/**
+ * Pricing model of a price as returned by the API. Includes legacy models ('dynamic', 'volume', 'percentage') retained for existing prices; only 'standard' can be created (see PriceModelInput).
+ */
+export type PriceModel = OpenEnum<typeof PriceModel>;
+
+/** @internal */
+export const PriceModel$inboundSchema: z.ZodType<
+  PriceModel,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PriceModel);

package/src/models/pricemodelinput.ts

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Pricing model accepted when creating or updating a price. Only 'standard' is creatable. Percentage-style and revenue-share pricing are expressed with 'standard' plus a unit-price multiplier (e.g. 10% ⇒ unitPrice '0.1'). The legacy 'dynamic', 'volume', and 'percentage' models remain billable and readable on existing prices but can no longer be created.
+ */
+export const PriceModelInput = {
+  Standard: "standard",
+} as const;
+/**
+ * Pricing model accepted when creating or updating a price. Only 'standard' is creatable. Percentage-style and revenue-share pricing are expressed with 'standard' plus a unit-price multiplier (e.g. 10% ⇒ unitPrice '0.1'). The legacy 'dynamic', 'volume', and 'percentage' models remain billable and readable on existing prices but can no longer be created.
+ */
+export type PriceModelInput = ClosedEnum<typeof PriceModelInput>;
+
+/** @internal */
+export const PriceModelInput$outboundSchema: z.ZodNativeEnum<
+  typeof PriceModelInput
+> = z.nativeEnum(PriceModelInput);

package/src/models/reconciledfeatureadded.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ReconciledFeatureAdded = {
+  featureId: string;
+  featureKey: string;
+  /**
+   * False when this feature's price never produces a recurring line item (an instant price, a credit-denominated price, or an already-elapsed one-time charge) — the feature is entitled but not billed by this reconciliation.
+   */
+  billed: boolean;
+};
+
+/** @internal */
+export const ReconciledFeatureAdded$inboundSchema: z.ZodType<
+  ReconciledFeatureAdded,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  featureId: z.string(),
+  featureKey: z.string(),
+  billed: z.boolean(),
+});
+
+export function reconciledFeatureAddedFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconciledFeatureAdded, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconciledFeatureAdded$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconciledFeatureAdded' from JSON`,
+  );
+}

package/src/models/reconciledfeaturefailed.ts

@@ -0,0 +1,55 @@
+/*
+ * 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";
+
+/**
+ * Coded failure reason. `grant_mint_failed` means the entitlement was created but its initial metered grant could not be minted; re-running this reconciliation retries the mint.
+ */
+export const Reason = {
+  EntitlementFailed: "entitlement_failed",
+  GrantMintFailed: "grant_mint_failed",
+} as const;
+/**
+ * Coded failure reason. `grant_mint_failed` means the entitlement was created but its initial metered grant could not be minted; re-running this reconciliation retries the mint.
+ */
+export type Reason = ClosedEnum<typeof Reason>;
+
+export type ReconciledFeatureFailed = {
+  featureId: string;
+  featureKey: string;
+  /**
+   * Coded failure reason. `grant_mint_failed` means the entitlement was created but its initial metered grant could not be minted; re-running this reconciliation retries the mint.
+   */
+  reason: Reason;
+};
+
+/** @internal */
+export const Reason$inboundSchema: z.ZodNativeEnum<typeof Reason> = z
+  .nativeEnum(Reason);
+
+/** @internal */
+export const ReconciledFeatureFailed$inboundSchema: z.ZodType<
+  ReconciledFeatureFailed,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  featureId: z.string(),
+  featureKey: z.string(),
+  reason: Reason$inboundSchema,
+});
+
+export function reconciledFeatureFailedFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconciledFeatureFailed, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconciledFeatureFailed$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconciledFeatureFailed' from JSON`,
+  );
+}

package/src/models/reconciledfeatureremoved.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ReconciledFeatureRemoved = {
+  featureId: string;
+  featureKey: string;
+};
+
+/** @internal */
+export const ReconciledFeatureRemoved$inboundSchema: z.ZodType<
+  ReconciledFeatureRemoved,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  featureId: z.string(),
+  featureKey: z.string(),
+});
+
+export function reconciledFeatureRemovedFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconciledFeatureRemoved, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconciledFeatureRemoved$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconciledFeatureRemoved' from JSON`,
+  );
+}

package/src/models/reconciledfeatureskipped.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type ReconciledFeatureSkipped = {
+  featureId: string;
+  featureKey: string;
+};
+
+/** @internal */
+export const ReconciledFeatureSkipped$inboundSchema: z.ZodType<
+  ReconciledFeatureSkipped,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  featureId: z.string(),
+  featureKey: z.string(),
+});
+
+export function reconciledFeatureSkippedFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconciledFeatureSkipped, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconciledFeatureSkipped$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconciledFeatureSkipped' from JSON`,
+  );
+}

package/src/models/schemasprice.ts

@@ -8,6 +8,7 @@ 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 {
   PricePropertiesUnion,
   PricePropertiesUnion$inboundSchema,
@@ -18,14 +19,6 @@ export const SchemasPriceObject = {
 } as const;
 export type SchemasPriceObject = ClosedEnum<typeof SchemasPriceObject>;
 
-export const SchemasPriceModel = {
-  Standard: "standard",
-  Dynamic: "dynamic",
-  Volume: "volume",
-  Percentage: "percentage",
-} as const;
-export type SchemasPriceModel = ClosedEnum<typeof SchemasPriceModel>;
-
 export const SchemasPricePaymentTerm = {
   Instant: "instant",
   InArrears: "in_arrears",
@@ -49,6 +42,10 @@ export type SchemasPrice = {
    * The unique identifier for the fee referred to by this price. Present when price is linked to a fee.
    */
   feeId?: string | undefined;
+  /**
+   * Unique identifier for a pricing unit
+   */
+  pricingUnitId?: string | undefined;
   /**
    * Unique identifier for an organization
    */
@@ -59,7 +56,10 @@ export type SchemasPrice = {
   billingCadence?: string | null | undefined;
   createdAt: Date;
   invoiceDisplayName: string;
-  model?: SchemasPriceModel | undefined;
+  /**
+   * Pricing model of a price as returned by the API. Includes legacy models ('dynamic', 'volume', 'percentage') retained for existing prices; only 'standard' can be created (see PriceModelInput).
+   */
+  model?: PriceModel | undefined;
   paymentTerm: SchemasPricePaymentTerm;
   properties: PricePropertiesUnion;
   updatedAt: Date;
@@ -82,11 +82,6 @@ export const SchemasPriceObject$inboundSchema: z.ZodNativeEnum<
   typeof SchemasPriceObject
 > = z.nativeEnum(SchemasPriceObject);
 
-/** @internal */
-export const SchemasPriceModel$inboundSchema: z.ZodNativeEnum<
-  typeof SchemasPriceModel
-> = z.nativeEnum(SchemasPriceModel);
-
 /** @internal */
 export const SchemasPricePaymentTerm$inboundSchema: z.ZodNativeEnum<
   typeof SchemasPricePaymentTerm
@@ -102,11 +97,12 @@ export const SchemasPrice$inboundSchema: z.ZodType<
   object: SchemasPriceObject$inboundSchema.default("price"),
   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)),
   invoiceDisplayName: z.string(),
-  model: SchemasPriceModel$inboundSchema.optional(),
+  model: PriceModel$inboundSchema.optional(),
   paymentTerm: SchemasPricePaymentTerm$inboundSchema,
   properties: PricePropertiesUnion$inboundSchema,
   updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),

package/src/models/subscriptionreconciliation.ts

@@ -0,0 +1,144 @@
+/*
+ * 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";
+import {
+  ReconciledFeatureAdded,
+  ReconciledFeatureAdded$inboundSchema,
+} from "./reconciledfeatureadded.js";
+import {
+  ReconciledFeatureFailed,
+  ReconciledFeatureFailed$inboundSchema,
+} from "./reconciledfeaturefailed.js";
+import {
+  ReconciledFeatureRemoved,
+  ReconciledFeatureRemoved$inboundSchema,
+} from "./reconciledfeatureremoved.js";
+import {
+  ReconciledFeatureSkipped,
+  ReconciledFeatureSkipped$inboundSchema,
+} from "./reconciledfeatureskipped.js";
+
+export const SubscriptionReconciliationObject = {
+  SubscriptionReconciliation: "subscriptionReconciliation",
+} as const;
+export type SubscriptionReconciliationObject = ClosedEnum<
+  typeof SubscriptionReconciliationObject
+>;
+
+export type Features = {
+  added: Array<ReconciledFeatureAdded>;
+  /**
+   * Features the subscription already had an active entitlement for — left unchanged.
+   */
+  skipped: Array<ReconciledFeatureSkipped>;
+  /**
+   * Features no longer on the plan: their entitlement was canceled and grants voided so the subscription matches the plan's current features.
+   */
+  removed: Array<ReconciledFeatureRemoved>;
+  /**
+   * Features that could not be fully provisioned. Never billed by this call.
+   */
+  failed: Array<ReconciledFeatureFailed>;
+};
+
+export type SubscriptionReconciliationLineItems = {
+  /**
+   * Number of features newly billed on the subscription by this reconciliation. A dry-run preview returns the same count as the applied run.
+   */
+  created: number;
+  /**
+   * Number of features whose billing was removed from the subscription's upcoming (not-yet-invoiced) invoice because their price is no longer on the plan.
+   */
+  removed: number;
+  /**
+   * True when entitlements were provisioned successfully but the line-item synchronization step failed. Safe to retry.
+   */
+  syncFailed?: boolean | undefined;
+};
+
+export type SubscriptionReconciliation = {
+  object: SubscriptionReconciliationObject;
+  /**
+   * True when this reconciliation was a preview — no entitlement, grant, or line item was created.
+   */
+  dryRun: boolean;
+  features: Features;
+  lineItems: SubscriptionReconciliationLineItems;
+};
+
+/** @internal */
+export const SubscriptionReconciliationObject$inboundSchema: z.ZodNativeEnum<
+  typeof SubscriptionReconciliationObject
+> = z.nativeEnum(SubscriptionReconciliationObject);
+
+/** @internal */
+export const Features$inboundSchema: z.ZodType<
+  Features,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  added: z.array(ReconciledFeatureAdded$inboundSchema),
+  skipped: z.array(ReconciledFeatureSkipped$inboundSchema),
+  removed: z.array(ReconciledFeatureRemoved$inboundSchema),
+  failed: z.array(ReconciledFeatureFailed$inboundSchema),
+});
+
+export function featuresFromJSON(
+  jsonString: string,
+): SafeParseResult<Features, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Features$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Features' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriptionReconciliationLineItems$inboundSchema: z.ZodType<
+  SubscriptionReconciliationLineItems,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  created: z.number().int(),
+  removed: z.number().int(),
+  syncFailed: z.boolean().optional(),
+});
+
+export function subscriptionReconciliationLineItemsFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionReconciliationLineItems, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SubscriptionReconciliationLineItems$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionReconciliationLineItems' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriptionReconciliation$inboundSchema: z.ZodType<
+  SubscriptionReconciliation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: SubscriptionReconciliationObject$inboundSchema,
+  dryRun: z.boolean(),
+  features: z.lazy(() => Features$inboundSchema),
+  lineItems: z.lazy(() => SubscriptionReconciliationLineItems$inboundSchema),
+});
+
+export function subscriptionReconciliationFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionReconciliation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionReconciliation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionReconciliation' from JSON`,
+  );
+}

package/src/sdk/subscriptions.ts

@@ -6,6 +6,7 @@ import { subscriptionsCreate } from "../funcs/subscriptionsCreate.js";
 import { subscriptionsGeneratePortalLink } from "../funcs/subscriptionsGeneratePortalLink.js";
 import { subscriptionsGet } from "../funcs/subscriptionsGet.js";
 import { subscriptionsList } from "../funcs/subscriptionsList.js";
+import { subscriptionsReconcileSubscriptionFeatures } from "../funcs/subscriptionsReconcileSubscriptionFeatures.js";
 import { subscriptionsTerminate } from "../funcs/subscriptionsTerminate.js";
 import { subscriptionsUpdateSubscription } from "../funcs/subscriptionsUpdateSubscription.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
@@ -106,4 +107,21 @@ export class Subscriptions extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * Reconcile Features
+   *
+   * @remarks
+   * Creates a reconciliation that converges a subscription's feature entitlements to its current plan. Provisions a missing entitlement (and, for metered features, its initial grant) for every plan feature the subscription does not already have; cancels the entitlement and voids the grants of any feature no longer on the plan; then synchronizes the corresponding prices' billing. An already-present feature is left unchanged. Restricted to active subscriptions billed on their plan's line-item schedule.
+   */
+  async reconcileSubscriptionFeatures(
+    request: operations.ReconcileSubscriptionFeaturesRequest,
+    options?: RequestOptions,
+  ): Promise<models.SubscriptionReconciliation> {
+    return unwrapAsync(subscriptionsReconcileSubscriptionFeatures(
+      this,
+      request,
+      options,
+    ));
+  }
 }