@paygentic/sdk 0.8.0 → 0.8.2

package/src/models/meterevent.ts

@@ -47,6 +47,10 @@ export type MeterEvent = {
    * Optional external identifier for cross-referencing with external systems. Alphanumeric characters, hyphens, and underscores only.
    */
   externalId?: string | undefined;
+  /**
+   * The merchant's own customer identifier the event was reported with. Empty subject with an externalSubject means the event is not linked to a customer yet.
+   */
+  externalSubject?: string | undefined;
 };
 
 /** @internal */
@@ -69,6 +73,7 @@ export const MeterEvent$inboundSchema: z.ZodType<
   idempotencyKey: z.string(),
   data: z.record(z.any()),
   externalId: z.string().optional(),
+  externalSubject: z.string().optional(),
 });
 
 export function meterEventFromJSON(

package/src/models/operations/advancetestclock.ts

@@ -5,70 +5,84 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 
-export type RequestBody2 = {
+export type AdvanceTestClockRequestBody2 = {
   /**
    * ISO 8601 duration format indicating clock advancement distance. Sample values: 'P1M' moves forward one month, 'P7D' moves forward seven days, 'PT2H' moves forward two hours, 'P1Y2M3DT4H5M6S' moves forward one year, two months, three days, four hours, five minutes, and six seconds
    */
   advanceBy: string;
 };
 
-export type RequestBody1 = {
+export type AdvanceTestClockRequestBody1 = {
   /**
    * New absolute time for the test clock (must be forward in time)
    */
   currentTime: Date;
 };
 
-export type AdvanceTestClockRequestBody = RequestBody1 | RequestBody2;
+export type AdvanceTestClockRequestBody =
+  | AdvanceTestClockRequestBody1
+  | AdvanceTestClockRequestBody2;
 
 export type AdvanceTestClockRequest = {
   /**
    * Test clock ID
    */
   id: string;
-  requestBody: RequestBody1 | RequestBody2;
+  requestBody: AdvanceTestClockRequestBody1 | AdvanceTestClockRequestBody2;
 };
 
 /** @internal */
-export type RequestBody2$Outbound = {
+export type AdvanceTestClockRequestBody2$Outbound = {
   advanceBy: string;
 };
 
 /** @internal */
-export const RequestBody2$outboundSchema: z.ZodType<
-  RequestBody2$Outbound,
+export const AdvanceTestClockRequestBody2$outboundSchema: z.ZodType<
+  AdvanceTestClockRequestBody2$Outbound,
   z.ZodTypeDef,
-  RequestBody2
+  AdvanceTestClockRequestBody2
 > = z.object({
   advanceBy: z.string(),
 });
 
-export function requestBody2ToJSON(requestBody2: RequestBody2): string {
-  return JSON.stringify(RequestBody2$outboundSchema.parse(requestBody2));
+export function advanceTestClockRequestBody2ToJSON(
+  advanceTestClockRequestBody2: AdvanceTestClockRequestBody2,
+): string {
+  return JSON.stringify(
+    AdvanceTestClockRequestBody2$outboundSchema.parse(
+      advanceTestClockRequestBody2,
+    ),
+  );
 }
 
 /** @internal */
-export type RequestBody1$Outbound = {
+export type AdvanceTestClockRequestBody1$Outbound = {
   currentTime: string;
 };
 
 /** @internal */
-export const RequestBody1$outboundSchema: z.ZodType<
-  RequestBody1$Outbound,
+export const AdvanceTestClockRequestBody1$outboundSchema: z.ZodType<
+  AdvanceTestClockRequestBody1$Outbound,
   z.ZodTypeDef,
-  RequestBody1
+  AdvanceTestClockRequestBody1
 > = z.object({
   currentTime: z.date().transform(v => v.toISOString()),
 });
 
-export function requestBody1ToJSON(requestBody1: RequestBody1): string {
-  return JSON.stringify(RequestBody1$outboundSchema.parse(requestBody1));
+export function advanceTestClockRequestBody1ToJSON(
+  advanceTestClockRequestBody1: AdvanceTestClockRequestBody1,
+): string {
+  return JSON.stringify(
+    AdvanceTestClockRequestBody1$outboundSchema.parse(
+      advanceTestClockRequestBody1,
+    ),
+  );
 }
 
 /** @internal */
 export type AdvanceTestClockRequestBody$Outbound =
-  | RequestBody1$Outbound
-  | RequestBody2$Outbound;
+  | AdvanceTestClockRequestBody1$Outbound
+  | AdvanceTestClockRequestBody2$Outbound;
 
 /** @internal */
 export const AdvanceTestClockRequestBody$outboundSchema: z.ZodType<
@@ -76,8 +90,8 @@ export const AdvanceTestClockRequestBody$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AdvanceTestClockRequestBody
 > = z.union([
-  z.lazy(() => RequestBody1$outboundSchema),
-  z.lazy(() => RequestBody2$outboundSchema),
+  z.lazy(() => AdvanceTestClockRequestBody1$outboundSchema),
+  z.lazy(() => AdvanceTestClockRequestBody2$outboundSchema),
 ]);
 
 export function advanceTestClockRequestBodyToJSON(
@@ -93,7 +107,9 @@ export function advanceTestClockRequestBodyToJSON(
 /** @internal */
 export type AdvanceTestClockRequest$Outbound = {
   id: string;
-  RequestBody: RequestBody1$Outbound | RequestBody2$Outbound;
+  RequestBody:
+    | AdvanceTestClockRequestBody1$Outbound
+    | AdvanceTestClockRequestBody2$Outbound;
 };
 
 /** @internal */
@@ -104,8 +120,8 @@ export const AdvanceTestClockRequest$outboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   requestBody: z.union([
-    z.lazy(() => RequestBody1$outboundSchema),
-    z.lazy(() => RequestBody2$outboundSchema),
+    z.lazy(() => AdvanceTestClockRequestBody1$outboundSchema),
+    z.lazy(() => AdvanceTestClockRequestBody2$outboundSchema),
   ]),
 }).transform((v) => {
   return remap$(v, {

package/src/models/operations/createplan.ts

@@ -4,6 +4,7 @@
 
 import * as z from "zod/v3";
 import { ClosedEnum } from "../../types/enums.js";
+import * as models from "../index.js";
 
 /**
  * ISO 8601 duration for the billing period. Takes precedence over billingInterval when both are provided.
@@ -104,7 +105,7 @@ export type CreatePlanRequest = {
   /**
    * Unique identifier for a product
    */
-  productId?: string | undefined;
+  productId: string;
   /**
    * Whether tax is added on top of the price (exclusive) or included in the price (inclusive)
    */
@@ -125,6 +126,10 @@ export type CreatePlanRequest = {
    * ISO 8601 datetime reference point for billing period alignment. Must be in the past or present. When set, subscriptions created under this plan align their first billing period to the next recurrence of this 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 may target the same pricingUnitId.
+   */
+  creditAllocations?: Array<models.PlanCreditAllocation> | undefined;
 };
 
 /** @internal */
@@ -159,12 +164,13 @@ export type CreatePlanRequest$Outbound = {
   merchantId: string;
   name: string;
   prices?: Array<string> | undefined;
-  productId?: string | undefined;
+  productId: string;
   taxBehavior: string;
   renewalReminderEnabled: boolean;
   renewalReminderDays: number;
   billingVersion: number;
   billingAnchor?: string | null | undefined;
+  creditAllocations?: Array<models.PlanCreditAllocation$Outbound> | undefined;
 };
 
 /** @internal */
@@ -183,13 +189,15 @@ export const CreatePlanRequest$outboundSchema: z.ZodType<
   merchantId: z.string(),
   name: z.string(),
   prices: z.array(z.string()).optional(),
-  productId: z.string().optional(),
+  productId: z.string(),
   taxBehavior: CreatePlanTaxBehavior$outboundSchema.default("exclusive"),
   renewalReminderEnabled: z.boolean().default(true),
   renewalReminderDays: z.number().int().default(3),
   billingVersion: BillingVersion$outboundSchema.default(1),
   billingAnchor: z.nullable(z.date().transform(v => v.toISOString()))
     .optional(),
+  creditAllocations: z.array(models.PlanCreditAllocation$outboundSchema)
+    .optional(),
 });
 
 export function createPlanRequestToJSON(

package/src/models/operations/getbillablemetricmeter.ts

@@ -44,9 +44,17 @@ export type GetBillableMetricMeterRequest = {
    */
   filterGroupBy?: string | undefined;
   /**
-   * Comma-separated dimension keys
+   * Comma-separated dimension keys. Configure keys for the grouping on the metric. Only the "subject" grouping is supported by default.
    */
   groupBy?: string | undefined;
+  /**
+   * Cap groupedValues to the top-N by value (descending). With windowSize, restricts the windowed series to those top-N groups. Bounds the payload for high-cardinality groupings; groupCount reports the untruncated distinct-group count.
+   */
+  groupLimit?: number | undefined;
+  /**
+   * Offset into the value-descending group ordering; requires groupLimit to page through grouped results. With windowSize set, pages the windowed series through the ranked groups (offset 0 yields the top-N).
+   */
+  groupOffset?: number | undefined;
 };
 
 /** @internal */
@@ -63,6 +71,8 @@ export type GetBillableMetricMeterRequest$Outbound = {
   windowSize?: string | undefined;
   filterGroupBy?: string | undefined;
   groupBy?: string | undefined;
+  groupLimit?: number | undefined;
+  groupOffset?: number | undefined;
 };
 
 /** @internal */
@@ -78,6 +88,8 @@ export const GetBillableMetricMeterRequest$outboundSchema: z.ZodType<
   windowSize: GetBillableMetricMeterWindowSize$outboundSchema.optional(),
   filterGroupBy: z.string().optional(),
   groupBy: z.string().optional(),
+  groupLimit: z.number().int().optional(),
+  groupOffset: z.number().int().optional(),
 });
 
 export function getBillableMetricMeterRequestToJSON(

package/src/models/operations/index.ts

@@ -105,6 +105,7 @@ export * from "./listsources.js";
 export * from "./listsubscriptions.js";
 export * from "./listtestclocks.js";
 export * from "./purchaseentitlementgrant.js";
+export * from "./reconcilesubscriptionfeatures.js";
 export * from "./rejectsourceevent.js";
 export * from "./replacescheduleintervals.js";
 export * from "./terminatesubscription.js";

package/src/models/operations/ingestevent.ts

@@ -4,7 +4,7 @@
 
 import * as z from "zod/v3";
 
-export type IngestEventRequest = {
+export type IngestEventRequestBody2 = {
   /**
    * CloudEvents type. Must match an eventType configured on a BillableMetric.
    */
@@ -14,9 +14,52 @@ export type IngestEventRequest = {
    */
   source: string;
   /**
-   * Customer or entity ID this event relates to.
+   * Customer or entity ID this event relates to. Required unless externalSubject is provided.
+   */
+  subject?: string | undefined;
+  /**
+   * Your own customer identifier, matched against the customer's externalId. Fallback for when the Paygentic customer ID is not known — prefer subject when it is. Events reported before the customer exists are linked retroactively once a customer with this externalId is created. Resolution is eventually consistent: after an externalId is removed or reassigned, events may resolve to the previous customer for up to one hour. If subject is also provided, subject takes precedence and externalSubject is recorded but not used for resolution.
+   */
+  externalSubject: string;
+  /**
+   * Organization/merchant ID. Defaults to the authenticated user's organization. Platform users can specify a different organization.
+   */
+  namespace?: string | undefined;
+  /**
+   * Event timestamp. Defaults to server time if not provided.
+   */
+  timestamp?: Date | undefined;
+  /**
+   * User-provided deduplication key. If not provided, a unique key is generated.
+   */
+  idempotencyKey?: string | undefined;
+  /**
+   * Optional external identifier for cross-referencing with external systems. Alphanumeric characters, hyphens, and underscores only.
+   */
+  externalId?: string | undefined;
+  /**
+   * Event payload containing the metering data.
+   */
+  data: { [k: string]: any };
+};
+
+export type IngestEventRequestBody1 = {
+  /**
+   * CloudEvents type. Must match an eventType configured on a BillableMetric.
+   */
+  type: string;
+  /**
+   * Event source URI identifying the application.
+   */
+  source: string;
+  /**
+   * Customer or entity ID this event relates to. Required unless externalSubject is provided.
    */
   subject: string;
+  /**
+   * Your own customer identifier, matched against the customer's externalId. Fallback for when the Paygentic customer ID is not known — prefer subject when it is. Events reported before the customer exists are linked retroactively once a customer with this externalId is created. Resolution is eventually consistent: after an externalId is removed or reassigned, events may resolve to the previous customer for up to one hour. If subject is also provided, subject takes precedence and externalSubject is recorded but not used for resolution.
+   */
+  externalSubject?: string | undefined;
   /**
    * Organization/merchant ID. Defaults to the authenticated user's organization. Platform users can specify a different organization.
    */
@@ -39,11 +82,54 @@ export type IngestEventRequest = {
   data: { [k: string]: any };
 };
 
+export type IngestEventRequest =
+  | IngestEventRequestBody1
+  | IngestEventRequestBody2;
+
+/** @internal */
+export type IngestEventRequestBody2$Outbound = {
+  type: string;
+  source: string;
+  subject?: string | undefined;
+  externalSubject: string;
+  namespace?: string | undefined;
+  timestamp?: string | undefined;
+  idempotencyKey?: string | undefined;
+  externalId?: string | undefined;
+  data: { [k: string]: any };
+};
+
+/** @internal */
+export const IngestEventRequestBody2$outboundSchema: z.ZodType<
+  IngestEventRequestBody2$Outbound,
+  z.ZodTypeDef,
+  IngestEventRequestBody2
+> = z.object({
+  type: z.string(),
+  source: z.string(),
+  subject: z.string().optional(),
+  externalSubject: z.string(),
+  namespace: z.string().optional(),
+  timestamp: z.date().transform(v => v.toISOString()).optional(),
+  idempotencyKey: z.string().optional(),
+  externalId: z.string().optional(),
+  data: z.record(z.any()),
+});
+
+export function ingestEventRequestBody2ToJSON(
+  ingestEventRequestBody2: IngestEventRequestBody2,
+): string {
+  return JSON.stringify(
+    IngestEventRequestBody2$outboundSchema.parse(ingestEventRequestBody2),
+  );
+}
+
 /** @internal */
-export type IngestEventRequest$Outbound = {
+export type IngestEventRequestBody1$Outbound = {
   type: string;
   source: string;
   subject: string;
+  externalSubject?: string | undefined;
   namespace?: string | undefined;
   timestamp?: string | undefined;
   idempotencyKey?: string | undefined;
@@ -52,14 +138,15 @@ export type IngestEventRequest$Outbound = {
 };
 
 /** @internal */
-export const IngestEventRequest$outboundSchema: z.ZodType<
-  IngestEventRequest$Outbound,
+export const IngestEventRequestBody1$outboundSchema: z.ZodType<
+  IngestEventRequestBody1$Outbound,
   z.ZodTypeDef,
-  IngestEventRequest
+  IngestEventRequestBody1
 > = z.object({
   type: z.string(),
   source: z.string(),
   subject: z.string(),
+  externalSubject: z.string().optional(),
   namespace: z.string().optional(),
   timestamp: z.date().transform(v => v.toISOString()).optional(),
   idempotencyKey: z.string().optional(),
@@ -67,6 +154,29 @@ export const IngestEventRequest$outboundSchema: z.ZodType<
   data: z.record(z.any()),
 });
 
+export function ingestEventRequestBody1ToJSON(
+  ingestEventRequestBody1: IngestEventRequestBody1,
+): string {
+  return JSON.stringify(
+    IngestEventRequestBody1$outboundSchema.parse(ingestEventRequestBody1),
+  );
+}
+
+/** @internal */
+export type IngestEventRequest$Outbound =
+  | IngestEventRequestBody1$Outbound
+  | IngestEventRequestBody2$Outbound;
+
+/** @internal */
+export const IngestEventRequest$outboundSchema: z.ZodType<
+  IngestEventRequest$Outbound,
+  z.ZodTypeDef,
+  IngestEventRequest
+> = z.union([
+  z.lazy(() => IngestEventRequestBody1$outboundSchema),
+  z.lazy(() => IngestEventRequestBody2$outboundSchema),
+]);
+
 export function ingestEventRequestToJSON(
   ingestEventRequest: IngestEventRequest,
 ): string {

package/src/models/operations/listbillablemetricevents.ts

@@ -30,6 +30,10 @@ export type ListBillableMetricEventsRequest = {
    * Filter by external identifier. Alphanumeric characters, hyphens, and underscores only.
    */
   externalId?: string | undefined;
+  /**
+   * Filter by the merchant's own customer identifier the event was reported with.
+   */
+  externalSubject?: string | undefined;
 };
 
 /** @internal */
@@ -41,6 +45,7 @@ export type ListBillableMetricEventsRequest$Outbound = {
   limit: number;
   offset: number;
   externalId?: string | undefined;
+  externalSubject?: string | undefined;
 };
 
 /** @internal */
@@ -56,6 +61,7 @@ export const ListBillableMetricEventsRequest$outboundSchema: z.ZodType<
   limit: z.number().int().default(20),
   offset: z.number().int().default(0),
   externalId: z.string().optional(),
+  externalSubject: z.string().optional(),
 });
 
 export function listBillableMetricEventsRequestToJSON(

package/src/models/operations/reconcilesubscriptionfeatures.ts

@@ -0,0 +1,78 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type ReconcileSubscriptionFeaturesRequestBody = {
+  /**
+   * Preview the outcome without creating any entitlement, grant, or line item.
+   */
+  dryRun?: boolean | undefined;
+};
+
+export type ReconcileSubscriptionFeaturesRequest = {
+  /**
+   * The subscription ID
+   */
+  id: string;
+  requestBody?: ReconcileSubscriptionFeaturesRequestBody | undefined;
+};
+
+/** @internal */
+export type ReconcileSubscriptionFeaturesRequestBody$Outbound = {
+  dryRun: boolean;
+};
+
+/** @internal */
+export const ReconcileSubscriptionFeaturesRequestBody$outboundSchema: z.ZodType<
+  ReconcileSubscriptionFeaturesRequestBody$Outbound,
+  z.ZodTypeDef,
+  ReconcileSubscriptionFeaturesRequestBody
+> = z.object({
+  dryRun: z.boolean().default(false),
+});
+
+export function reconcileSubscriptionFeaturesRequestBodyToJSON(
+  reconcileSubscriptionFeaturesRequestBody:
+    ReconcileSubscriptionFeaturesRequestBody,
+): string {
+  return JSON.stringify(
+    ReconcileSubscriptionFeaturesRequestBody$outboundSchema.parse(
+      reconcileSubscriptionFeaturesRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type ReconcileSubscriptionFeaturesRequest$Outbound = {
+  id: string;
+  RequestBody?: ReconcileSubscriptionFeaturesRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const ReconcileSubscriptionFeaturesRequest$outboundSchema: z.ZodType<
+  ReconcileSubscriptionFeaturesRequest$Outbound,
+  z.ZodTypeDef,
+  ReconcileSubscriptionFeaturesRequest
+> = z.object({
+  id: z.string(),
+  requestBody: z.lazy(() =>
+    ReconcileSubscriptionFeaturesRequestBody$outboundSchema
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function reconcileSubscriptionFeaturesRequestToJSON(
+  reconcileSubscriptionFeaturesRequest: ReconcileSubscriptionFeaturesRequest,
+): string {
+  return JSON.stringify(
+    ReconcileSubscriptionFeaturesRequest$outboundSchema.parse(
+      reconcileSubscriptionFeaturesRequest,
+    ),
+  );
+}

package/src/models/operations/updateplan.ts

@@ -5,6 +5,7 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { ClosedEnum } from "../../types/enums.js";
+import * as models from "../index.js";
 
 /**
  * ISO 8601 duration for the billing period. Takes precedence over billingInterval when both are provided.
@@ -98,6 +99,10 @@ export type UpdatePlanRequestBody = {
    * ISO 8601 datetime reference point for billing period alignment. Must be in the past or present. Set to null to clear the anchor and revert to start-time-based anchoring.
    */
   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 may target the same pricingUnitId.
+   */
+  creditAllocations?: Array<models.PlanCreditAllocation> | undefined;
 };
 
 export type UpdatePlanRequest = {
@@ -137,6 +142,7 @@ export type UpdatePlanRequestBody$Outbound = {
   renewalReminderEnabled?: boolean | undefined;
   renewalReminderDays?: number | undefined;
   billingAnchor?: string | null | undefined;
+  creditAllocations?: Array<models.PlanCreditAllocation$Outbound> | undefined;
 };
 
 /** @internal */
@@ -158,6 +164,8 @@ export const UpdatePlanRequestBody$outboundSchema: z.ZodType<
   renewalReminderDays: z.number().int().optional(),
   billingAnchor: z.nullable(z.date().transform(v => v.toISOString()))
     .optional(),
+  creditAllocations: z.array(models.PlanCreditAllocation$outboundSchema)
+    .optional(),
 });
 
 export function updatePlanRequestBodyToJSON(

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`,
+  );
+}