autumn-js 1.2.32 → 1.2.33

package/dist/better-auth/utils/handleBetterAuthRoute.js

@@ -1531,6 +1531,28 @@ var AttachOnEnd = {
   Bill: "bill",
   Revert: "revert"
 };
+var AttachPurchaseLimitInterval = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var AttachLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var AttachUsageLimitInterval = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var AttachThresholdType = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var AttachProrationBehavior = {
   ProrateImmediately: "prorate_immediately",
   None: "none"
@@ -1809,6 +1831,121 @@ var AttachFreeTrialParams$outboundSchema = z10.pipe(
     });
   })
 );
+var AttachPurchaseLimitInterval$outboundSchema = z10.enum(AttachPurchaseLimitInterval);
+var AttachPurchaseLimit$outboundSchema = z10.pipe(
+  z10.object({
+    interval: AttachPurchaseLimitInterval$outboundSchema,
+    intervalCount: z10._default(z10.number(), 1),
+    limit: z10.number()
+  }),
+  z10.transform((v) => {
+    return remap(v, {
+      intervalCount: "interval_count"
+    });
+  })
+);
+var AttachAutoTopup$outboundSchema = z10.pipe(
+  z10.object({
+    featureId: z10.string(),
+    enabled: z10._default(z10.boolean(), false),
+    threshold: z10.number(),
+    quantity: z10.number(),
+    purchaseLimit: z10.optional(z10.lazy(() => AttachPurchaseLimit$outboundSchema)),
+    invoiceMode: z10.optional(z10.boolean())
+  }),
+  z10.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      purchaseLimit: "purchase_limit",
+      invoiceMode: "invoice_mode"
+    });
+  })
+);
+var AttachLimitType$outboundSchema = z10.enum(AttachLimitType);
+var AttachSpendLimit$outboundSchema = z10.pipe(
+  z10.object({
+    featureId: z10.optional(z10.string()),
+    enabled: z10._default(z10.boolean(), false),
+    limitType: z10.optional(AttachLimitType$outboundSchema),
+    overageLimit: z10.optional(z10.number())
+  }),
+  z10.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      limitType: "limit_type",
+      overageLimit: "overage_limit"
+    });
+  })
+);
+var AttachUsageLimitInterval$outboundSchema = z10.enum(AttachUsageLimitInterval);
+var AttachUsageLimit$outboundSchema = z10.pipe(
+  z10.object({
+    featureId: z10.string(),
+    enabled: z10._default(z10.boolean(), true),
+    limit: z10.number(),
+    interval: AttachUsageLimitInterval$outboundSchema
+  }),
+  z10.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var AttachThresholdType$outboundSchema = z10.enum(AttachThresholdType);
+var AttachUsageAlert$outboundSchema = z10.pipe(
+  z10.object({
+    featureId: z10.optional(z10.string()),
+    enabled: z10._default(z10.boolean(), true),
+    threshold: z10.number(),
+    thresholdType: AttachThresholdType$outboundSchema,
+    name: z10.optional(z10.string())
+  }),
+  z10.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      thresholdType: "threshold_type"
+    });
+  })
+);
+var AttachOverageAllowed$outboundSchema = z10.pipe(
+  z10.object({
+    featureId: z10.string(),
+    enabled: z10._default(z10.boolean(), false)
+  }),
+  z10.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var AttachBillingControls$outboundSchema = z10.pipe(
+  z10.object({
+    autoTopups: z10.optional(
+      z10.array(z10.lazy(() => AttachAutoTopup$outboundSchema))
+    ),
+    spendLimits: z10.optional(
+      z10.array(z10.lazy(() => AttachSpendLimit$outboundSchema))
+    ),
+    usageLimits: z10.optional(
+      z10.array(z10.lazy(() => AttachUsageLimit$outboundSchema))
+    ),
+    usageAlerts: z10.optional(
+      z10.array(z10.lazy(() => AttachUsageAlert$outboundSchema))
+    ),
+    overageAllowed: z10.optional(
+      z10.array(z10.lazy(() => AttachOverageAllowed$outboundSchema))
+    )
+  }),
+  z10.transform((v) => {
+    return remap(v, {
+      autoTopups: "auto_topups",
+      spendLimits: "spend_limits",
+      usageLimits: "usage_limits",
+      usageAlerts: "usage_alerts",
+      overageAllowed: "overage_allowed"
+    });
+  })
+);
 var AttachCustomize$outboundSchema = z10.pipe(
   z10.object({
     price: z10.optional(z10.nullable(z10.lazy(() => AttachBasePrice$outboundSchema))),
@@ -1821,13 +1958,17 @@ var AttachCustomize$outboundSchema = z10.pipe(
     ),
     freeTrial: z10.optional(
       z10.nullable(z10.lazy(() => AttachFreeTrialParams$outboundSchema))
+    ),
+    billingControls: z10.optional(
+      z10.lazy(() => AttachBillingControls$outboundSchema)
     )
   }),
   z10.transform((v) => {
     return remap(v, {
       addItems: "add_items",
       removeItems: "remove_items",
-      freeTrial: "free_trial"
+      freeTrial: "free_trial",
+      billingControls: "billing_controls"
     });
   })
 );
@@ -2367,6 +2508,28 @@ var BillingUpdateOnEnd = {
   Bill: "bill",
   Revert: "revert"
 };
+var BillingUpdatePurchaseLimitInterval = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var BillingUpdateLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var BillingUpdateUsageLimitInterval = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var BillingUpdateThresholdType = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var BillingUpdateProrationBehavior = {
   ProrateImmediately: "prorate_immediately",
   None: "none"
@@ -2662,6 +2825,123 @@ var BillingUpdateFreeTrialParams$outboundSchema = z13.pipe(
     });
   })
 );
+var BillingUpdatePurchaseLimitInterval$outboundSchema = z13.enum(BillingUpdatePurchaseLimitInterval);
+var BillingUpdatePurchaseLimit$outboundSchema = z13.pipe(
+  z13.object({
+    interval: BillingUpdatePurchaseLimitInterval$outboundSchema,
+    intervalCount: z13._default(z13.number(), 1),
+    limit: z13.number()
+  }),
+  z13.transform((v) => {
+    return remap(v, {
+      intervalCount: "interval_count"
+    });
+  })
+);
+var BillingUpdateAutoTopup$outboundSchema = z13.pipe(
+  z13.object({
+    featureId: z13.string(),
+    enabled: z13._default(z13.boolean(), false),
+    threshold: z13.number(),
+    quantity: z13.number(),
+    purchaseLimit: z13.optional(
+      z13.lazy(() => BillingUpdatePurchaseLimit$outboundSchema)
+    ),
+    invoiceMode: z13.optional(z13.boolean())
+  }),
+  z13.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      purchaseLimit: "purchase_limit",
+      invoiceMode: "invoice_mode"
+    });
+  })
+);
+var BillingUpdateLimitType$outboundSchema = z13.enum(BillingUpdateLimitType);
+var BillingUpdateSpendLimit$outboundSchema = z13.pipe(
+  z13.object({
+    featureId: z13.optional(z13.string()),
+    enabled: z13._default(z13.boolean(), false),
+    limitType: z13.optional(BillingUpdateLimitType$outboundSchema),
+    overageLimit: z13.optional(z13.number())
+  }),
+  z13.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      limitType: "limit_type",
+      overageLimit: "overage_limit"
+    });
+  })
+);
+var BillingUpdateUsageLimitInterval$outboundSchema = z13.enum(BillingUpdateUsageLimitInterval);
+var BillingUpdateUsageLimit$outboundSchema = z13.pipe(
+  z13.object({
+    featureId: z13.string(),
+    enabled: z13._default(z13.boolean(), true),
+    limit: z13.number(),
+    interval: BillingUpdateUsageLimitInterval$outboundSchema
+  }),
+  z13.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var BillingUpdateThresholdType$outboundSchema = z13.enum(BillingUpdateThresholdType);
+var BillingUpdateUsageAlert$outboundSchema = z13.pipe(
+  z13.object({
+    featureId: z13.optional(z13.string()),
+    enabled: z13._default(z13.boolean(), true),
+    threshold: z13.number(),
+    thresholdType: BillingUpdateThresholdType$outboundSchema,
+    name: z13.optional(z13.string())
+  }),
+  z13.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      thresholdType: "threshold_type"
+    });
+  })
+);
+var BillingUpdateOverageAllowed$outboundSchema = z13.pipe(
+  z13.object({
+    featureId: z13.string(),
+    enabled: z13._default(z13.boolean(), false)
+  }),
+  z13.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var BillingUpdateBillingControls$outboundSchema = z13.pipe(
+  z13.object({
+    autoTopups: z13.optional(
+      z13.array(z13.lazy(() => BillingUpdateAutoTopup$outboundSchema))
+    ),
+    spendLimits: z13.optional(
+      z13.array(z13.lazy(() => BillingUpdateSpendLimit$outboundSchema))
+    ),
+    usageLimits: z13.optional(
+      z13.array(z13.lazy(() => BillingUpdateUsageLimit$outboundSchema))
+    ),
+    usageAlerts: z13.optional(
+      z13.array(z13.lazy(() => BillingUpdateUsageAlert$outboundSchema))
+    ),
+    overageAllowed: z13.optional(
+      z13.array(z13.lazy(() => BillingUpdateOverageAllowed$outboundSchema))
+    )
+  }),
+  z13.transform((v) => {
+    return remap(v, {
+      autoTopups: "auto_topups",
+      spendLimits: "spend_limits",
+      usageLimits: "usage_limits",
+      usageAlerts: "usage_alerts",
+      overageAllowed: "overage_allowed"
+    });
+  })
+);
 var BillingUpdateCustomize$outboundSchema = z13.pipe(
   z13.object({
     price: z13.optional(
@@ -2678,13 +2958,17 @@ var BillingUpdateCustomize$outboundSchema = z13.pipe(
     ),
     freeTrial: z13.optional(
       z13.nullable(z13.lazy(() => BillingUpdateFreeTrialParams$outboundSchema))
+    ),
+    billingControls: z13.optional(
+      z13.lazy(() => BillingUpdateBillingControls$outboundSchema)
     )
   }),
   z13.transform((v) => {
     return remap(v, {
       addItems: "add_items",
       removeItems: "remove_items",
-      freeTrial: "free_trial"
+      freeTrial: "free_trial",
+      billingControls: "billing_controls"
     });
   })
 );
@@ -2852,7 +3136,7 @@ var FeatureType2 = {
   Boolean: "boolean",
   Static: "static"
 };
-var CheckInterval2 = {
+var CheckItemInterval2 = {
   Minute: "minute",
   Hour: "hour",
   Day: "day",
@@ -2896,6 +3180,28 @@ var CheckOnEnd2 = {
   Bill: "bill",
   Revert: "revert"
 };
+var CheckPurchaseLimitInterval2 = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var CheckLimitType2 = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var CheckUsageLimitInterval2 = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var CheckThresholdType2 = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var ProductScenario2 = {
   Scheduled: "scheduled",
   Active: "active",
@@ -2933,7 +3239,7 @@ var FeatureType1 = {
   Boolean: "boolean",
   Static: "static"
 };
-var CheckInterval1 = {
+var CheckItemInterval1 = {
   Minute: "minute",
   Hour: "hour",
   Day: "day",
@@ -2977,6 +3283,28 @@ var CheckOnEnd1 = {
   Bill: "bill",
   Revert: "revert"
 };
+var CheckPurchaseLimitInterval1 = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var CheckLimitType1 = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var CheckUsageLimitInterval1 = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var CheckThresholdType1 = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var ProductScenario1 = {
   Scheduled: "scheduled",
   Active: "active",
@@ -3112,7 +3440,7 @@ var CheckEnv2$inboundSchema = inboundSchema(CheckEnv2);
 var ProductType2$inboundSchema = inboundSchema(ProductType2);
 var FeatureType2$inboundSchema = inboundSchema(FeatureType2);
 var IncludedUsage2$inboundSchema = smartUnion([number2(), string4()]);
-var CheckInterval2$inboundSchema = inboundSchema(CheckInterval2);
+var CheckItemInterval2$inboundSchema = inboundSchema(CheckItemInterval2);
 var CheckTierBehavior2$inboundSchema = inboundSchema(CheckTierBehavior2);
 var UsageModel2$inboundSchema = inboundSchema(UsageModel2);
 var ProductDisplay2$inboundSchema = z14.pipe(
@@ -3166,7 +3494,7 @@ var CheckItem2$inboundSchema = z14.pipe(
     included_usage: z14.optional(
       z14.nullable(smartUnion([number2(), string4()]))
     ),
-    interval: z14.optional(z14.nullable(CheckInterval2$inboundSchema)),
+    interval: z14.optional(z14.nullable(CheckItemInterval2$inboundSchema)),
     interval_count: z14.optional(z14.nullable(number2())),
     price: z14.optional(z14.nullable(number2())),
     tiers: z14.optional(z14.nullable(z14.array(nullable(z14.any())))),
@@ -3217,48 +3545,169 @@ var CheckFreeTrial2$inboundSchema = z14.pipe(
     });
   })
 );
-var ProductScenario2$inboundSchema = inboundSchema(ProductScenario2);
-var Properties2$inboundSchema = z14.pipe(
+var CheckPurchaseLimitInterval2$inboundSchema = inboundSchema(CheckPurchaseLimitInterval2);
+var CheckPurchaseLimit2$inboundSchema = z14.pipe(
   z14.object({
-    is_free: boolean2(),
-    is_one_off: boolean2(),
-    interval_group: z14.optional(z14.nullable(string4())),
-    has_trial: z14.optional(z14.nullable(boolean2())),
-    updateable: z14.optional(z14.nullable(boolean2()))
+    interval: CheckPurchaseLimitInterval2$inboundSchema,
+    interval_count: z14._default(number2(), 1),
+    limit: number2()
   }),
   z14.transform((v) => {
     return remap(v, {
-      "is_free": "isFree",
-      "is_one_off": "isOneOff",
-      "interval_group": "intervalGroup",
-      "has_trial": "hasTrial"
+      "interval_count": "intervalCount"
     });
   })
 );
-var CheckProduct2$inboundSchema = z14.pipe(
+var CheckAutoTopup2$inboundSchema = z14.pipe(
   z14.object({
-    id: string4(),
-    name: string4(),
-    group: nullable(string4()),
-    env: CheckEnv2$inboundSchema,
-    is_add_on: boolean2(),
-    is_default: boolean2(),
-    archived: boolean2(),
-    version: number2(),
-    created_at: number2(),
-    items: z14.array(z14.lazy(() => CheckItem2$inboundSchema)),
-    free_trial: nullable(z14.lazy(() => CheckFreeTrial2$inboundSchema)),
-    base_variant_id: nullable(string4()),
-    scenario: optional3(ProductScenario2$inboundSchema),
-    properties: optional3(z14.lazy(() => Properties2$inboundSchema))
+    feature_id: string4(),
+    enabled: z14._default(boolean2(), false),
+    threshold: number2(),
+    quantity: number2(),
+    purchase_limit: optional3(
+      z14.lazy(() => CheckPurchaseLimit2$inboundSchema)
+    ),
+    invoice_mode: optional3(boolean2())
   }),
   z14.transform((v) => {
     return remap(v, {
-      "is_add_on": "isAddOn",
-      "is_default": "isDefault",
+      "feature_id": "featureId",
+      "purchase_limit": "purchaseLimit",
+      "invoice_mode": "invoiceMode"
+    });
+  })
+);
+var CheckLimitType2$inboundSchema = inboundSchema(CheckLimitType2);
+var CheckSpendLimit2$inboundSchema = z14.pipe(
+  z14.object({
+    feature_id: optional3(string4()),
+    enabled: z14._default(boolean2(), false),
+    limit_type: optional3(CheckLimitType2$inboundSchema),
+    overage_limit: optional3(number2())
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "limit_type": "limitType",
+      "overage_limit": "overageLimit"
+    });
+  })
+);
+var CheckUsageLimitInterval2$inboundSchema = inboundSchema(CheckUsageLimitInterval2);
+var CheckUsageLimit2$inboundSchema = z14.pipe(
+  z14.object({
+    feature_id: string4(),
+    enabled: z14._default(boolean2(), true),
+    limit: number2(),
+    interval: CheckUsageLimitInterval2$inboundSchema
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var CheckThresholdType2$inboundSchema = inboundSchema(CheckThresholdType2);
+var CheckUsageAlert2$inboundSchema = z14.pipe(
+  z14.object({
+    feature_id: optional3(string4()),
+    enabled: z14._default(boolean2(), true),
+    threshold: number2(),
+    threshold_type: CheckThresholdType2$inboundSchema,
+    name: optional3(string4())
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "threshold_type": "thresholdType"
+    });
+  })
+);
+var CheckOverageAllowed2$inboundSchema = z14.pipe(
+  z14.object({
+    feature_id: string4(),
+    enabled: z14._default(boolean2(), false)
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var CheckBillingControls2$inboundSchema = z14.pipe(
+  z14.object({
+    auto_topups: optional3(
+      z14.array(z14.lazy(() => CheckAutoTopup2$inboundSchema))
+    ),
+    spend_limits: optional3(
+      z14.array(z14.lazy(() => CheckSpendLimit2$inboundSchema))
+    ),
+    usage_limits: optional3(
+      z14.array(z14.lazy(() => CheckUsageLimit2$inboundSchema))
+    ),
+    usage_alerts: optional3(
+      z14.array(z14.lazy(() => CheckUsageAlert2$inboundSchema))
+    ),
+    overage_allowed: optional3(
+      z14.array(z14.lazy(() => CheckOverageAllowed2$inboundSchema))
+    )
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "auto_topups": "autoTopups",
+      "spend_limits": "spendLimits",
+      "usage_limits": "usageLimits",
+      "usage_alerts": "usageAlerts",
+      "overage_allowed": "overageAllowed"
+    });
+  })
+);
+var ProductScenario2$inboundSchema = inboundSchema(ProductScenario2);
+var Properties2$inboundSchema = z14.pipe(
+  z14.object({
+    is_free: boolean2(),
+    is_one_off: boolean2(),
+    interval_group: z14.optional(z14.nullable(string4())),
+    has_trial: z14.optional(z14.nullable(boolean2())),
+    updateable: z14.optional(z14.nullable(boolean2()))
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "is_free": "isFree",
+      "is_one_off": "isOneOff",
+      "interval_group": "intervalGroup",
+      "has_trial": "hasTrial"
+    });
+  })
+);
+var CheckProduct2$inboundSchema = z14.pipe(
+  z14.object({
+    id: string4(),
+    name: string4(),
+    group: nullable(string4()),
+    env: CheckEnv2$inboundSchema,
+    is_add_on: boolean2(),
+    is_default: boolean2(),
+    archived: boolean2(),
+    version: number2(),
+    created_at: number2(),
+    items: z14.array(z14.lazy(() => CheckItem2$inboundSchema)),
+    free_trial: nullable(z14.lazy(() => CheckFreeTrial2$inboundSchema)),
+    base_variant_id: nullable(string4()),
+    billing_controls: optional3(
+      z14.lazy(() => CheckBillingControls2$inboundSchema)
+    ),
+    scenario: optional3(ProductScenario2$inboundSchema),
+    properties: optional3(z14.lazy(() => Properties2$inboundSchema))
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "is_add_on": "isAddOn",
+      "is_default": "isDefault",
       "created_at": "createdAt",
       "free_trial": "freeTrial",
-      "base_variant_id": "baseVariantId"
+      "base_variant_id": "baseVariantId",
+      "billing_controls": "billingControls"
     });
   })
 );
@@ -3387,7 +3836,7 @@ var CheckEnv1$inboundSchema = inboundSchema(CheckEnv1);
 var ProductType1$inboundSchema = inboundSchema(ProductType1);
 var FeatureType1$inboundSchema = inboundSchema(FeatureType1);
 var IncludedUsage1$inboundSchema = smartUnion([number2(), string4()]);
-var CheckInterval1$inboundSchema = inboundSchema(CheckInterval1);
+var CheckItemInterval1$inboundSchema = inboundSchema(CheckItemInterval1);
 var CheckTierBehavior1$inboundSchema = inboundSchema(CheckTierBehavior1);
 var UsageModel1$inboundSchema = inboundSchema(UsageModel1);
 var ProductDisplay1$inboundSchema = z14.pipe(
@@ -3441,7 +3890,7 @@ var CheckItem1$inboundSchema = z14.pipe(
     included_usage: z14.optional(
       z14.nullable(smartUnion([number2(), string4()]))
     ),
-    interval: z14.optional(z14.nullable(CheckInterval1$inboundSchema)),
+    interval: z14.optional(z14.nullable(CheckItemInterval1$inboundSchema)),
     interval_count: z14.optional(z14.nullable(number2())),
     price: z14.optional(z14.nullable(number2())),
     tiers: z14.optional(z14.nullable(z14.array(nullable(z14.any())))),
@@ -3492,6 +3941,123 @@ var CheckFreeTrial1$inboundSchema = z14.pipe(
     });
   })
 );
+var CheckPurchaseLimitInterval1$inboundSchema = inboundSchema(CheckPurchaseLimitInterval1);
+var CheckPurchaseLimit1$inboundSchema = z14.pipe(
+  z14.object({
+    interval: CheckPurchaseLimitInterval1$inboundSchema,
+    interval_count: z14._default(number2(), 1),
+    limit: number2()
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var CheckAutoTopup1$inboundSchema = z14.pipe(
+  z14.object({
+    feature_id: string4(),
+    enabled: z14._default(boolean2(), false),
+    threshold: number2(),
+    quantity: number2(),
+    purchase_limit: optional3(
+      z14.lazy(() => CheckPurchaseLimit1$inboundSchema)
+    ),
+    invoice_mode: optional3(boolean2())
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "purchase_limit": "purchaseLimit",
+      "invoice_mode": "invoiceMode"
+    });
+  })
+);
+var CheckLimitType1$inboundSchema = inboundSchema(CheckLimitType1);
+var CheckSpendLimit1$inboundSchema = z14.pipe(
+  z14.object({
+    feature_id: optional3(string4()),
+    enabled: z14._default(boolean2(), false),
+    limit_type: optional3(CheckLimitType1$inboundSchema),
+    overage_limit: optional3(number2())
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "limit_type": "limitType",
+      "overage_limit": "overageLimit"
+    });
+  })
+);
+var CheckUsageLimitInterval1$inboundSchema = inboundSchema(CheckUsageLimitInterval1);
+var CheckUsageLimit1$inboundSchema = z14.pipe(
+  z14.object({
+    feature_id: string4(),
+    enabled: z14._default(boolean2(), true),
+    limit: number2(),
+    interval: CheckUsageLimitInterval1$inboundSchema
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var CheckThresholdType1$inboundSchema = inboundSchema(CheckThresholdType1);
+var CheckUsageAlert1$inboundSchema = z14.pipe(
+  z14.object({
+    feature_id: optional3(string4()),
+    enabled: z14._default(boolean2(), true),
+    threshold: number2(),
+    threshold_type: CheckThresholdType1$inboundSchema,
+    name: optional3(string4())
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "threshold_type": "thresholdType"
+    });
+  })
+);
+var CheckOverageAllowed1$inboundSchema = z14.pipe(
+  z14.object({
+    feature_id: string4(),
+    enabled: z14._default(boolean2(), false)
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var CheckBillingControls1$inboundSchema = z14.pipe(
+  z14.object({
+    auto_topups: optional3(
+      z14.array(z14.lazy(() => CheckAutoTopup1$inboundSchema))
+    ),
+    spend_limits: optional3(
+      z14.array(z14.lazy(() => CheckSpendLimit1$inboundSchema))
+    ),
+    usage_limits: optional3(
+      z14.array(z14.lazy(() => CheckUsageLimit1$inboundSchema))
+    ),
+    usage_alerts: optional3(
+      z14.array(z14.lazy(() => CheckUsageAlert1$inboundSchema))
+    ),
+    overage_allowed: optional3(
+      z14.array(z14.lazy(() => CheckOverageAllowed1$inboundSchema))
+    )
+  }),
+  z14.transform((v) => {
+    return remap(v, {
+      "auto_topups": "autoTopups",
+      "spend_limits": "spendLimits",
+      "usage_limits": "usageLimits",
+      "usage_alerts": "usageAlerts",
+      "overage_allowed": "overageAllowed"
+    });
+  })
+);
 var ProductScenario1$inboundSchema = inboundSchema(ProductScenario1);
 var Properties1$inboundSchema = z14.pipe(
   z14.object({
@@ -3524,6 +4090,9 @@ var CheckProduct1$inboundSchema = z14.pipe(
     items: z14.array(z14.lazy(() => CheckItem1$inboundSchema)),
     free_trial: nullable(z14.lazy(() => CheckFreeTrial1$inboundSchema)),
     base_variant_id: nullable(string4()),
+    billing_controls: optional3(
+      z14.lazy(() => CheckBillingControls1$inboundSchema)
+    ),
     scenario: optional3(ProductScenario1$inboundSchema),
     properties: optional3(z14.lazy(() => Properties1$inboundSchema))
   }),
@@ -3533,7 +4102,8 @@ var CheckProduct1$inboundSchema = z14.pipe(
       "is_default": "isDefault",
       "created_at": "createdAt",
       "free_trial": "freeTrial",
-      "base_variant_id": "baseVariantId"
+      "base_variant_id": "baseVariantId",
+      "billing_controls": "billingControls"
     });
   })
 );
@@ -3662,6 +4232,10 @@ var CustomerDataPurchaseLimitInterval = {
   Week: "week",
   Month: "month"
 };
+var CustomerDataLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var CustomerDataUsageLimitInterval = {
   Day: "day",
   Week: "week",
@@ -3706,15 +4280,18 @@ var CustomerDataAutoTopup$outboundSchema = z16.pipe(
     });
   })
 );
+var CustomerDataLimitType$outboundSchema = z16.enum(CustomerDataLimitType);
 var CustomerDataSpendLimit$outboundSchema = z16.pipe(
   z16.object({
     featureId: z16.optional(z16.string()),
     enabled: z16._default(z16.boolean(), false),
+    limitType: z16.optional(CustomerDataLimitType$outboundSchema),
     overageLimit: z16.optional(z16.number())
   }),
   z16.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
+      limitType: "limit_type",
       overageLimit: "overage_limit"
     });
   })
@@ -3723,6 +4300,7 @@ var CustomerDataUsageLimitInterval$outboundSchema = z16.enum(CustomerDataUsageLi
 var CustomerDataUsageLimit$outboundSchema = z16.pipe(
   z16.object({
     featureId: z16.string(),
+    enabled: z16._default(z16.boolean(), true),
     limit: z16.number(),
     interval: CustomerDataUsageLimitInterval$outboundSchema
   }),
@@ -3885,6 +4463,28 @@ var PlanEnv = {
   Sandbox: "sandbox",
   Live: "live"
 };
+var PlanPurchaseLimitInterval = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var PlanLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var PlanUsageLimitInterval = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var PlanThresholdType = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var PlanStatus = {
   Active: "active",
   Scheduled: "scheduled"
@@ -4038,49 +4638,166 @@ var PlanRollover$inboundSchema = z17.pipe(
     });
   })
 );
-var Item$inboundSchema = z17.pipe(
+var Item$inboundSchema = z17.pipe(
+  z17.object({
+    feature_id: string4(),
+    feature: optional3(z17.lazy(() => PlanFeature$inboundSchema)),
+    included: number2(),
+    unlimited: boolean2(),
+    reset: nullable(z17.lazy(() => PlanReset$inboundSchema)),
+    price: nullable(z17.lazy(() => PlanItemPrice$inboundSchema)),
+    display: optional3(z17.lazy(() => PlanItemDisplay$inboundSchema)),
+    rollover: optional3(z17.lazy(() => PlanRollover$inboundSchema))
+  }),
+  z17.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var PlanDurationType$inboundSchema = inboundSchema(PlanDurationType);
+var OnEnd$inboundSchema = inboundSchema(OnEnd);
+var FreeTrial$inboundSchema = z17.pipe(
+  z17.object({
+    duration_length: number2(),
+    duration_type: PlanDurationType$inboundSchema,
+    card_required: boolean2(),
+    on_end: z17.optional(z17.nullable(OnEnd$inboundSchema))
+  }),
+  z17.transform((v) => {
+    return remap(v, {
+      "duration_length": "durationLength",
+      "duration_type": "durationType",
+      "card_required": "cardRequired",
+      "on_end": "onEnd"
+    });
+  })
+);
+var PlanEnv$inboundSchema = inboundSchema(PlanEnv);
+var PlanConfig$inboundSchema = z17.pipe(
+  z17.object({
+    ignore_past_due: z17._default(boolean2(), false)
+  }),
+  z17.transform((v) => {
+    return remap(v, {
+      "ignore_past_due": "ignorePastDue"
+    });
+  })
+);
+var PlanPurchaseLimitInterval$inboundSchema = inboundSchema(PlanPurchaseLimitInterval);
+var PlanPurchaseLimit$inboundSchema = z17.pipe(
+  z17.object({
+    interval: PlanPurchaseLimitInterval$inboundSchema,
+    interval_count: z17._default(number2(), 1),
+    limit: number2()
+  }),
+  z17.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var PlanAutoTopup$inboundSchema = z17.pipe(
+  z17.object({
+    feature_id: string4(),
+    enabled: z17._default(boolean2(), false),
+    threshold: number2(),
+    quantity: number2(),
+    purchase_limit: optional3(
+      z17.lazy(() => PlanPurchaseLimit$inboundSchema)
+    ),
+    invoice_mode: optional3(boolean2())
+  }),
+  z17.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "purchase_limit": "purchaseLimit",
+      "invoice_mode": "invoiceMode"
+    });
+  })
+);
+var PlanLimitType$inboundSchema = inboundSchema(PlanLimitType);
+var PlanSpendLimit$inboundSchema = z17.pipe(
+  z17.object({
+    feature_id: optional3(string4()),
+    enabled: z17._default(boolean2(), false),
+    limit_type: optional3(PlanLimitType$inboundSchema),
+    overage_limit: optional3(number2())
+  }),
+  z17.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "limit_type": "limitType",
+      "overage_limit": "overageLimit"
+    });
+  })
+);
+var PlanUsageLimitInterval$inboundSchema = inboundSchema(PlanUsageLimitInterval);
+var PlanUsageLimit$inboundSchema = z17.pipe(
+  z17.object({
+    feature_id: string4(),
+    enabled: z17._default(boolean2(), true),
+    limit: number2(),
+    interval: PlanUsageLimitInterval$inboundSchema
+  }),
+  z17.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var PlanThresholdType$inboundSchema = inboundSchema(PlanThresholdType);
+var PlanUsageAlert$inboundSchema = z17.pipe(
   z17.object({
-    feature_id: string4(),
-    feature: optional3(z17.lazy(() => PlanFeature$inboundSchema)),
-    included: number2(),
-    unlimited: boolean2(),
-    reset: nullable(z17.lazy(() => PlanReset$inboundSchema)),
-    price: nullable(z17.lazy(() => PlanItemPrice$inboundSchema)),
-    display: optional3(z17.lazy(() => PlanItemDisplay$inboundSchema)),
-    rollover: optional3(z17.lazy(() => PlanRollover$inboundSchema))
+    feature_id: optional3(string4()),
+    enabled: z17._default(boolean2(), true),
+    threshold: number2(),
+    threshold_type: PlanThresholdType$inboundSchema,
+    name: optional3(string4())
   }),
   z17.transform((v) => {
     return remap(v, {
-      "feature_id": "featureId"
+      "feature_id": "featureId",
+      "threshold_type": "thresholdType"
     });
   })
 );
-var PlanDurationType$inboundSchema = inboundSchema(PlanDurationType);
-var OnEnd$inboundSchema = inboundSchema(OnEnd);
-var FreeTrial$inboundSchema = z17.pipe(
+var PlanOverageAllowed$inboundSchema = z17.pipe(
   z17.object({
-    duration_length: number2(),
-    duration_type: PlanDurationType$inboundSchema,
-    card_required: boolean2(),
-    on_end: z17.optional(z17.nullable(OnEnd$inboundSchema))
+    feature_id: string4(),
+    enabled: z17._default(boolean2(), false)
   }),
   z17.transform((v) => {
     return remap(v, {
-      "duration_length": "durationLength",
-      "duration_type": "durationType",
-      "card_required": "cardRequired",
-      "on_end": "onEnd"
+      "feature_id": "featureId"
     });
   })
 );
-var PlanEnv$inboundSchema = inboundSchema(PlanEnv);
-var PlanConfig$inboundSchema = z17.pipe(
+var PlanBillingControls$inboundSchema = z17.pipe(
   z17.object({
-    ignore_past_due: z17._default(boolean2(), false)
+    auto_topups: optional3(
+      z17.array(z17.lazy(() => PlanAutoTopup$inboundSchema))
+    ),
+    spend_limits: optional3(
+      z17.array(z17.lazy(() => PlanSpendLimit$inboundSchema))
+    ),
+    usage_limits: optional3(
+      z17.array(z17.lazy(() => PlanUsageLimit$inboundSchema))
+    ),
+    usage_alerts: optional3(
+      z17.array(z17.lazy(() => PlanUsageAlert$inboundSchema))
+    ),
+    overage_allowed: optional3(
+      z17.array(z17.lazy(() => PlanOverageAllowed$inboundSchema))
+    )
   }),
   z17.transform((v) => {
     return remap(v, {
-      "ignore_past_due": "ignorePastDue"
+      "auto_topups": "autoTopups",
+      "spend_limits": "spendLimits",
+      "usage_limits": "usageLimits",
+      "usage_alerts": "usageAlerts",
+      "overage_allowed": "overageAllowed"
     });
   })
 );
@@ -4118,6 +4835,9 @@ var Plan$inboundSchema = z17.pipe(
     archived: boolean2(),
     base_variant_id: nullable(string4()),
     config: z17.lazy(() => PlanConfig$inboundSchema),
+    billing_controls: optional3(z17.lazy(
+      () => PlanBillingControls$inboundSchema
+    )),
     metadata: z17.record(z17.string(), z17.any()),
     customer_eligibility: optional3(z17.lazy(
       () => CustomerEligibility$inboundSchema
@@ -4130,12 +4850,17 @@ var Plan$inboundSchema = z17.pipe(
       "free_trial": "freeTrial",
       "created_at": "createdAt",
       "base_variant_id": "baseVariantId",
+      "billing_controls": "billingControls",
       "customer_eligibility": "customerEligibility"
     });
   })
 );
 
 // ../sdk/src/models/create-entity-op.ts
+var CreateEntityLimitTypeRequestBody = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var CreateEntityIntervalRequestBody = {
   Day: "day",
   Week: "week",
@@ -4170,6 +4895,10 @@ var CreateEntityType = {
   CreditSystem: "credit_system",
   AiCreditSystem: "ai_credit_system"
 };
+var CreateEntityLimitTypeResponse = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var CreateEntityIntervalResponse = {
   Day: "day",
   Week: "week",
@@ -4186,15 +4915,18 @@ var CreateEntityProcessorType = {
   Stripe: "stripe",
   Revenuecat: "revenuecat"
 };
+var CreateEntityLimitTypeRequestBody$outboundSchema = z18.enum(CreateEntityLimitTypeRequestBody);
 var CreateEntitySpendLimitRequest$outboundSchema = z18.pipe(
   z18.object({
     featureId: z18.optional(z18.string()),
     enabled: z18._default(z18.boolean(), false),
+    limitType: z18.optional(CreateEntityLimitTypeRequestBody$outboundSchema),
     overageLimit: z18.optional(z18.number())
   }),
   z18.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
+      limitType: "limit_type",
       overageLimit: "overage_limit"
     });
   })
@@ -4203,6 +4935,7 @@ var CreateEntityIntervalRequestBody$outboundSchema = z18.enum(CreateEntityInterv
 var CreateEntityUsageLimitRequest$outboundSchema = z18.pipe(
   z18.object({
     featureId: z18.string(),
+    enabled: z18._default(z18.boolean(), true),
     limit: z18.number(),
     interval: CreateEntityIntervalRequestBody$outboundSchema
   }),
@@ -4421,15 +5154,18 @@ var CreateEntityFlags$inboundSchema = z18.pipe(
     });
   })
 );
+var CreateEntityLimitTypeResponse$inboundSchema = inboundSchema(CreateEntityLimitTypeResponse);
 var CreateEntitySpendLimitResponse$inboundSchema = z18.pipe(
   z18.object({
     feature_id: optional3(string4()),
     enabled: z18._default(boolean2(), false),
+    limit_type: optional3(CreateEntityLimitTypeResponse$inboundSchema),
     overage_limit: optional3(number2())
   }),
   z18.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
+      "limit_type": "limitType",
       "overage_limit": "overageLimit"
     });
   })
@@ -4438,6 +5174,7 @@ var CreateEntityIntervalResponse$inboundSchema = inboundSchema(CreateEntityInter
 var CreateEntityUsageLimitResponse$inboundSchema = z18.pipe(
   z18.object({
     feature_id: string4(),
+    enabled: z18._default(boolean2(), true),
     limit: number2(),
     interval: CreateEntityIntervalResponse$inboundSchema,
     usage: optional3(number2())
@@ -4773,6 +5510,28 @@ var CreatePlanOnEndRequest = {
   Bill: "bill",
   Revert: "revert"
 };
+var CreatePlanPurchaseLimitIntervalRequestBody = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var CreatePlanLimitTypeRequestBody = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var CreatePlanUsageLimitIntervalRequestBody = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var CreatePlanThresholdTypeRequestBody = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var CreatePlanPriceIntervalResponse = {
   OneOff: "one_off",
   Week: "week",
@@ -4833,6 +5592,28 @@ var CreatePlanEnv = {
   Sandbox: "sandbox",
   Live: "live"
 };
+var CreatePlanPurchaseLimitIntervalResponse = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var CreatePlanLimitTypeResponse = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var CreatePlanUsageLimitIntervalResponse = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var CreatePlanThresholdTypeResponse = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var CreatePlanStatus = {
   Active: "active",
   Scheduled: "scheduled"
@@ -4993,6 +5774,127 @@ var CreatePlanConfigRequest$outboundSchema = z20.pipe(
     });
   })
 );
+var CreatePlanPurchaseLimitIntervalRequestBody$outboundSchema = z20.enum(
+  CreatePlanPurchaseLimitIntervalRequestBody
+);
+var CreatePlanPurchaseLimitRequest$outboundSchema = z20.pipe(
+  z20.object({
+    interval: CreatePlanPurchaseLimitIntervalRequestBody$outboundSchema,
+    intervalCount: z20._default(z20.number(), 1),
+    limit: z20.number()
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      intervalCount: "interval_count"
+    });
+  })
+);
+var CreatePlanAutoTopupRequest$outboundSchema = z20.pipe(
+  z20.object({
+    featureId: z20.string(),
+    enabled: z20._default(z20.boolean(), false),
+    threshold: z20.number(),
+    quantity: z20.number(),
+    purchaseLimit: z20.optional(
+      z20.lazy(() => CreatePlanPurchaseLimitRequest$outboundSchema)
+    ),
+    invoiceMode: z20.optional(z20.boolean())
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      purchaseLimit: "purchase_limit",
+      invoiceMode: "invoice_mode"
+    });
+  })
+);
+var CreatePlanLimitTypeRequestBody$outboundSchema = z20.enum(CreatePlanLimitTypeRequestBody);
+var CreatePlanSpendLimitRequest$outboundSchema = z20.pipe(
+  z20.object({
+    featureId: z20.optional(z20.string()),
+    enabled: z20._default(z20.boolean(), false),
+    limitType: z20.optional(CreatePlanLimitTypeRequestBody$outboundSchema),
+    overageLimit: z20.optional(z20.number())
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      limitType: "limit_type",
+      overageLimit: "overage_limit"
+    });
+  })
+);
+var CreatePlanUsageLimitIntervalRequestBody$outboundSchema = z20.enum(
+  CreatePlanUsageLimitIntervalRequestBody
+);
+var CreatePlanUsageLimitRequest$outboundSchema = z20.pipe(
+  z20.object({
+    featureId: z20.string(),
+    enabled: z20._default(z20.boolean(), true),
+    limit: z20.number(),
+    interval: CreatePlanUsageLimitIntervalRequestBody$outboundSchema
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var CreatePlanThresholdTypeRequestBody$outboundSchema = z20.enum(CreatePlanThresholdTypeRequestBody);
+var CreatePlanUsageAlertRequestBody$outboundSchema = z20.pipe(
+  z20.object({
+    featureId: z20.optional(z20.string()),
+    enabled: z20._default(z20.boolean(), true),
+    threshold: z20.number(),
+    thresholdType: CreatePlanThresholdTypeRequestBody$outboundSchema,
+    name: z20.optional(z20.string())
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      thresholdType: "threshold_type"
+    });
+  })
+);
+var CreatePlanOverageAllowedRequest$outboundSchema = z20.pipe(
+  z20.object({
+    featureId: z20.string(),
+    enabled: z20._default(z20.boolean(), false)
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var CreatePlanBillingControlsRequest$outboundSchema = z20.pipe(
+  z20.object({
+    autoTopups: z20.optional(
+      z20.array(z20.lazy(() => CreatePlanAutoTopupRequest$outboundSchema))
+    ),
+    spendLimits: z20.optional(
+      z20.array(z20.lazy(() => CreatePlanSpendLimitRequest$outboundSchema))
+    ),
+    usageLimits: z20.optional(
+      z20.array(z20.lazy(() => CreatePlanUsageLimitRequest$outboundSchema))
+    ),
+    usageAlerts: z20.optional(
+      z20.array(z20.lazy(() => CreatePlanUsageAlertRequestBody$outboundSchema))
+    ),
+    overageAllowed: z20.optional(
+      z20.array(z20.lazy(() => CreatePlanOverageAllowedRequest$outboundSchema))
+    )
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      autoTopups: "auto_topups",
+      spendLimits: "spend_limits",
+      usageLimits: "usage_limits",
+      usageAlerts: "usage_alerts",
+      overageAllowed: "overage_allowed"
+    });
+  })
+);
 var CreatePlanParams$outboundSchema = z20.pipe(
   z20.object({
     planId: z20.string(),
@@ -5005,6 +5907,9 @@ var CreatePlanParams$outboundSchema = z20.pipe(
     items: z20.optional(z20.array(z20.lazy(() => CreatePlanPlanItem$outboundSchema))),
     freeTrial: z20.optional(z20.lazy(() => FreeTrialRequest$outboundSchema)),
     config: z20.optional(z20.lazy(() => CreatePlanConfigRequest$outboundSchema)),
+    billingControls: z20.optional(
+      z20.lazy(() => CreatePlanBillingControlsRequest$outboundSchema)
+    ),
     metadata: z20.optional(z20.record(z20.string(), z20.any())),
     createInStripe: z20._default(z20.boolean(), true)
   }),
@@ -5014,6 +5919,7 @@ var CreatePlanParams$outboundSchema = z20.pipe(
       addOn: "add_on",
       autoEnable: "auto_enable",
       freeTrial: "free_trial",
+      billingControls: "billing_controls",
       createInStripe: "create_in_stripe"
     });
   })
@@ -5153,59 +6059,176 @@ var CreatePlanRolloverResponse$inboundSchema = z20.pipe(
   }),
   z20.transform((v) => {
     return remap(v, {
-      "max_percentage": "maxPercentage",
-      "expiry_duration_type": "expiryDurationType",
-      "expiry_duration_length": "expiryDurationLength"
+      "max_percentage": "maxPercentage",
+      "expiry_duration_type": "expiryDurationType",
+      "expiry_duration_length": "expiryDurationLength"
+    });
+  })
+);
+var CreatePlanItem$inboundSchema = z20.pipe(
+  z20.object({
+    feature_id: string4(),
+    feature: optional3(z20.lazy(() => CreatePlanFeature$inboundSchema)),
+    included: number2(),
+    unlimited: boolean2(),
+    reset: nullable(z20.lazy(() => CreatePlanResetResponse$inboundSchema)),
+    price: nullable(
+      z20.lazy(() => CreatePlanItemPriceResponse$inboundSchema)
+    ),
+    display: optional3(z20.lazy(() => CreatePlanItemDisplay$inboundSchema)),
+    rollover: optional3(
+      z20.lazy(() => CreatePlanRolloverResponse$inboundSchema)
+    )
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var CreatePlanDurationTypeResponse$inboundSchema = inboundSchema(CreatePlanDurationTypeResponse);
+var CreatePlanOnEndResponse$inboundSchema = inboundSchema(CreatePlanOnEndResponse);
+var CreatePlanFreeTrialResponse$inboundSchema = z20.pipe(
+  z20.object({
+    duration_length: number2(),
+    duration_type: CreatePlanDurationTypeResponse$inboundSchema,
+    card_required: boolean2(),
+    on_end: z20.optional(z20.nullable(CreatePlanOnEndResponse$inboundSchema))
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      "duration_length": "durationLength",
+      "duration_type": "durationType",
+      "card_required": "cardRequired",
+      "on_end": "onEnd"
+    });
+  })
+);
+var CreatePlanEnv$inboundSchema = inboundSchema(CreatePlanEnv);
+var CreatePlanConfigResponse$inboundSchema = z20.pipe(
+  z20.object({
+    ignore_past_due: z20._default(boolean2(), false)
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      "ignore_past_due": "ignorePastDue"
+    });
+  })
+);
+var CreatePlanPurchaseLimitIntervalResponse$inboundSchema = inboundSchema(CreatePlanPurchaseLimitIntervalResponse);
+var CreatePlanPurchaseLimitResponse$inboundSchema = z20.pipe(
+  z20.object({
+    interval: CreatePlanPurchaseLimitIntervalResponse$inboundSchema,
+    interval_count: z20._default(number2(), 1),
+    limit: number2()
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var CreatePlanAutoTopupResponse$inboundSchema = z20.pipe(
+  z20.object({
+    feature_id: string4(),
+    enabled: z20._default(boolean2(), false),
+    threshold: number2(),
+    quantity: number2(),
+    purchase_limit: optional3(
+      z20.lazy(() => CreatePlanPurchaseLimitResponse$inboundSchema)
+    ),
+    invoice_mode: optional3(boolean2())
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "purchase_limit": "purchaseLimit",
+      "invoice_mode": "invoiceMode"
+    });
+  })
+);
+var CreatePlanLimitTypeResponse$inboundSchema = inboundSchema(CreatePlanLimitTypeResponse);
+var CreatePlanSpendLimitResponse$inboundSchema = z20.pipe(
+  z20.object({
+    feature_id: optional3(string4()),
+    enabled: z20._default(boolean2(), false),
+    limit_type: optional3(CreatePlanLimitTypeResponse$inboundSchema),
+    overage_limit: optional3(number2())
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "limit_type": "limitType",
+      "overage_limit": "overageLimit"
+    });
+  })
+);
+var CreatePlanUsageLimitIntervalResponse$inboundSchema = inboundSchema(CreatePlanUsageLimitIntervalResponse);
+var CreatePlanUsageLimitResponse$inboundSchema = z20.pipe(
+  z20.object({
+    feature_id: string4(),
+    enabled: z20._default(boolean2(), true),
+    limit: number2(),
+    interval: CreatePlanUsageLimitIntervalResponse$inboundSchema
+  }),
+  z20.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
     });
   })
 );
-var CreatePlanItem$inboundSchema = z20.pipe(
+var CreatePlanThresholdTypeResponse$inboundSchema = inboundSchema(CreatePlanThresholdTypeResponse);
+var CreatePlanUsageAlertResponse$inboundSchema = z20.pipe(
   z20.object({
-    feature_id: string4(),
-    feature: optional3(z20.lazy(() => CreatePlanFeature$inboundSchema)),
-    included: number2(),
-    unlimited: boolean2(),
-    reset: nullable(z20.lazy(() => CreatePlanResetResponse$inboundSchema)),
-    price: nullable(
-      z20.lazy(() => CreatePlanItemPriceResponse$inboundSchema)
-    ),
-    display: optional3(z20.lazy(() => CreatePlanItemDisplay$inboundSchema)),
-    rollover: optional3(
-      z20.lazy(() => CreatePlanRolloverResponse$inboundSchema)
-    )
+    feature_id: optional3(string4()),
+    enabled: z20._default(boolean2(), true),
+    threshold: number2(),
+    threshold_type: CreatePlanThresholdTypeResponse$inboundSchema,
+    name: optional3(string4())
   }),
   z20.transform((v) => {
     return remap(v, {
-      "feature_id": "featureId"
+      "feature_id": "featureId",
+      "threshold_type": "thresholdType"
     });
   })
 );
-var CreatePlanDurationTypeResponse$inboundSchema = inboundSchema(CreatePlanDurationTypeResponse);
-var CreatePlanOnEndResponse$inboundSchema = inboundSchema(CreatePlanOnEndResponse);
-var CreatePlanFreeTrialResponse$inboundSchema = z20.pipe(
+var CreatePlanOverageAllowedResponse$inboundSchema = z20.pipe(
   z20.object({
-    duration_length: number2(),
-    duration_type: CreatePlanDurationTypeResponse$inboundSchema,
-    card_required: boolean2(),
-    on_end: z20.optional(z20.nullable(CreatePlanOnEndResponse$inboundSchema))
+    feature_id: string4(),
+    enabled: z20._default(boolean2(), false)
   }),
   z20.transform((v) => {
     return remap(v, {
-      "duration_length": "durationLength",
-      "duration_type": "durationType",
-      "card_required": "cardRequired",
-      "on_end": "onEnd"
+      "feature_id": "featureId"
     });
   })
 );
-var CreatePlanEnv$inboundSchema = inboundSchema(CreatePlanEnv);
-var CreatePlanConfigResponse$inboundSchema = z20.pipe(
+var CreatePlanBillingControlsResponse$inboundSchema = z20.pipe(
   z20.object({
-    ignore_past_due: z20._default(boolean2(), false)
+    auto_topups: optional3(
+      z20.array(z20.lazy(() => CreatePlanAutoTopupResponse$inboundSchema))
+    ),
+    spend_limits: optional3(
+      z20.array(z20.lazy(() => CreatePlanSpendLimitResponse$inboundSchema))
+    ),
+    usage_limits: optional3(
+      z20.array(z20.lazy(() => CreatePlanUsageLimitResponse$inboundSchema))
+    ),
+    usage_alerts: optional3(
+      z20.array(z20.lazy(() => CreatePlanUsageAlertResponse$inboundSchema))
+    ),
+    overage_allowed: optional3(
+      z20.array(z20.lazy(() => CreatePlanOverageAllowedResponse$inboundSchema))
+    )
   }),
   z20.transform((v) => {
     return remap(v, {
-      "ignore_past_due": "ignorePastDue"
+      "auto_topups": "autoTopups",
+      "spend_limits": "spendLimits",
+      "usage_limits": "usageLimits",
+      "usage_alerts": "usageAlerts",
+      "overage_allowed": "overageAllowed"
     });
   })
 );
@@ -5245,6 +6268,9 @@ var CreatePlanResponse$inboundSchema = z20.pipe(
     archived: boolean2(),
     base_variant_id: nullable(string4()),
     config: z20.lazy(() => CreatePlanConfigResponse$inboundSchema),
+    billing_controls: optional3(
+      z20.lazy(() => CreatePlanBillingControlsResponse$inboundSchema)
+    ),
     metadata: z20.record(z20.string(), z20.any()),
     customer_eligibility: optional3(
       z20.lazy(() => CreatePlanCustomerEligibility$inboundSchema)
@@ -5257,6 +6283,7 @@ var CreatePlanResponse$inboundSchema = z20.pipe(
       "free_trial": "freeTrial",
       "created_at": "createdAt",
       "base_variant_id": "baseVariantId",
+      "billing_controls": "billingControls",
       "customer_eligibility": "customerEligibility"
     });
   })
@@ -5424,6 +6451,28 @@ var CreateScheduleIntervalRemoveItemEnum3 = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
+var CreateSchedulePurchaseLimitInterval2 = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var CreateScheduleLimitType2 = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var CreateScheduleUsageLimitInterval2 = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var CreateScheduleThresholdType2 = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var CreateScheduleStatus = {
   Created: "created",
   PendingPayment: "pending_payment"
@@ -5741,6 +6790,123 @@ var CreateSchedulePlanItemFilter2$outboundSchema = z22.pipe(
     });
   })
 );
+var CreateSchedulePurchaseLimitInterval2$outboundSchema = z22.enum(CreateSchedulePurchaseLimitInterval2);
+var CreateSchedulePurchaseLimit2$outboundSchema = z22.pipe(
+  z22.object({
+    interval: CreateSchedulePurchaseLimitInterval2$outboundSchema,
+    intervalCount: z22._default(z22.number(), 1),
+    limit: z22.number()
+  }),
+  z22.transform((v) => {
+    return remap(v, {
+      intervalCount: "interval_count"
+    });
+  })
+);
+var CreateScheduleAutoTopup2$outboundSchema = z22.pipe(
+  z22.object({
+    featureId: z22.string(),
+    enabled: z22._default(z22.boolean(), false),
+    threshold: z22.number(),
+    quantity: z22.number(),
+    purchaseLimit: z22.optional(
+      z22.lazy(() => CreateSchedulePurchaseLimit2$outboundSchema)
+    ),
+    invoiceMode: z22.optional(z22.boolean())
+  }),
+  z22.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      purchaseLimit: "purchase_limit",
+      invoiceMode: "invoice_mode"
+    });
+  })
+);
+var CreateScheduleLimitType2$outboundSchema = z22.enum(CreateScheduleLimitType2);
+var CreateScheduleSpendLimit2$outboundSchema = z22.pipe(
+  z22.object({
+    featureId: z22.optional(z22.string()),
+    enabled: z22._default(z22.boolean(), false),
+    limitType: z22.optional(CreateScheduleLimitType2$outboundSchema),
+    overageLimit: z22.optional(z22.number())
+  }),
+  z22.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      limitType: "limit_type",
+      overageLimit: "overage_limit"
+    });
+  })
+);
+var CreateScheduleUsageLimitInterval2$outboundSchema = z22.enum(CreateScheduleUsageLimitInterval2);
+var CreateScheduleUsageLimit2$outboundSchema = z22.pipe(
+  z22.object({
+    featureId: z22.string(),
+    enabled: z22._default(z22.boolean(), true),
+    limit: z22.number(),
+    interval: CreateScheduleUsageLimitInterval2$outboundSchema
+  }),
+  z22.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var CreateScheduleThresholdType2$outboundSchema = z22.enum(CreateScheduleThresholdType2);
+var CreateScheduleUsageAlert2$outboundSchema = z22.pipe(
+  z22.object({
+    featureId: z22.optional(z22.string()),
+    enabled: z22._default(z22.boolean(), true),
+    threshold: z22.number(),
+    thresholdType: CreateScheduleThresholdType2$outboundSchema,
+    name: z22.optional(z22.string())
+  }),
+  z22.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      thresholdType: "threshold_type"
+    });
+  })
+);
+var CreateScheduleOverageAllowed2$outboundSchema = z22.pipe(
+  z22.object({
+    featureId: z22.string(),
+    enabled: z22._default(z22.boolean(), false)
+  }),
+  z22.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var CreateScheduleBillingControls2$outboundSchema = z22.pipe(
+  z22.object({
+    autoTopups: z22.optional(
+      z22.array(z22.lazy(() => CreateScheduleAutoTopup2$outboundSchema))
+    ),
+    spendLimits: z22.optional(
+      z22.array(z22.lazy(() => CreateScheduleSpendLimit2$outboundSchema))
+    ),
+    usageLimits: z22.optional(
+      z22.array(z22.lazy(() => CreateScheduleUsageLimit2$outboundSchema))
+    ),
+    usageAlerts: z22.optional(
+      z22.array(z22.lazy(() => CreateScheduleUsageAlert2$outboundSchema))
+    ),
+    overageAllowed: z22.optional(
+      z22.array(z22.lazy(() => CreateScheduleOverageAllowed2$outboundSchema))
+    )
+  }),
+  z22.transform((v) => {
+    return remap(v, {
+      autoTopups: "auto_topups",
+      spendLimits: "spend_limits",
+      usageLimits: "usage_limits",
+      usageAlerts: "usage_alerts",
+      overageAllowed: "overage_allowed"
+    });
+  })
+);
 var CreateScheduleCustomize2$outboundSchema = z22.pipe(
   z22.object({
     price: z22.optional(
@@ -5754,12 +6920,16 @@ var CreateScheduleCustomize2$outboundSchema = z22.pipe(
     ),
     removeItems: z22.optional(
       z22.array(z22.lazy(() => CreateSchedulePlanItemFilter2$outboundSchema))
+    ),
+    billingControls: z22.optional(
+      z22.lazy(() => CreateScheduleBillingControls2$outboundSchema)
     )
   }),
   z22.transform((v) => {
     return remap(v, {
       addItems: "add_items",
-      removeItems: "remove_items"
+      removeItems: "remove_items",
+      billingControls: "billing_controls"
     });
   })
 );
@@ -5926,6 +7096,10 @@ var CustomerPurchaseLimitInterval1 = {
   Week: "week",
   Month: "month"
 };
+var CustomerLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var CustomerUsageLimitInterval = {
   Day: "day",
   Week: "week",
@@ -6030,15 +7204,18 @@ var CustomerAutoTopup$inboundSchema = z24.pipe(
     });
   })
 );
+var CustomerLimitType$inboundSchema = inboundSchema(CustomerLimitType);
 var CustomerSpendLimit$inboundSchema = z24.pipe(
   z24.object({
     feature_id: optional3(string4()),
     enabled: z24._default(boolean2(), false),
+    limit_type: optional3(CustomerLimitType$inboundSchema),
     overage_limit: optional3(number2())
   }),
   z24.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
+      "limit_type": "limitType",
       "overage_limit": "overageLimit"
     });
   })
@@ -6047,6 +7224,7 @@ var CustomerUsageLimitInterval$inboundSchema = inboundSchema(CustomerUsageLimitI
 var CustomerUsageLimit$inboundSchema = z24.pipe(
   z24.object({
     feature_id: string4(),
+    enabled: z24._default(boolean2(), true),
     limit: number2(),
     interval: CustomerUsageLimitInterval$inboundSchema,
     usage: optional3(number2())
@@ -6579,6 +7757,10 @@ var GetCustomerPurchaseLimitInterval1 = {
   Week: "week",
   Month: "month"
 };
+var GetCustomerLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var GetCustomerUsageLimitInterval = {
   Day: "day",
   Week: "week",
@@ -6694,15 +7876,18 @@ var GetCustomerAutoTopup$inboundSchema = z31.pipe(
     });
   })
 );
+var GetCustomerLimitType$inboundSchema = inboundSchema(GetCustomerLimitType);
 var GetCustomerSpendLimit$inboundSchema = z31.pipe(
   z31.object({
     feature_id: optional3(string4()),
     enabled: z31._default(boolean2(), false),
+    limit_type: optional3(GetCustomerLimitType$inboundSchema),
     overage_limit: optional3(number2())
   }),
   z31.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
+      "limit_type": "limitType",
       "overage_limit": "overageLimit"
     });
   })
@@ -6711,6 +7896,7 @@ var GetCustomerUsageLimitInterval$inboundSchema = inboundSchema(GetCustomerUsage
 var GetCustomerUsageLimit$inboundSchema = z31.pipe(
   z31.object({
     feature_id: string4(),
+    enabled: z31._default(boolean2(), true),
     limit: number2(),
     interval: GetCustomerUsageLimitInterval$inboundSchema,
     usage: optional3(number2())
@@ -7123,6 +8309,10 @@ var GetEntityType = {
   CreditSystem: "credit_system",
   AiCreditSystem: "ai_credit_system"
 };
+var GetEntityLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var GetEntityInterval = {
   Day: "day",
   Week: "week",
@@ -7288,15 +8478,18 @@ var GetEntityFlags$inboundSchema = z32.pipe(
     });
   })
 );
+var GetEntityLimitType$inboundSchema = inboundSchema(GetEntityLimitType);
 var GetEntitySpendLimit$inboundSchema = z32.pipe(
   z32.object({
     feature_id: optional3(string4()),
     enabled: z32._default(boolean2(), false),
+    limit_type: optional3(GetEntityLimitType$inboundSchema),
     overage_limit: optional3(number2())
   }),
   z32.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
+      "limit_type": "limitType",
       "overage_limit": "overageLimit"
     });
   })
@@ -7305,6 +8498,7 @@ var GetEntityInterval$inboundSchema = inboundSchema(GetEntityInterval);
 var GetEntityUsageLimit$inboundSchema = z32.pipe(
   z32.object({
     feature_id: string4(),
+    enabled: z32._default(boolean2(), true),
     limit: number2(),
     interval: GetEntityInterval$inboundSchema,
     usage: optional3(number2())
@@ -7511,6 +8705,10 @@ var GetOrCreateCustomerPurchaseLimitInterval = {
   Week: "week",
   Month: "month"
 };
+var GetOrCreateCustomerLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var GetOrCreateCustomerUsageLimitInterval = {
   Day: "day",
   Week: "week",
@@ -7557,15 +8755,18 @@ var GetOrCreateCustomerAutoTopup$outboundSchema = z34.pipe(
     });
   })
 );
+var GetOrCreateCustomerLimitType$outboundSchema = z34.enum(GetOrCreateCustomerLimitType);
 var GetOrCreateCustomerSpendLimit$outboundSchema = z34.pipe(
   z34.object({
     featureId: z34.optional(z34.string()),
     enabled: z34._default(z34.boolean(), false),
+    limitType: z34.optional(GetOrCreateCustomerLimitType$outboundSchema),
     overageLimit: z34.optional(z34.number())
   }),
   z34.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
+      limitType: "limit_type",
       overageLimit: "overage_limit"
     });
   })
@@ -7576,6 +8777,7 @@ var GetOrCreateCustomerUsageLimitInterval$outboundSchema = z34.enum(
 var GetOrCreateCustomerUsageLimit$outboundSchema = z34.pipe(
   z34.object({
     featureId: z34.string(),
+    enabled: z34._default(z34.boolean(), true),
     limit: z34.number(),
     interval: GetOrCreateCustomerUsageLimitInterval$outboundSchema
   }),
@@ -7741,6 +8943,28 @@ var GetPlanEnv = {
   Sandbox: "sandbox",
   Live: "live"
 };
+var GetPlanPurchaseLimitInterval = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var GetPlanLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var GetPlanUsageLimitInterval = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var GetPlanThresholdType = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var GetPlanStatus = {
   Active: "active",
   Scheduled: "scheduled"
@@ -7937,14 +9161,131 @@ var GetPlanFreeTrial$inboundSchema = z35.pipe(
     });
   })
 );
-var GetPlanEnv$inboundSchema = inboundSchema(GetPlanEnv);
-var GetPlanConfig$inboundSchema = z35.pipe(
+var GetPlanEnv$inboundSchema = inboundSchema(GetPlanEnv);
+var GetPlanConfig$inboundSchema = z35.pipe(
+  z35.object({
+    ignore_past_due: z35._default(boolean2(), false)
+  }),
+  z35.transform((v) => {
+    return remap(v, {
+      "ignore_past_due": "ignorePastDue"
+    });
+  })
+);
+var GetPlanPurchaseLimitInterval$inboundSchema = inboundSchema(GetPlanPurchaseLimitInterval);
+var GetPlanPurchaseLimit$inboundSchema = z35.pipe(
+  z35.object({
+    interval: GetPlanPurchaseLimitInterval$inboundSchema,
+    interval_count: z35._default(number2(), 1),
+    limit: number2()
+  }),
+  z35.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var GetPlanAutoTopup$inboundSchema = z35.pipe(
+  z35.object({
+    feature_id: string4(),
+    enabled: z35._default(boolean2(), false),
+    threshold: number2(),
+    quantity: number2(),
+    purchase_limit: optional3(
+      z35.lazy(() => GetPlanPurchaseLimit$inboundSchema)
+    ),
+    invoice_mode: optional3(boolean2())
+  }),
+  z35.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "purchase_limit": "purchaseLimit",
+      "invoice_mode": "invoiceMode"
+    });
+  })
+);
+var GetPlanLimitType$inboundSchema = inboundSchema(GetPlanLimitType);
+var GetPlanSpendLimit$inboundSchema = z35.pipe(
+  z35.object({
+    feature_id: optional3(string4()),
+    enabled: z35._default(boolean2(), false),
+    limit_type: optional3(GetPlanLimitType$inboundSchema),
+    overage_limit: optional3(number2())
+  }),
+  z35.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "limit_type": "limitType",
+      "overage_limit": "overageLimit"
+    });
+  })
+);
+var GetPlanUsageLimitInterval$inboundSchema = inboundSchema(GetPlanUsageLimitInterval);
+var GetPlanUsageLimit$inboundSchema = z35.pipe(
+  z35.object({
+    feature_id: string4(),
+    enabled: z35._default(boolean2(), true),
+    limit: number2(),
+    interval: GetPlanUsageLimitInterval$inboundSchema
+  }),
+  z35.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var GetPlanThresholdType$inboundSchema = inboundSchema(GetPlanThresholdType);
+var GetPlanUsageAlert$inboundSchema = z35.pipe(
+  z35.object({
+    feature_id: optional3(string4()),
+    enabled: z35._default(boolean2(), true),
+    threshold: number2(),
+    threshold_type: GetPlanThresholdType$inboundSchema,
+    name: optional3(string4())
+  }),
+  z35.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "threshold_type": "thresholdType"
+    });
+  })
+);
+var GetPlanOverageAllowed$inboundSchema = z35.pipe(
+  z35.object({
+    feature_id: string4(),
+    enabled: z35._default(boolean2(), false)
+  }),
+  z35.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var GetPlanBillingControls$inboundSchema = z35.pipe(
   z35.object({
-    ignore_past_due: z35._default(boolean2(), false)
+    auto_topups: optional3(
+      z35.array(z35.lazy(() => GetPlanAutoTopup$inboundSchema))
+    ),
+    spend_limits: optional3(
+      z35.array(z35.lazy(() => GetPlanSpendLimit$inboundSchema))
+    ),
+    usage_limits: optional3(
+      z35.array(z35.lazy(() => GetPlanUsageLimit$inboundSchema))
+    ),
+    usage_alerts: optional3(
+      z35.array(z35.lazy(() => GetPlanUsageAlert$inboundSchema))
+    ),
+    overage_allowed: optional3(
+      z35.array(z35.lazy(() => GetPlanOverageAllowed$inboundSchema))
+    )
   }),
   z35.transform((v) => {
     return remap(v, {
-      "ignore_past_due": "ignorePastDue"
+      "auto_topups": "autoTopups",
+      "spend_limits": "spendLimits",
+      "usage_limits": "usageLimits",
+      "usage_alerts": "usageAlerts",
+      "overage_allowed": "overageAllowed"
     });
   })
 );
@@ -7982,6 +9323,9 @@ var GetPlanResponse$inboundSchema = z35.pipe(
     archived: boolean2(),
     base_variant_id: nullable(string4()),
     config: z35.lazy(() => GetPlanConfig$inboundSchema),
+    billing_controls: optional3(
+      z35.lazy(() => GetPlanBillingControls$inboundSchema)
+    ),
     metadata: z35.record(z35.string(), z35.any()),
     customer_eligibility: optional3(
       z35.lazy(() => GetPlanCustomerEligibility$inboundSchema)
@@ -7994,6 +9338,7 @@ var GetPlanResponse$inboundSchema = z35.pipe(
       "free_trial": "freeTrial",
       "created_at": "createdAt",
       "base_variant_id": "baseVariantId",
+      "billing_controls": "billingControls",
       "customer_eligibility": "customerEligibility"
     });
   })
@@ -8155,6 +9500,10 @@ var ListCustomersPurchaseLimitInterval1 = {
   Week: "week",
   Month: "month"
 };
+var ListCustomersLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var ListCustomersUsageLimitInterval = {
   Day: "day",
   Week: "week",
@@ -8263,15 +9612,18 @@ var ListCustomersAutoTopup$inboundSchema = z38.pipe(
     });
   })
 );
+var ListCustomersLimitType$inboundSchema = inboundSchema(ListCustomersLimitType);
 var ListCustomersSpendLimit$inboundSchema = z38.pipe(
   z38.object({
     feature_id: optional3(string4()),
     enabled: z38._default(boolean2(), false),
+    limit_type: optional3(ListCustomersLimitType$inboundSchema),
     overage_limit: optional3(number2())
   }),
   z38.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
+      "limit_type": "limitType",
       "overage_limit": "overageLimit"
     });
   })
@@ -8280,6 +9632,7 @@ var ListCustomersUsageLimitInterval$inboundSchema = inboundSchema(ListCustomersU
 var ListCustomersUsageLimit$inboundSchema = z38.pipe(
   z38.object({
     feature_id: string4(),
+    enabled: z38._default(boolean2(), true),
     limit: number2(),
     interval: ListCustomersUsageLimitInterval$inboundSchema,
     usage: optional3(number2())
@@ -8593,6 +9946,10 @@ var ListEntitiesType = {
   CreditSystem: "credit_system",
   AiCreditSystem: "ai_credit_system"
 };
+var ListEntitiesLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var ListEntitiesInterval = {
   Day: "day",
   Week: "week",
@@ -8772,15 +10129,18 @@ var ListEntitiesFlags$inboundSchema = z39.pipe(
     });
   })
 );
+var ListEntitiesLimitType$inboundSchema = inboundSchema(ListEntitiesLimitType);
 var ListEntitiesSpendLimit$inboundSchema = z39.pipe(
   z39.object({
     feature_id: optional3(string4()),
     enabled: z39._default(boolean2(), false),
+    limit_type: optional3(ListEntitiesLimitType$inboundSchema),
     overage_limit: optional3(number2())
   }),
   z39.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
+      "limit_type": "limitType",
       "overage_limit": "overageLimit"
     });
   })
@@ -8789,6 +10149,7 @@ var ListEntitiesInterval$inboundSchema = inboundSchema(ListEntitiesInterval);
 var ListEntitiesUsageLimit$inboundSchema = z39.pipe(
   z39.object({
     feature_id: string4(),
+    enabled: z39._default(boolean2(), true),
     limit: number2(),
     interval: ListEntitiesInterval$inboundSchema,
     usage: optional3(number2())
@@ -9159,6 +10520,28 @@ var ListPlansEnv = {
   Sandbox: "sandbox",
   Live: "live"
 };
+var ListPlansPurchaseLimitInterval = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var ListPlansLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var ListPlansUsageLimitInterval = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var ListPlansThresholdType = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var ListPlansStatus = {
   Active: "active",
   Scheduled: "scheduled"
@@ -9369,6 +10752,123 @@ var ListPlansConfig$inboundSchema = z42.pipe(
     });
   })
 );
+var ListPlansPurchaseLimitInterval$inboundSchema = inboundSchema(ListPlansPurchaseLimitInterval);
+var ListPlansPurchaseLimit$inboundSchema = z42.pipe(
+  z42.object({
+    interval: ListPlansPurchaseLimitInterval$inboundSchema,
+    interval_count: z42._default(number2(), 1),
+    limit: number2()
+  }),
+  z42.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var ListPlansAutoTopup$inboundSchema = z42.pipe(
+  z42.object({
+    feature_id: string4(),
+    enabled: z42._default(boolean2(), false),
+    threshold: number2(),
+    quantity: number2(),
+    purchase_limit: optional3(
+      z42.lazy(() => ListPlansPurchaseLimit$inboundSchema)
+    ),
+    invoice_mode: optional3(boolean2())
+  }),
+  z42.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "purchase_limit": "purchaseLimit",
+      "invoice_mode": "invoiceMode"
+    });
+  })
+);
+var ListPlansLimitType$inboundSchema = inboundSchema(ListPlansLimitType);
+var ListPlansSpendLimit$inboundSchema = z42.pipe(
+  z42.object({
+    feature_id: optional3(string4()),
+    enabled: z42._default(boolean2(), false),
+    limit_type: optional3(ListPlansLimitType$inboundSchema),
+    overage_limit: optional3(number2())
+  }),
+  z42.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "limit_type": "limitType",
+      "overage_limit": "overageLimit"
+    });
+  })
+);
+var ListPlansUsageLimitInterval$inboundSchema = inboundSchema(ListPlansUsageLimitInterval);
+var ListPlansUsageLimit$inboundSchema = z42.pipe(
+  z42.object({
+    feature_id: string4(),
+    enabled: z42._default(boolean2(), true),
+    limit: number2(),
+    interval: ListPlansUsageLimitInterval$inboundSchema
+  }),
+  z42.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var ListPlansThresholdType$inboundSchema = inboundSchema(ListPlansThresholdType);
+var ListPlansUsageAlert$inboundSchema = z42.pipe(
+  z42.object({
+    feature_id: optional3(string4()),
+    enabled: z42._default(boolean2(), true),
+    threshold: number2(),
+    threshold_type: ListPlansThresholdType$inboundSchema,
+    name: optional3(string4())
+  }),
+  z42.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "threshold_type": "thresholdType"
+    });
+  })
+);
+var ListPlansOverageAllowed$inboundSchema = z42.pipe(
+  z42.object({
+    feature_id: string4(),
+    enabled: z42._default(boolean2(), false)
+  }),
+  z42.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var ListPlansBillingControls$inboundSchema = z42.pipe(
+  z42.object({
+    auto_topups: optional3(
+      z42.array(z42.lazy(() => ListPlansAutoTopup$inboundSchema))
+    ),
+    spend_limits: optional3(
+      z42.array(z42.lazy(() => ListPlansSpendLimit$inboundSchema))
+    ),
+    usage_limits: optional3(
+      z42.array(z42.lazy(() => ListPlansUsageLimit$inboundSchema))
+    ),
+    usage_alerts: optional3(
+      z42.array(z42.lazy(() => ListPlansUsageAlert$inboundSchema))
+    ),
+    overage_allowed: optional3(
+      z42.array(z42.lazy(() => ListPlansOverageAllowed$inboundSchema))
+    )
+  }),
+  z42.transform((v) => {
+    return remap(v, {
+      "auto_topups": "autoTopups",
+      "spend_limits": "spendLimits",
+      "usage_limits": "usageLimits",
+      "usage_alerts": "usageAlerts",
+      "overage_allowed": "overageAllowed"
+    });
+  })
+);
 var ListPlansStatus$inboundSchema = inboundSchema(ListPlansStatus);
 var ListPlansAttachAction$inboundSchema = inboundSchema(ListPlansAttachAction);
 var ListPlansCustomerEligibility$inboundSchema = z42.pipe(
@@ -9403,6 +10903,9 @@ var ListPlansList$inboundSchema = z42.pipe(
     archived: boolean2(),
     base_variant_id: nullable(string4()),
     config: z42.lazy(() => ListPlansConfig$inboundSchema),
+    billing_controls: optional3(
+      z42.lazy(() => ListPlansBillingControls$inboundSchema)
+    ),
     metadata: z42.record(z42.string(), z42.any()),
     customer_eligibility: optional3(
       z42.lazy(() => ListPlansCustomerEligibility$inboundSchema)
@@ -9415,6 +10918,7 @@ var ListPlansList$inboundSchema = z42.pipe(
       "free_trial": "freeTrial",
       "created_at": "createdAt",
       "base_variant_id": "baseVariantId",
+      "billing_controls": "billingControls",
       "customer_eligibility": "customerEligibility"
     });
   })
@@ -9521,6 +11025,10 @@ var MultiAttachRedirectMode = {
   IfRequired: "if_required",
   Never: "never"
 };
+var MultiAttachLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var MultiAttachEntityDataInterval = {
   Day: "day",
   Week: "week",
@@ -9729,15 +11237,18 @@ var MultiAttachAttachDiscount$outboundSchema = z44.pipe(
   })
 );
 var MultiAttachRedirectMode$outboundSchema = z44.enum(MultiAttachRedirectMode);
+var MultiAttachLimitType$outboundSchema = z44.enum(MultiAttachLimitType);
 var MultiAttachSpendLimit$outboundSchema = z44.pipe(
   z44.object({
     featureId: z44.optional(z44.string()),
     enabled: z44._default(z44.boolean(), false),
+    limitType: z44.optional(MultiAttachLimitType$outboundSchema),
     overageLimit: z44.optional(z44.number())
   }),
   z44.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
+      limitType: "limit_type",
       overageLimit: "overage_limit"
     });
   })
@@ -9746,6 +11257,7 @@ var MultiAttachEntityDataInterval$outboundSchema = z44.enum(MultiAttachEntityDat
 var MultiAttachUsageLimit$outboundSchema = z44.pipe(
   z44.object({
     featureId: z44.string(),
+    enabled: z44._default(z44.boolean(), true),
     limit: z44.number(),
     interval: MultiAttachEntityDataInterval$outboundSchema
   }),
@@ -10060,6 +11572,28 @@ var PreviewAttachOnEnd = {
   Bill: "bill",
   Revert: "revert"
 };
+var PreviewAttachPurchaseLimitInterval = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var PreviewAttachLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var PreviewAttachUsageLimitInterval = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var PreviewAttachThresholdType = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var PreviewAttachProrationBehavior = {
   ProrateImmediately: "prorate_immediately",
   None: "none"
@@ -10275,34 +11809,143 @@ var PreviewAttachAddItemProration$outboundSchema = z46.pipe(
 var PreviewAttachAddItemExpiryDurationType$outboundSchema = z46.enum(
   PreviewAttachAddItemExpiryDurationType
 );
-var PreviewAttachAddItemRollover$outboundSchema = z46.pipe(
+var PreviewAttachAddItemRollover$outboundSchema = z46.pipe(
+  z46.object({
+    max: z46.optional(z46.number()),
+    maxPercentage: z46.optional(z46.number()),
+    expiryDurationType: PreviewAttachAddItemExpiryDurationType$outboundSchema,
+    expiryDurationLength: z46.optional(z46.number())
+  }),
+  z46.transform((v) => {
+    return remap(v, {
+      maxPercentage: "max_percentage",
+      expiryDurationType: "expiry_duration_type",
+      expiryDurationLength: "expiry_duration_length"
+    });
+  })
+);
+var PreviewAttachAddItemPlanItem$outboundSchema = z46.pipe(
+  z46.object({
+    featureId: z46.string(),
+    included: z46.optional(z46.number()),
+    unlimited: z46.optional(z46.boolean()),
+    reset: z46.optional(z46.lazy(() => PreviewAttachAddItemReset$outboundSchema)),
+    price: z46.optional(z46.lazy(() => PreviewAttachAddItemPrice$outboundSchema)),
+    proration: z46.optional(
+      z46.lazy(() => PreviewAttachAddItemProration$outboundSchema)
+    ),
+    rollover: z46.optional(
+      z46.lazy(() => PreviewAttachAddItemRollover$outboundSchema)
+    )
+  }),
+  z46.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var PreviewAttachRemoveItemBillingMethod$outboundSchema = z46.enum(PreviewAttachRemoveItemBillingMethod);
+var PreviewAttachIntervalRemoveItemEnum2$outboundSchema = z46.enum(PreviewAttachIntervalRemoveItemEnum2);
+var PreviewAttachIntervalRemoveItemEnum1$outboundSchema = z46.enum(PreviewAttachIntervalRemoveItemEnum1);
+var PreviewAttachIntervalUnion$outboundSchema = smartUnion([
+  PreviewAttachIntervalRemoveItemEnum1$outboundSchema,
+  PreviewAttachIntervalRemoveItemEnum2$outboundSchema
+]);
+var PreviewAttachPlanItemFilter$outboundSchema = z46.pipe(
+  z46.object({
+    featureId: z46.optional(z46.string()),
+    billingMethod: z46.optional(
+      PreviewAttachRemoveItemBillingMethod$outboundSchema
+    ),
+    interval: z46.optional(
+      smartUnion([
+        PreviewAttachIntervalRemoveItemEnum1$outboundSchema,
+        PreviewAttachIntervalRemoveItemEnum2$outboundSchema
+      ])
+    ),
+    intervalCount: z46.optional(z46.int())
+  }),
+  z46.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      billingMethod: "billing_method",
+      intervalCount: "interval_count"
+    });
+  })
+);
+var PreviewAttachDurationType$outboundSchema = z46.enum(PreviewAttachDurationType);
+var PreviewAttachOnEnd$outboundSchema = z46.enum(PreviewAttachOnEnd);
+var PreviewAttachFreeTrialParams$outboundSchema = z46.pipe(
+  z46.object({
+    durationLength: z46.number(),
+    durationType: z46._default(PreviewAttachDurationType$outboundSchema, "month"),
+    cardRequired: z46._default(z46.boolean(), true),
+    onEnd: z46.optional(PreviewAttachOnEnd$outboundSchema)
+  }),
+  z46.transform((v) => {
+    return remap(v, {
+      durationLength: "duration_length",
+      durationType: "duration_type",
+      cardRequired: "card_required",
+      onEnd: "on_end"
+    });
+  })
+);
+var PreviewAttachPurchaseLimitInterval$outboundSchema = z46.enum(PreviewAttachPurchaseLimitInterval);
+var PreviewAttachPurchaseLimit$outboundSchema = z46.pipe(
+  z46.object({
+    interval: PreviewAttachPurchaseLimitInterval$outboundSchema,
+    intervalCount: z46._default(z46.number(), 1),
+    limit: z46.number()
+  }),
+  z46.transform((v) => {
+    return remap(v, {
+      intervalCount: "interval_count"
+    });
+  })
+);
+var PreviewAttachAutoTopup$outboundSchema = z46.pipe(
+  z46.object({
+    featureId: z46.string(),
+    enabled: z46._default(z46.boolean(), false),
+    threshold: z46.number(),
+    quantity: z46.number(),
+    purchaseLimit: z46.optional(
+      z46.lazy(() => PreviewAttachPurchaseLimit$outboundSchema)
+    ),
+    invoiceMode: z46.optional(z46.boolean())
+  }),
+  z46.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      purchaseLimit: "purchase_limit",
+      invoiceMode: "invoice_mode"
+    });
+  })
+);
+var PreviewAttachLimitType$outboundSchema = z46.enum(PreviewAttachLimitType);
+var PreviewAttachSpendLimit$outboundSchema = z46.pipe(
   z46.object({
-    max: z46.optional(z46.number()),
-    maxPercentage: z46.optional(z46.number()),
-    expiryDurationType: PreviewAttachAddItemExpiryDurationType$outboundSchema,
-    expiryDurationLength: z46.optional(z46.number())
+    featureId: z46.optional(z46.string()),
+    enabled: z46._default(z46.boolean(), false),
+    limitType: z46.optional(PreviewAttachLimitType$outboundSchema),
+    overageLimit: z46.optional(z46.number())
   }),
   z46.transform((v) => {
     return remap(v, {
-      maxPercentage: "max_percentage",
-      expiryDurationType: "expiry_duration_type",
-      expiryDurationLength: "expiry_duration_length"
+      featureId: "feature_id",
+      limitType: "limit_type",
+      overageLimit: "overage_limit"
     });
   })
 );
-var PreviewAttachAddItemPlanItem$outboundSchema = z46.pipe(
+var PreviewAttachUsageLimitInterval$outboundSchema = z46.enum(PreviewAttachUsageLimitInterval);
+var PreviewAttachUsageLimit$outboundSchema = z46.pipe(
   z46.object({
     featureId: z46.string(),
-    included: z46.optional(z46.number()),
-    unlimited: z46.optional(z46.boolean()),
-    reset: z46.optional(z46.lazy(() => PreviewAttachAddItemReset$outboundSchema)),
-    price: z46.optional(z46.lazy(() => PreviewAttachAddItemPrice$outboundSchema)),
-    proration: z46.optional(
-      z46.lazy(() => PreviewAttachAddItemProration$outboundSchema)
-    ),
-    rollover: z46.optional(
-      z46.lazy(() => PreviewAttachAddItemRollover$outboundSchema)
-    )
+    enabled: z46._default(z46.boolean(), true),
+    limit: z46.number(),
+    interval: PreviewAttachUsageLimitInterval$outboundSchema
   }),
   z46.transform((v) => {
     return remap(v, {
@@ -10310,50 +11953,58 @@ var PreviewAttachAddItemPlanItem$outboundSchema = z46.pipe(
     });
   })
 );
-var PreviewAttachRemoveItemBillingMethod$outboundSchema = z46.enum(PreviewAttachRemoveItemBillingMethod);
-var PreviewAttachIntervalRemoveItemEnum2$outboundSchema = z46.enum(PreviewAttachIntervalRemoveItemEnum2);
-var PreviewAttachIntervalRemoveItemEnum1$outboundSchema = z46.enum(PreviewAttachIntervalRemoveItemEnum1);
-var PreviewAttachIntervalUnion$outboundSchema = smartUnion([
-  PreviewAttachIntervalRemoveItemEnum1$outboundSchema,
-  PreviewAttachIntervalRemoveItemEnum2$outboundSchema
-]);
-var PreviewAttachPlanItemFilter$outboundSchema = z46.pipe(
+var PreviewAttachThresholdType$outboundSchema = z46.enum(PreviewAttachThresholdType);
+var PreviewAttachUsageAlert$outboundSchema = z46.pipe(
   z46.object({
     featureId: z46.optional(z46.string()),
-    billingMethod: z46.optional(
-      PreviewAttachRemoveItemBillingMethod$outboundSchema
-    ),
-    interval: z46.optional(
-      smartUnion([
-        PreviewAttachIntervalRemoveItemEnum1$outboundSchema,
-        PreviewAttachIntervalRemoveItemEnum2$outboundSchema
-      ])
-    ),
-    intervalCount: z46.optional(z46.int())
+    enabled: z46._default(z46.boolean(), true),
+    threshold: z46.number(),
+    thresholdType: PreviewAttachThresholdType$outboundSchema,
+    name: z46.optional(z46.string())
   }),
   z46.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
-      billingMethod: "billing_method",
-      intervalCount: "interval_count"
+      thresholdType: "threshold_type"
     });
   })
 );
-var PreviewAttachDurationType$outboundSchema = z46.enum(PreviewAttachDurationType);
-var PreviewAttachOnEnd$outboundSchema = z46.enum(PreviewAttachOnEnd);
-var PreviewAttachFreeTrialParams$outboundSchema = z46.pipe(
+var PreviewAttachOverageAllowed$outboundSchema = z46.pipe(
   z46.object({
-    durationLength: z46.number(),
-    durationType: z46._default(PreviewAttachDurationType$outboundSchema, "month"),
-    cardRequired: z46._default(z46.boolean(), true),
-    onEnd: z46.optional(PreviewAttachOnEnd$outboundSchema)
+    featureId: z46.string(),
+    enabled: z46._default(z46.boolean(), false)
   }),
   z46.transform((v) => {
     return remap(v, {
-      durationLength: "duration_length",
-      durationType: "duration_type",
-      cardRequired: "card_required",
-      onEnd: "on_end"
+      featureId: "feature_id"
+    });
+  })
+);
+var PreviewAttachBillingControls$outboundSchema = z46.pipe(
+  z46.object({
+    autoTopups: z46.optional(
+      z46.array(z46.lazy(() => PreviewAttachAutoTopup$outboundSchema))
+    ),
+    spendLimits: z46.optional(
+      z46.array(z46.lazy(() => PreviewAttachSpendLimit$outboundSchema))
+    ),
+    usageLimits: z46.optional(
+      z46.array(z46.lazy(() => PreviewAttachUsageLimit$outboundSchema))
+    ),
+    usageAlerts: z46.optional(
+      z46.array(z46.lazy(() => PreviewAttachUsageAlert$outboundSchema))
+    ),
+    overageAllowed: z46.optional(
+      z46.array(z46.lazy(() => PreviewAttachOverageAllowed$outboundSchema))
+    )
+  }),
+  z46.transform((v) => {
+    return remap(v, {
+      autoTopups: "auto_topups",
+      spendLimits: "spend_limits",
+      usageLimits: "usage_limits",
+      usageAlerts: "usage_alerts",
+      overageAllowed: "overage_allowed"
     });
   })
 );
@@ -10373,13 +12024,17 @@ var PreviewAttachCustomize$outboundSchema = z46.pipe(
     ),
     freeTrial: z46.optional(
       z46.nullable(z46.lazy(() => PreviewAttachFreeTrialParams$outboundSchema))
+    ),
+    billingControls: z46.optional(
+      z46.lazy(() => PreviewAttachBillingControls$outboundSchema)
     )
   }),
   z46.transform((v) => {
     return remap(v, {
       addItems: "add_items",
       removeItems: "remove_items",
-      freeTrial: "free_trial"
+      freeTrial: "free_trial",
+      billingControls: "billing_controls"
     });
   })
 );
@@ -10829,6 +12484,10 @@ var PreviewMultiAttachRedirectMode = {
   IfRequired: "if_required",
   Never: "never"
 };
+var PreviewMultiAttachLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var PreviewMultiAttachEntityDataInterval = {
   Day: "day",
   Week: "week",
@@ -11055,15 +12714,18 @@ var PreviewMultiAttachAttachDiscount$outboundSchema = z47.pipe(
   })
 );
 var PreviewMultiAttachRedirectMode$outboundSchema = z47.enum(PreviewMultiAttachRedirectMode);
+var PreviewMultiAttachLimitType$outboundSchema = z47.enum(PreviewMultiAttachLimitType);
 var PreviewMultiAttachSpendLimit$outboundSchema = z47.pipe(
   z47.object({
     featureId: z47.optional(z47.string()),
     enabled: z47._default(z47.boolean(), false),
+    limitType: z47.optional(PreviewMultiAttachLimitType$outboundSchema),
     overageLimit: z47.optional(z47.number())
   }),
   z47.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
+      limitType: "limit_type",
       overageLimit: "overage_limit"
     });
   })
@@ -11072,6 +12734,7 @@ var PreviewMultiAttachEntityDataInterval$outboundSchema = z47.enum(PreviewMultiA
 var PreviewMultiAttachUsageLimit$outboundSchema = z47.pipe(
   z47.object({
     featureId: z47.string(),
+    enabled: z47._default(z47.boolean(), true),
     limit: z47.number(),
     interval: PreviewMultiAttachEntityDataInterval$outboundSchema
   }),
@@ -11568,6 +13231,28 @@ var PreviewUpdateOnEnd = {
   Bill: "bill",
   Revert: "revert"
 };
+var PreviewUpdatePurchaseLimitInterval = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var PreviewUpdateLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var PreviewUpdateUsageLimitInterval = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var PreviewUpdateThresholdType = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var PreviewUpdateProrationBehavior = {
   ProrateImmediately: "prorate_immediately",
   None: "none"
@@ -11870,6 +13555,123 @@ var PreviewUpdateFreeTrialParams$outboundSchema = z48.pipe(
     });
   })
 );
+var PreviewUpdatePurchaseLimitInterval$outboundSchema = z48.enum(PreviewUpdatePurchaseLimitInterval);
+var PreviewUpdatePurchaseLimit$outboundSchema = z48.pipe(
+  z48.object({
+    interval: PreviewUpdatePurchaseLimitInterval$outboundSchema,
+    intervalCount: z48._default(z48.number(), 1),
+    limit: z48.number()
+  }),
+  z48.transform((v) => {
+    return remap(v, {
+      intervalCount: "interval_count"
+    });
+  })
+);
+var PreviewUpdateAutoTopup$outboundSchema = z48.pipe(
+  z48.object({
+    featureId: z48.string(),
+    enabled: z48._default(z48.boolean(), false),
+    threshold: z48.number(),
+    quantity: z48.number(),
+    purchaseLimit: z48.optional(
+      z48.lazy(() => PreviewUpdatePurchaseLimit$outboundSchema)
+    ),
+    invoiceMode: z48.optional(z48.boolean())
+  }),
+  z48.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      purchaseLimit: "purchase_limit",
+      invoiceMode: "invoice_mode"
+    });
+  })
+);
+var PreviewUpdateLimitType$outboundSchema = z48.enum(PreviewUpdateLimitType);
+var PreviewUpdateSpendLimit$outboundSchema = z48.pipe(
+  z48.object({
+    featureId: z48.optional(z48.string()),
+    enabled: z48._default(z48.boolean(), false),
+    limitType: z48.optional(PreviewUpdateLimitType$outboundSchema),
+    overageLimit: z48.optional(z48.number())
+  }),
+  z48.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      limitType: "limit_type",
+      overageLimit: "overage_limit"
+    });
+  })
+);
+var PreviewUpdateUsageLimitInterval$outboundSchema = z48.enum(PreviewUpdateUsageLimitInterval);
+var PreviewUpdateUsageLimit$outboundSchema = z48.pipe(
+  z48.object({
+    featureId: z48.string(),
+    enabled: z48._default(z48.boolean(), true),
+    limit: z48.number(),
+    interval: PreviewUpdateUsageLimitInterval$outboundSchema
+  }),
+  z48.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var PreviewUpdateThresholdType$outboundSchema = z48.enum(PreviewUpdateThresholdType);
+var PreviewUpdateUsageAlert$outboundSchema = z48.pipe(
+  z48.object({
+    featureId: z48.optional(z48.string()),
+    enabled: z48._default(z48.boolean(), true),
+    threshold: z48.number(),
+    thresholdType: PreviewUpdateThresholdType$outboundSchema,
+    name: z48.optional(z48.string())
+  }),
+  z48.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      thresholdType: "threshold_type"
+    });
+  })
+);
+var PreviewUpdateOverageAllowed$outboundSchema = z48.pipe(
+  z48.object({
+    featureId: z48.string(),
+    enabled: z48._default(z48.boolean(), false)
+  }),
+  z48.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var PreviewUpdateBillingControls$outboundSchema = z48.pipe(
+  z48.object({
+    autoTopups: z48.optional(
+      z48.array(z48.lazy(() => PreviewUpdateAutoTopup$outboundSchema))
+    ),
+    spendLimits: z48.optional(
+      z48.array(z48.lazy(() => PreviewUpdateSpendLimit$outboundSchema))
+    ),
+    usageLimits: z48.optional(
+      z48.array(z48.lazy(() => PreviewUpdateUsageLimit$outboundSchema))
+    ),
+    usageAlerts: z48.optional(
+      z48.array(z48.lazy(() => PreviewUpdateUsageAlert$outboundSchema))
+    ),
+    overageAllowed: z48.optional(
+      z48.array(z48.lazy(() => PreviewUpdateOverageAllowed$outboundSchema))
+    )
+  }),
+  z48.transform((v) => {
+    return remap(v, {
+      autoTopups: "auto_topups",
+      spendLimits: "spend_limits",
+      usageLimits: "usage_limits",
+      usageAlerts: "usage_alerts",
+      overageAllowed: "overage_allowed"
+    });
+  })
+);
 var PreviewUpdateCustomize$outboundSchema = z48.pipe(
   z48.object({
     price: z48.optional(
@@ -11886,13 +13688,17 @@ var PreviewUpdateCustomize$outboundSchema = z48.pipe(
     ),
     freeTrial: z48.optional(
       z48.nullable(z48.lazy(() => PreviewUpdateFreeTrialParams$outboundSchema))
+    ),
+    billingControls: z48.optional(
+      z48.lazy(() => PreviewUpdateBillingControls$outboundSchema)
     )
   }),
   z48.transform((v) => {
     return remap(v, {
       addItems: "add_items",
       removeItems: "remove_items",
-      freeTrial: "free_trial"
+      freeTrial: "free_trial",
+      billingControls: "billing_controls"
     });
   })
 );
@@ -12468,6 +14274,28 @@ var SetupPaymentOnEnd = {
   Bill: "bill",
   Revert: "revert"
 };
+var SetupPaymentPurchaseLimitInterval = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var SetupPaymentLimitType = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var SetupPaymentUsageLimitInterval = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var SetupPaymentThresholdType = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var SetupPaymentProrationBehavior = {
   ProrateImmediately: "prorate_immediately",
   None: "none"
@@ -12723,26 +14551,143 @@ var SetupPaymentPlanItemFilter$outboundSchema = z53.pipe(
   z53.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
-      billingMethod: "billing_method",
-      intervalCount: "interval_count"
+      billingMethod: "billing_method",
+      intervalCount: "interval_count"
+    });
+  })
+);
+var SetupPaymentDurationType$outboundSchema = z53.enum(SetupPaymentDurationType);
+var SetupPaymentOnEnd$outboundSchema = z53.enum(SetupPaymentOnEnd);
+var SetupPaymentFreeTrialParams$outboundSchema = z53.pipe(
+  z53.object({
+    durationLength: z53.number(),
+    durationType: z53._default(SetupPaymentDurationType$outboundSchema, "month"),
+    cardRequired: z53._default(z53.boolean(), true),
+    onEnd: z53.optional(SetupPaymentOnEnd$outboundSchema)
+  }),
+  z53.transform((v) => {
+    return remap(v, {
+      durationLength: "duration_length",
+      durationType: "duration_type",
+      cardRequired: "card_required",
+      onEnd: "on_end"
+    });
+  })
+);
+var SetupPaymentPurchaseLimitInterval$outboundSchema = z53.enum(SetupPaymentPurchaseLimitInterval);
+var SetupPaymentPurchaseLimit$outboundSchema = z53.pipe(
+  z53.object({
+    interval: SetupPaymentPurchaseLimitInterval$outboundSchema,
+    intervalCount: z53._default(z53.number(), 1),
+    limit: z53.number()
+  }),
+  z53.transform((v) => {
+    return remap(v, {
+      intervalCount: "interval_count"
+    });
+  })
+);
+var SetupPaymentAutoTopup$outboundSchema = z53.pipe(
+  z53.object({
+    featureId: z53.string(),
+    enabled: z53._default(z53.boolean(), false),
+    threshold: z53.number(),
+    quantity: z53.number(),
+    purchaseLimit: z53.optional(
+      z53.lazy(() => SetupPaymentPurchaseLimit$outboundSchema)
+    ),
+    invoiceMode: z53.optional(z53.boolean())
+  }),
+  z53.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      purchaseLimit: "purchase_limit",
+      invoiceMode: "invoice_mode"
+    });
+  })
+);
+var SetupPaymentLimitType$outboundSchema = z53.enum(SetupPaymentLimitType);
+var SetupPaymentSpendLimit$outboundSchema = z53.pipe(
+  z53.object({
+    featureId: z53.optional(z53.string()),
+    enabled: z53._default(z53.boolean(), false),
+    limitType: z53.optional(SetupPaymentLimitType$outboundSchema),
+    overageLimit: z53.optional(z53.number())
+  }),
+  z53.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      limitType: "limit_type",
+      overageLimit: "overage_limit"
+    });
+  })
+);
+var SetupPaymentUsageLimitInterval$outboundSchema = z53.enum(SetupPaymentUsageLimitInterval);
+var SetupPaymentUsageLimit$outboundSchema = z53.pipe(
+  z53.object({
+    featureId: z53.string(),
+    enabled: z53._default(z53.boolean(), true),
+    limit: z53.number(),
+    interval: SetupPaymentUsageLimitInterval$outboundSchema
+  }),
+  z53.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var SetupPaymentThresholdType$outboundSchema = z53.enum(SetupPaymentThresholdType);
+var SetupPaymentUsageAlert$outboundSchema = z53.pipe(
+  z53.object({
+    featureId: z53.optional(z53.string()),
+    enabled: z53._default(z53.boolean(), true),
+    threshold: z53.number(),
+    thresholdType: SetupPaymentThresholdType$outboundSchema,
+    name: z53.optional(z53.string())
+  }),
+  z53.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      thresholdType: "threshold_type"
     });
   })
 );
-var SetupPaymentDurationType$outboundSchema = z53.enum(SetupPaymentDurationType);
-var SetupPaymentOnEnd$outboundSchema = z53.enum(SetupPaymentOnEnd);
-var SetupPaymentFreeTrialParams$outboundSchema = z53.pipe(
+var SetupPaymentOverageAllowed$outboundSchema = z53.pipe(
   z53.object({
-    durationLength: z53.number(),
-    durationType: z53._default(SetupPaymentDurationType$outboundSchema, "month"),
-    cardRequired: z53._default(z53.boolean(), true),
-    onEnd: z53.optional(SetupPaymentOnEnd$outboundSchema)
+    featureId: z53.string(),
+    enabled: z53._default(z53.boolean(), false)
   }),
   z53.transform((v) => {
     return remap(v, {
-      durationLength: "duration_length",
-      durationType: "duration_type",
-      cardRequired: "card_required",
-      onEnd: "on_end"
+      featureId: "feature_id"
+    });
+  })
+);
+var SetupPaymentBillingControls$outboundSchema = z53.pipe(
+  z53.object({
+    autoTopups: z53.optional(
+      z53.array(z53.lazy(() => SetupPaymentAutoTopup$outboundSchema))
+    ),
+    spendLimits: z53.optional(
+      z53.array(z53.lazy(() => SetupPaymentSpendLimit$outboundSchema))
+    ),
+    usageLimits: z53.optional(
+      z53.array(z53.lazy(() => SetupPaymentUsageLimit$outboundSchema))
+    ),
+    usageAlerts: z53.optional(
+      z53.array(z53.lazy(() => SetupPaymentUsageAlert$outboundSchema))
+    ),
+    overageAllowed: z53.optional(
+      z53.array(z53.lazy(() => SetupPaymentOverageAllowed$outboundSchema))
+    )
+  }),
+  z53.transform((v) => {
+    return remap(v, {
+      autoTopups: "auto_topups",
+      spendLimits: "spend_limits",
+      usageLimits: "usage_limits",
+      usageAlerts: "usage_alerts",
+      overageAllowed: "overage_allowed"
     });
   })
 );
@@ -12762,13 +14707,17 @@ var SetupPaymentCustomize$outboundSchema = z53.pipe(
     ),
     freeTrial: z53.optional(
       z53.nullable(z53.lazy(() => SetupPaymentFreeTrialParams$outboundSchema))
+    ),
+    billingControls: z53.optional(
+      z53.lazy(() => SetupPaymentBillingControls$outboundSchema)
     )
   }),
   z53.transform((v) => {
     return remap(v, {
       addItems: "add_items",
       removeItems: "remove_items",
-      freeTrial: "free_trial"
+      freeTrial: "free_trial",
+      billingControls: "billing_controls"
     });
   })
 );
@@ -13360,6 +15309,10 @@ var UpdateCustomerPurchaseLimitIntervalRequestBody = {
   Week: "week",
   Month: "month"
 };
+var UpdateCustomerLimitTypeRequestBody = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var UpdateCustomerUsageLimitIntervalRequestBody = {
   Day: "day",
   Week: "week",
@@ -13388,6 +15341,10 @@ var UpdateCustomerPurchaseLimitIntervalResponse1 = {
   Week: "week",
   Month: "month"
 };
+var UpdateCustomerLimitTypeResponse = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var UpdateCustomerUsageLimitIntervalResponse = {
   Day: "day",
   Week: "week",
@@ -13452,15 +15409,18 @@ var UpdateCustomerAutoTopupRequest$outboundSchema = z58.pipe(
     });
   })
 );
+var UpdateCustomerLimitTypeRequestBody$outboundSchema = z58.enum(UpdateCustomerLimitTypeRequestBody);
 var UpdateCustomerSpendLimitRequest$outboundSchema = z58.pipe(
   z58.object({
     featureId: z58.optional(z58.string()),
     enabled: z58._default(z58.boolean(), false),
+    limitType: z58.optional(UpdateCustomerLimitTypeRequestBody$outboundSchema),
     overageLimit: z58.optional(z58.number())
   }),
   z58.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
+      limitType: "limit_type",
       overageLimit: "overage_limit"
     });
   })
@@ -13471,6 +15431,7 @@ var UpdateCustomerUsageLimitIntervalRequestBody$outboundSchema = z58.enum(
 var UpdateCustomerUsageLimitRequest$outboundSchema = z58.pipe(
   z58.object({
     featureId: z58.string(),
+    enabled: z58._default(z58.boolean(), true),
     limit: z58.number(),
     interval: UpdateCustomerUsageLimitIntervalRequestBody$outboundSchema
   }),
@@ -13630,15 +15591,18 @@ var UpdateCustomerAutoTopupResponse$inboundSchema = z58.pipe(
     });
   })
 );
+var UpdateCustomerLimitTypeResponse$inboundSchema = inboundSchema(UpdateCustomerLimitTypeResponse);
 var UpdateCustomerSpendLimitResponse$inboundSchema = z58.pipe(
   z58.object({
     feature_id: optional3(string4()),
     enabled: z58._default(boolean2(), false),
+    limit_type: optional3(UpdateCustomerLimitTypeResponse$inboundSchema),
     overage_limit: optional3(number2())
   }),
   z58.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
+      "limit_type": "limitType",
       "overage_limit": "overageLimit"
     });
   })
@@ -13647,6 +15611,7 @@ var UpdateCustomerUsageLimitIntervalResponse$inboundSchema = inboundSchema(Updat
 var UpdateCustomerUsageLimitResponse$inboundSchema = z58.pipe(
   z58.object({
     feature_id: string4(),
+    enabled: z58._default(boolean2(), true),
     limit: number2(),
     interval: UpdateCustomerUsageLimitIntervalResponse$inboundSchema,
     usage: optional3(number2())
@@ -13925,6 +15890,10 @@ var UpdateCustomerResponse$inboundSchema = z58.pipe(
 
 // ../sdk/src/models/update-entity-op.ts
 var z59 = __toESM(require("zod/v4-mini"), 1);
+var UpdateEntityLimitTypeRequestBody = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var UpdateEntityIntervalRequestBody = {
   Day: "day",
   Week: "week",
@@ -13959,6 +15928,10 @@ var UpdateEntityType = {
   CreditSystem: "credit_system",
   AiCreditSystem: "ai_credit_system"
 };
+var UpdateEntityLimitTypeResponse = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
 var UpdateEntityIntervalResponse = {
   Day: "day",
   Week: "week",
@@ -13975,15 +15948,18 @@ var UpdateEntityProcessorType = {
   Stripe: "stripe",
   Revenuecat: "revenuecat"
 };
+var UpdateEntityLimitTypeRequestBody$outboundSchema = z59.enum(UpdateEntityLimitTypeRequestBody);
 var UpdateEntitySpendLimitRequest$outboundSchema = z59.pipe(
   z59.object({
     featureId: z59.optional(z59.string()),
     enabled: z59._default(z59.boolean(), false),
+    limitType: z59.optional(UpdateEntityLimitTypeRequestBody$outboundSchema),
     overageLimit: z59.optional(z59.number())
   }),
   z59.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
+      limitType: "limit_type",
       overageLimit: "overage_limit"
     });
   })
@@ -13992,6 +15968,7 @@ var UpdateEntityIntervalRequestBody$outboundSchema = z59.enum(UpdateEntityInterv
 var UpdateEntityUsageLimitRequest$outboundSchema = z59.pipe(
   z59.object({
     featureId: z59.string(),
+    enabled: z59._default(z59.boolean(), true),
     limit: z59.number(),
     interval: UpdateEntityIntervalRequestBody$outboundSchema
   }),
@@ -14205,15 +16182,18 @@ var UpdateEntityFlags$inboundSchema = z59.pipe(
     });
   })
 );
+var UpdateEntityLimitTypeResponse$inboundSchema = inboundSchema(UpdateEntityLimitTypeResponse);
 var UpdateEntitySpendLimitResponse$inboundSchema = z59.pipe(
   z59.object({
     feature_id: optional3(string4()),
     enabled: z59._default(boolean2(), false),
+    limit_type: optional3(UpdateEntityLimitTypeResponse$inboundSchema),
     overage_limit: optional3(number2())
   }),
   z59.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
+      "limit_type": "limitType",
       "overage_limit": "overageLimit"
     });
   })
@@ -14222,6 +16202,7 @@ var UpdateEntityIntervalResponse$inboundSchema = inboundSchema(UpdateEntityInter
 var UpdateEntityUsageLimitResponse$inboundSchema = z59.pipe(
   z59.object({
     feature_id: string4(),
+    enabled: z59._default(boolean2(), true),
     limit: number2(),
     interval: UpdateEntityIntervalResponse$inboundSchema,
     usage: optional3(number2())
@@ -14560,6 +16541,28 @@ var UpdatePlanOnEndRequest = {
   Bill: "bill",
   Revert: "revert"
 };
+var UpdatePlanPurchaseLimitIntervalRequestBody = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var UpdatePlanLimitTypeRequestBody = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var UpdatePlanUsageLimitIntervalRequestBody = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var UpdatePlanThresholdTypeRequestBody = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var UpdatePlanPriceIntervalResponse = {
   OneOff: "one_off",
   Week: "week",
@@ -14620,6 +16623,28 @@ var UpdatePlanEnv = {
   Sandbox: "sandbox",
   Live: "live"
 };
+var UpdatePlanPurchaseLimitIntervalResponse = {
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month"
+};
+var UpdatePlanLimitTypeResponse = {
+  Absolute: "absolute",
+  UsagePercentage: "usage_percentage"
+};
+var UpdatePlanUsageLimitIntervalResponse = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var UpdatePlanThresholdTypeResponse = {
+  Usage: "usage",
+  UsagePercentage: "usage_percentage",
+  Remaining: "remaining",
+  RemainingPercentage: "remaining_percentage"
+};
 var UpdatePlanStatus = {
   Active: "active",
   Scheduled: "scheduled"
@@ -14778,6 +16803,127 @@ var UpdatePlanConfigRequest$outboundSchema = z61.pipe(
     });
   })
 );
+var UpdatePlanPurchaseLimitIntervalRequestBody$outboundSchema = z61.enum(
+  UpdatePlanPurchaseLimitIntervalRequestBody
+);
+var UpdatePlanPurchaseLimitRequest$outboundSchema = z61.pipe(
+  z61.object({
+    interval: UpdatePlanPurchaseLimitIntervalRequestBody$outboundSchema,
+    intervalCount: z61._default(z61.number(), 1),
+    limit: z61.number()
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      intervalCount: "interval_count"
+    });
+  })
+);
+var UpdatePlanAutoTopupRequest$outboundSchema = z61.pipe(
+  z61.object({
+    featureId: z61.string(),
+    enabled: z61._default(z61.boolean(), false),
+    threshold: z61.number(),
+    quantity: z61.number(),
+    purchaseLimit: z61.optional(
+      z61.lazy(() => UpdatePlanPurchaseLimitRequest$outboundSchema)
+    ),
+    invoiceMode: z61.optional(z61.boolean())
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      purchaseLimit: "purchase_limit",
+      invoiceMode: "invoice_mode"
+    });
+  })
+);
+var UpdatePlanLimitTypeRequestBody$outboundSchema = z61.enum(UpdatePlanLimitTypeRequestBody);
+var UpdatePlanSpendLimitRequest$outboundSchema = z61.pipe(
+  z61.object({
+    featureId: z61.optional(z61.string()),
+    enabled: z61._default(z61.boolean(), false),
+    limitType: z61.optional(UpdatePlanLimitTypeRequestBody$outboundSchema),
+    overageLimit: z61.optional(z61.number())
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      limitType: "limit_type",
+      overageLimit: "overage_limit"
+    });
+  })
+);
+var UpdatePlanUsageLimitIntervalRequestBody$outboundSchema = z61.enum(
+  UpdatePlanUsageLimitIntervalRequestBody
+);
+var UpdatePlanUsageLimitRequest$outboundSchema = z61.pipe(
+  z61.object({
+    featureId: z61.string(),
+    enabled: z61._default(z61.boolean(), true),
+    limit: z61.number(),
+    interval: UpdatePlanUsageLimitIntervalRequestBody$outboundSchema
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var UpdatePlanThresholdTypeRequestBody$outboundSchema = z61.enum(UpdatePlanThresholdTypeRequestBody);
+var UpdatePlanUsageAlertRequestBody$outboundSchema = z61.pipe(
+  z61.object({
+    featureId: z61.optional(z61.string()),
+    enabled: z61._default(z61.boolean(), true),
+    threshold: z61.number(),
+    thresholdType: UpdatePlanThresholdTypeRequestBody$outboundSchema,
+    name: z61.optional(z61.string())
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id",
+      thresholdType: "threshold_type"
+    });
+  })
+);
+var UpdatePlanOverageAllowedRequest$outboundSchema = z61.pipe(
+  z61.object({
+    featureId: z61.string(),
+    enabled: z61._default(z61.boolean(), false)
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      featureId: "feature_id"
+    });
+  })
+);
+var UpdatePlanBillingControlsRequest$outboundSchema = z61.pipe(
+  z61.object({
+    autoTopups: z61.optional(
+      z61.array(z61.lazy(() => UpdatePlanAutoTopupRequest$outboundSchema))
+    ),
+    spendLimits: z61.optional(
+      z61.array(z61.lazy(() => UpdatePlanSpendLimitRequest$outboundSchema))
+    ),
+    usageLimits: z61.optional(
+      z61.array(z61.lazy(() => UpdatePlanUsageLimitRequest$outboundSchema))
+    ),
+    usageAlerts: z61.optional(
+      z61.array(z61.lazy(() => UpdatePlanUsageAlertRequestBody$outboundSchema))
+    ),
+    overageAllowed: z61.optional(
+      z61.array(z61.lazy(() => UpdatePlanOverageAllowedRequest$outboundSchema))
+    )
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      autoTopups: "auto_topups",
+      spendLimits: "spend_limits",
+      usageLimits: "usage_limits",
+      usageAlerts: "usage_alerts",
+      overageAllowed: "overage_allowed"
+    });
+  })
+);
 var UpdatePlanParams$outboundSchema = z61.pipe(
   z61.object({
     planId: z61.string(),
@@ -14794,6 +16940,9 @@ var UpdatePlanParams$outboundSchema = z61.pipe(
       z61.nullable(z61.lazy(() => UpdatePlanFreeTrialParams$outboundSchema))
     ),
     config: z61.optional(z61.lazy(() => UpdatePlanConfigRequest$outboundSchema)),
+    billingControls: z61.optional(
+      z61.lazy(() => UpdatePlanBillingControlsRequest$outboundSchema)
+    ),
     metadata: z61.optional(z61.record(z61.string(), z61.any())),
     createInStripe: z61._default(z61.boolean(), true),
     version: z61.optional(z61.number()),
@@ -14807,6 +16956,7 @@ var UpdatePlanParams$outboundSchema = z61.pipe(
       addOn: "add_on",
       autoEnable: "auto_enable",
       freeTrial: "free_trial",
+      billingControls: "billing_controls",
       createInStripe: "create_in_stripe",
       newPlanId: "new_plan_id",
       disableVersion: "disable_version"
@@ -14938,69 +17088,186 @@ var UpdatePlanItemDisplay$inboundSchema = z61.pipe(
     });
   })
 );
-var UpdatePlanExpiryDurationTypeResponse$inboundSchema = inboundSchema(UpdatePlanExpiryDurationTypeResponse);
-var UpdatePlanRolloverResponse$inboundSchema = z61.pipe(
+var UpdatePlanExpiryDurationTypeResponse$inboundSchema = inboundSchema(UpdatePlanExpiryDurationTypeResponse);
+var UpdatePlanRolloverResponse$inboundSchema = z61.pipe(
+  z61.object({
+    max: nullable(number2()),
+    max_percentage: z61.optional(z61.nullable(number2())),
+    expiry_duration_type: UpdatePlanExpiryDurationTypeResponse$inboundSchema,
+    expiry_duration_length: optional3(number2())
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      "max_percentage": "maxPercentage",
+      "expiry_duration_type": "expiryDurationType",
+      "expiry_duration_length": "expiryDurationLength"
+    });
+  })
+);
+var UpdatePlanItem$inboundSchema = z61.pipe(
+  z61.object({
+    feature_id: string4(),
+    feature: optional3(z61.lazy(() => UpdatePlanFeature$inboundSchema)),
+    included: number2(),
+    unlimited: boolean2(),
+    reset: nullable(z61.lazy(() => UpdatePlanResetResponse$inboundSchema)),
+    price: nullable(
+      z61.lazy(() => UpdatePlanItemPriceResponse$inboundSchema)
+    ),
+    display: optional3(z61.lazy(() => UpdatePlanItemDisplay$inboundSchema)),
+    rollover: optional3(
+      z61.lazy(() => UpdatePlanRolloverResponse$inboundSchema)
+    )
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId"
+    });
+  })
+);
+var UpdatePlanDurationTypeResponse$inboundSchema = inboundSchema(UpdatePlanDurationTypeResponse);
+var UpdatePlanOnEndResponse$inboundSchema = inboundSchema(UpdatePlanOnEndResponse);
+var UpdatePlanFreeTrial$inboundSchema = z61.pipe(
+  z61.object({
+    duration_length: number2(),
+    duration_type: UpdatePlanDurationTypeResponse$inboundSchema,
+    card_required: boolean2(),
+    on_end: z61.optional(z61.nullable(UpdatePlanOnEndResponse$inboundSchema))
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      "duration_length": "durationLength",
+      "duration_type": "durationType",
+      "card_required": "cardRequired",
+      "on_end": "onEnd"
+    });
+  })
+);
+var UpdatePlanEnv$inboundSchema = inboundSchema(UpdatePlanEnv);
+var UpdatePlanConfigResponse$inboundSchema = z61.pipe(
+  z61.object({
+    ignore_past_due: z61._default(boolean2(), false)
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      "ignore_past_due": "ignorePastDue"
+    });
+  })
+);
+var UpdatePlanPurchaseLimitIntervalResponse$inboundSchema = inboundSchema(UpdatePlanPurchaseLimitIntervalResponse);
+var UpdatePlanPurchaseLimitResponse$inboundSchema = z61.pipe(
+  z61.object({
+    interval: UpdatePlanPurchaseLimitIntervalResponse$inboundSchema,
+    interval_count: z61._default(number2(), 1),
+    limit: number2()
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var UpdatePlanAutoTopupResponse$inboundSchema = z61.pipe(
+  z61.object({
+    feature_id: string4(),
+    enabled: z61._default(boolean2(), false),
+    threshold: number2(),
+    quantity: number2(),
+    purchase_limit: optional3(
+      z61.lazy(() => UpdatePlanPurchaseLimitResponse$inboundSchema)
+    ),
+    invoice_mode: optional3(boolean2())
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "purchase_limit": "purchaseLimit",
+      "invoice_mode": "invoiceMode"
+    });
+  })
+);
+var UpdatePlanLimitTypeResponse$inboundSchema = inboundSchema(UpdatePlanLimitTypeResponse);
+var UpdatePlanSpendLimitResponse$inboundSchema = z61.pipe(
+  z61.object({
+    feature_id: optional3(string4()),
+    enabled: z61._default(boolean2(), false),
+    limit_type: optional3(UpdatePlanLimitTypeResponse$inboundSchema),
+    overage_limit: optional3(number2())
+  }),
+  z61.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "limit_type": "limitType",
+      "overage_limit": "overageLimit"
+    });
+  })
+);
+var UpdatePlanUsageLimitIntervalResponse$inboundSchema = inboundSchema(UpdatePlanUsageLimitIntervalResponse);
+var UpdatePlanUsageLimitResponse$inboundSchema = z61.pipe(
   z61.object({
-    max: nullable(number2()),
-    max_percentage: z61.optional(z61.nullable(number2())),
-    expiry_duration_type: UpdatePlanExpiryDurationTypeResponse$inboundSchema,
-    expiry_duration_length: optional3(number2())
+    feature_id: string4(),
+    enabled: z61._default(boolean2(), true),
+    limit: number2(),
+    interval: UpdatePlanUsageLimitIntervalResponse$inboundSchema
   }),
   z61.transform((v) => {
     return remap(v, {
-      "max_percentage": "maxPercentage",
-      "expiry_duration_type": "expiryDurationType",
-      "expiry_duration_length": "expiryDurationLength"
+      "feature_id": "featureId"
     });
   })
 );
-var UpdatePlanItem$inboundSchema = z61.pipe(
+var UpdatePlanThresholdTypeResponse$inboundSchema = inboundSchema(UpdatePlanThresholdTypeResponse);
+var UpdatePlanUsageAlertResponse$inboundSchema = z61.pipe(
   z61.object({
-    feature_id: string4(),
-    feature: optional3(z61.lazy(() => UpdatePlanFeature$inboundSchema)),
-    included: number2(),
-    unlimited: boolean2(),
-    reset: nullable(z61.lazy(() => UpdatePlanResetResponse$inboundSchema)),
-    price: nullable(
-      z61.lazy(() => UpdatePlanItemPriceResponse$inboundSchema)
-    ),
-    display: optional3(z61.lazy(() => UpdatePlanItemDisplay$inboundSchema)),
-    rollover: optional3(
-      z61.lazy(() => UpdatePlanRolloverResponse$inboundSchema)
-    )
+    feature_id: optional3(string4()),
+    enabled: z61._default(boolean2(), true),
+    threshold: number2(),
+    threshold_type: UpdatePlanThresholdTypeResponse$inboundSchema,
+    name: optional3(string4())
   }),
   z61.transform((v) => {
     return remap(v, {
-      "feature_id": "featureId"
+      "feature_id": "featureId",
+      "threshold_type": "thresholdType"
     });
   })
 );
-var UpdatePlanDurationTypeResponse$inboundSchema = inboundSchema(UpdatePlanDurationTypeResponse);
-var UpdatePlanOnEndResponse$inboundSchema = inboundSchema(UpdatePlanOnEndResponse);
-var UpdatePlanFreeTrial$inboundSchema = z61.pipe(
+var UpdatePlanOverageAllowedResponse$inboundSchema = z61.pipe(
   z61.object({
-    duration_length: number2(),
-    duration_type: UpdatePlanDurationTypeResponse$inboundSchema,
-    card_required: boolean2(),
-    on_end: z61.optional(z61.nullable(UpdatePlanOnEndResponse$inboundSchema))
+    feature_id: string4(),
+    enabled: z61._default(boolean2(), false)
   }),
   z61.transform((v) => {
     return remap(v, {
-      "duration_length": "durationLength",
-      "duration_type": "durationType",
-      "card_required": "cardRequired",
-      "on_end": "onEnd"
+      "feature_id": "featureId"
     });
   })
 );
-var UpdatePlanEnv$inboundSchema = inboundSchema(UpdatePlanEnv);
-var UpdatePlanConfigResponse$inboundSchema = z61.pipe(
+var UpdatePlanBillingControlsResponse$inboundSchema = z61.pipe(
   z61.object({
-    ignore_past_due: z61._default(boolean2(), false)
+    auto_topups: optional3(
+      z61.array(z61.lazy(() => UpdatePlanAutoTopupResponse$inboundSchema))
+    ),
+    spend_limits: optional3(
+      z61.array(z61.lazy(() => UpdatePlanSpendLimitResponse$inboundSchema))
+    ),
+    usage_limits: optional3(
+      z61.array(z61.lazy(() => UpdatePlanUsageLimitResponse$inboundSchema))
+    ),
+    usage_alerts: optional3(
+      z61.array(z61.lazy(() => UpdatePlanUsageAlertResponse$inboundSchema))
+    ),
+    overage_allowed: optional3(
+      z61.array(z61.lazy(() => UpdatePlanOverageAllowedResponse$inboundSchema))
+    )
   }),
   z61.transform((v) => {
     return remap(v, {
-      "ignore_past_due": "ignorePastDue"
+      "auto_topups": "autoTopups",
+      "spend_limits": "spendLimits",
+      "usage_limits": "usageLimits",
+      "usage_alerts": "usageAlerts",
+      "overage_allowed": "overageAllowed"
     });
   })
 );
@@ -15038,6 +17305,9 @@ var UpdatePlanResponse$inboundSchema = z61.pipe(
     archived: boolean2(),
     base_variant_id: nullable(string4()),
     config: z61.lazy(() => UpdatePlanConfigResponse$inboundSchema),
+    billing_controls: optional3(
+      z61.lazy(() => UpdatePlanBillingControlsResponse$inboundSchema)
+    ),
     metadata: z61.record(z61.string(), z61.any()),
     customer_eligibility: optional3(
       z61.lazy(() => UpdatePlanCustomerEligibility$inboundSchema)
@@ -15050,6 +17320,7 @@ var UpdatePlanResponse$inboundSchema = z61.pipe(
       "free_trial": "freeTrial",
       "created_at": "createdAt",
       "base_variant_id": "baseVariantId",
+      "billing_controls": "billingControls",
       "customer_eligibility": "customerEligibility"
     });
   })
@@ -17129,7 +19400,7 @@ var Billing = class extends ClientSDK {
    * @example
    * ```typescript
    * // Schedule a transition from a trial plan to a paid plan
-   * const response = await client.billing.createSchedule({ customerId: "cus_123", phases: [{"startsAt":1782402442343,"plans":[{"planId":"trial_plan"}]},{"startsAt":1783612042343,"plans":[{"planId":"pro_plan"}]}] });
+   * const response = await client.billing.createSchedule({ customerId: "cus_123", phases: [{"startsAt":1782490690668,"plans":[{"planId":"trial_plan"}]},{"startsAt":1783700290668,"plans":[{"planId":"pro_plan"}]}] });
    * ```
    *
    * @param customerId - The ID of the customer to create the schedule for.
@@ -19830,6 +22101,7 @@ var Plans = class extends ClientSDK {
    * @param items - Feature configurations for this plan. Each item defines included units, pricing, and reset behavior. (optional)
    * @param freeTrial - Free trial configuration. Customers can try this plan before being charged. (optional)
    * @param config - Miscellaneous plan-level configuration flags. (optional)
+   * @param billingControls - Plan-level billing controls used as customer defaults. (optional)
    * @param metadata - Arbitrary key-value metadata defined by you for your own use (e.g. UI copy, feature highlights). Values can be any JSON-serializable value. Shared across all versions of the plan. (optional)
    *
    * @returns The created plan object.
@@ -19937,6 +22209,7 @@ var Plans = class extends ClientSDK {
    * @param items - Feature configurations for this plan. Each item defines included units, pricing, and reset behavior. (optional)
    * @param freeTrial - The free trial of the plan. Set to null to remove the free trial. (optional)
    * @param config - Miscellaneous plan-level configuration flags. (optional)
+   * @param billingControls - Plan-level billing controls used as customer defaults. (optional)
    * @param metadata - Arbitrary key-value metadata defined by you for your own use (e.g. UI copy, feature highlights). Values can be any JSON-serializable value. Shared across all versions of the plan. (optional)
    * @param newPlanId - The new ID to use for the plan. Can only be updated if the plan has not been used by any customers. (optional)
    *
@@ -20787,6 +23060,10 @@ var attachAddItemTierSchema = import_v42.z.object({
   amount: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional(),
   flatAmount: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional()
 });
+var attachOverageAllowedSchema = import_v42.z.object({
+  featureId: import_v42.z.string(),
+  enabled: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional()
+});
 var attachInvoiceModeSchema = import_v42.z.object({
   enabled: import_v42.z.boolean(),
   enablePlanImmediately: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional(),
@@ -20921,12 +23198,56 @@ var attachFreeTrialParamsOutboundSchema = import_v42.z.object({
   card_required: import_v42.z.boolean(),
   on_end: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional()
 });
+var attachPurchaseLimitOutboundSchema = import_v42.z.object({
+  interval: import_v42.z.string(),
+  interval_count: import_v42.z.number(),
+  limit: import_v42.z.number()
+});
+var attachAutoTopupOutboundSchema = import_v42.z.object({
+  feature_id: import_v42.z.string(),
+  enabled: import_v42.z.boolean(),
+  threshold: import_v42.z.number(),
+  quantity: import_v42.z.number(),
+  purchase_limit: import_v42.z.union([attachPurchaseLimitOutboundSchema, import_v42.z.undefined()]).optional(),
+  invoice_mode: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional()
+});
+var attachSpendLimitOutboundSchema = import_v42.z.object({
+  feature_id: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional(),
+  enabled: import_v42.z.boolean(),
+  limit_type: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional(),
+  overage_limit: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional()
+});
+var attachUsageLimitOutboundSchema = import_v42.z.object({
+  feature_id: import_v42.z.string(),
+  enabled: import_v42.z.boolean(),
+  limit: import_v42.z.number(),
+  interval: import_v42.z.string()
+});
+var attachUsageAlertOutboundSchema = import_v42.z.object({
+  feature_id: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional(),
+  enabled: import_v42.z.boolean(),
+  threshold: import_v42.z.number(),
+  threshold_type: import_v42.z.string(),
+  name: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional()
+});
+var attachOverageAllowedOutboundSchema = import_v42.z.object({
+  feature_id: import_v42.z.string(),
+  enabled: import_v42.z.boolean()
+});
+var attachBillingControlsOutboundSchema = import_v42.z.object({
+  auto_topups: import_v42.z.union([import_v42.z.array(attachAutoTopupOutboundSchema), import_v42.z.undefined()]).optional(),
+  spend_limits: import_v42.z.union([import_v42.z.array(attachSpendLimitOutboundSchema), import_v42.z.undefined()]).optional(),
+  usage_limits: import_v42.z.union([import_v42.z.array(attachUsageLimitOutboundSchema), import_v42.z.undefined()]).optional(),
+  usage_alerts: import_v42.z.union([import_v42.z.array(attachUsageAlertOutboundSchema), import_v42.z.undefined()]).optional(),
+  overage_allowed: import_v42.z.union([import_v42.z.array(attachOverageAllowedOutboundSchema), import_v42.z.undefined()]).optional()
+});
 var attachCustomizeOutboundSchema = import_v42.z.object({
   price: import_v42.z.union([attachBasePriceOutboundSchema, import_v42.z.undefined()]).optional().nullable(),
   items: import_v42.z.union([import_v42.z.array(attachItemPlanItemOutboundSchema), import_v42.z.undefined()]).optional(),
   add_items: import_v42.z.union([import_v42.z.array(attachAddItemPlanItemOutboundSchema), import_v42.z.undefined()]).optional(),
   remove_items: import_v42.z.union([import_v42.z.array(attachPlanItemFilterOutboundSchema), import_v42.z.undefined()]).optional(),
-  free_trial: import_v42.z.union([attachFreeTrialParamsOutboundSchema, import_v42.z.undefined()]).optional().nullable()
+  free_trial: import_v42.z.union([attachFreeTrialParamsOutboundSchema, import_v42.z.undefined()]).optional().nullable(),
+  billing_controls: import_v42.z.union([attachBillingControlsOutboundSchema, import_v42.z.undefined()]).optional()
 });
 var attachInvoiceModeOutboundSchema = import_v42.z.object({
   enabled: import_v42.z.boolean(),
@@ -21093,12 +23414,56 @@ var attachFreeTrialParamsSchema = import_v42.z.object({
   cardRequired: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional(),
   onEnd: import_v42.z.union([attachOnEndSchema, import_v42.z.undefined()]).optional()
 });
+var attachPurchaseLimitIntervalSchema = closedEnumSchema2;
+var attachPurchaseLimitSchema = import_v42.z.object({
+  interval: attachPurchaseLimitIntervalSchema,
+  intervalCount: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional(),
+  limit: import_v42.z.number()
+});
+var attachAutoTopupSchema = import_v42.z.object({
+  featureId: import_v42.z.string(),
+  enabled: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional(),
+  threshold: import_v42.z.number(),
+  quantity: import_v42.z.number(),
+  purchaseLimit: import_v42.z.union([attachPurchaseLimitSchema, import_v42.z.undefined()]).optional(),
+  invoiceMode: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional()
+});
+var attachLimitTypeSchema = closedEnumSchema2;
+var attachSpendLimitSchema = import_v42.z.object({
+  featureId: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional(),
+  enabled: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional(),
+  limitType: import_v42.z.union([attachLimitTypeSchema, import_v42.z.undefined()]).optional(),
+  overageLimit: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional()
+});
+var attachUsageLimitIntervalSchema = closedEnumSchema2;
+var attachUsageLimitSchema = import_v42.z.object({
+  featureId: import_v42.z.string(),
+  enabled: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional(),
+  limit: import_v42.z.number(),
+  interval: attachUsageLimitIntervalSchema
+});
+var attachThresholdTypeSchema = closedEnumSchema2;
+var attachUsageAlertSchema = import_v42.z.object({
+  featureId: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional(),
+  enabled: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional(),
+  threshold: import_v42.z.number(),
+  thresholdType: attachThresholdTypeSchema,
+  name: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional()
+});
+var attachBillingControlsSchema = import_v42.z.object({
+  autoTopups: import_v42.z.union([import_v42.z.array(attachAutoTopupSchema), import_v42.z.undefined()]).optional(),
+  spendLimits: import_v42.z.union([import_v42.z.array(attachSpendLimitSchema), import_v42.z.undefined()]).optional(),
+  usageLimits: import_v42.z.union([import_v42.z.array(attachUsageLimitSchema), import_v42.z.undefined()]).optional(),
+  usageAlerts: import_v42.z.union([import_v42.z.array(attachUsageAlertSchema), import_v42.z.undefined()]).optional(),
+  overageAllowed: import_v42.z.union([import_v42.z.array(attachOverageAllowedSchema), import_v42.z.undefined()]).optional()
+});
 var attachCustomizeSchema = import_v42.z.object({
   price: import_v42.z.union([attachBasePriceSchema, import_v42.z.undefined()]).optional().nullable(),
   items: import_v42.z.union([import_v42.z.array(attachItemPlanItemSchema), import_v42.z.undefined()]).optional(),
   addItems: import_v42.z.union([import_v42.z.array(attachAddItemPlanItemSchema), import_v42.z.undefined()]).optional(),
   removeItems: import_v42.z.union([import_v42.z.array(attachPlanItemFilterSchema), import_v42.z.undefined()]).optional(),
-  freeTrial: import_v42.z.union([attachFreeTrialParamsSchema, import_v42.z.undefined()]).optional().nullable()
+  freeTrial: import_v42.z.union([attachFreeTrialParamsSchema, import_v42.z.undefined()]).optional().nullable(),
+  billingControls: import_v42.z.union([attachBillingControlsSchema, import_v42.z.undefined()]).optional()
 });
 var attachProrationBehaviorSchema = closedEnumSchema2;
 var attachRedirectModeSchema = closedEnumSchema2;
@@ -21169,11 +23534,6 @@ var import_v44 = require("zod/v4");
 var getOrCreateCustomerGlobalsSchema = import_v44.z.object({
   xApiVersion: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional()
 });
-var getOrCreateCustomerSpendLimitSchema = import_v44.z.object({
-  featureId: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional(),
-  enabled: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional(),
-  overageLimit: import_v44.z.union([import_v44.z.number(), import_v44.z.undefined()]).optional()
-});
 var getOrCreateCustomerOverageAllowedSchema = import_v44.z.object({
   featureId: import_v44.z.string(),
   enabled: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional()
@@ -21197,10 +23557,12 @@ var getOrCreateCustomerAutoTopupOutboundSchema = import_v44.z.object({
 var getOrCreateCustomerSpendLimitOutboundSchema = import_v44.z.object({
   feature_id: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional(),
   enabled: import_v44.z.boolean(),
+  limit_type: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional(),
   overage_limit: import_v44.z.union([import_v44.z.number(), import_v44.z.undefined()]).optional()
 });
 var getOrCreateCustomerUsageLimitOutboundSchema = import_v44.z.object({
   feature_id: import_v44.z.string(),
+  enabled: import_v44.z.boolean(),
   limit: import_v44.z.number(),
   interval: import_v44.z.string()
 });
@@ -21267,9 +23629,17 @@ var getOrCreateCustomerAutoTopupSchema = import_v44.z.object({
   purchaseLimit: import_v44.z.union([getOrCreateCustomerPurchaseLimitSchema, import_v44.z.undefined()]).optional(),
   invoiceMode: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional()
 });
+var getOrCreateCustomerLimitTypeSchema = closedEnumSchema3;
+var getOrCreateCustomerSpendLimitSchema = import_v44.z.object({
+  featureId: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional(),
+  enabled: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional(),
+  limitType: import_v44.z.union([getOrCreateCustomerLimitTypeSchema, import_v44.z.undefined()]).optional(),
+  overageLimit: import_v44.z.union([import_v44.z.number(), import_v44.z.undefined()]).optional()
+});
 var getOrCreateCustomerUsageLimitIntervalSchema = closedEnumSchema3;
 var getOrCreateCustomerUsageLimitSchema = import_v44.z.object({
   featureId: import_v44.z.string(),
+  enabled: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional(),
   limit: import_v44.z.number(),
   interval: getOrCreateCustomerUsageLimitIntervalSchema
 });
@@ -21407,6 +23777,10 @@ var listPlansItemDisplaySchema = import_v46.z.object({
 var listPlansConfigSchema = import_v46.z.object({
   ignorePastDue: import_v46.z.boolean()
 });
+var listPlansOverageAllowedSchema = import_v46.z.object({
+  featureId: import_v46.z.string(),
+  enabled: import_v46.z.boolean()
+});
 var listPlansParamsOutboundSchema = import_v46.z.object({
   customer_id: import_v46.z.union([import_v46.z.string(), import_v46.z.undefined()]).optional(),
   entity_id: import_v46.z.union([import_v46.z.string(), import_v46.z.undefined()]).optional(),
@@ -21473,6 +23847,49 @@ var listPlansFreeTrialSchema = import_v46.z.object({
   onEnd: import_v46.z.union([listPlansOnEndSchema, import_v46.z.undefined()]).optional().nullable()
 });
 var listPlansEnvSchema = openEnumSchema3;
+var listPlansPurchaseLimitIntervalSchema = openEnumSchema3;
+var listPlansPurchaseLimitSchema = import_v46.z.object({
+  interval: listPlansPurchaseLimitIntervalSchema,
+  intervalCount: import_v46.z.number(),
+  limit: import_v46.z.number()
+});
+var listPlansAutoTopupSchema = import_v46.z.object({
+  featureId: import_v46.z.string(),
+  enabled: import_v46.z.boolean(),
+  threshold: import_v46.z.number(),
+  quantity: import_v46.z.number(),
+  purchaseLimit: import_v46.z.union([listPlansPurchaseLimitSchema, import_v46.z.undefined()]).optional(),
+  invoiceMode: import_v46.z.union([import_v46.z.boolean(), import_v46.z.undefined()]).optional()
+});
+var listPlansLimitTypeSchema = openEnumSchema3;
+var listPlansSpendLimitSchema = import_v46.z.object({
+  featureId: import_v46.z.union([import_v46.z.string(), import_v46.z.undefined()]).optional(),
+  enabled: import_v46.z.boolean(),
+  limitType: import_v46.z.union([listPlansLimitTypeSchema, import_v46.z.undefined()]).optional(),
+  overageLimit: import_v46.z.union([import_v46.z.number(), import_v46.z.undefined()]).optional()
+});
+var listPlansUsageLimitIntervalSchema = openEnumSchema3;
+var listPlansUsageLimitSchema = import_v46.z.object({
+  featureId: import_v46.z.string(),
+  enabled: import_v46.z.boolean(),
+  limit: import_v46.z.number(),
+  interval: listPlansUsageLimitIntervalSchema
+});
+var listPlansThresholdTypeSchema = openEnumSchema3;
+var listPlansUsageAlertSchema = import_v46.z.object({
+  featureId: import_v46.z.union([import_v46.z.string(), import_v46.z.undefined()]).optional(),
+  enabled: import_v46.z.boolean(),
+  threshold: import_v46.z.number(),
+  thresholdType: listPlansThresholdTypeSchema,
+  name: import_v46.z.union([import_v46.z.string(), import_v46.z.undefined()]).optional()
+});
+var listPlansBillingControlsSchema = import_v46.z.object({
+  autoTopups: import_v46.z.union([import_v46.z.array(listPlansAutoTopupSchema), import_v46.z.undefined()]).optional(),
+  spendLimits: import_v46.z.union([import_v46.z.array(listPlansSpendLimitSchema), import_v46.z.undefined()]).optional(),
+  usageLimits: import_v46.z.union([import_v46.z.array(listPlansUsageLimitSchema), import_v46.z.undefined()]).optional(),
+  usageAlerts: import_v46.z.union([import_v46.z.array(listPlansUsageAlertSchema), import_v46.z.undefined()]).optional(),
+  overageAllowed: import_v46.z.union([import_v46.z.array(listPlansOverageAllowedSchema), import_v46.z.undefined()]).optional()
+});
 var listPlansStatusSchema = openEnumSchema3;
 var listPlansAttachActionSchema = openEnumSchema3;
 var listPlansCustomerEligibilitySchema = import_v46.z.object({
@@ -21498,6 +23915,7 @@ var listPlansListSchema = import_v46.z.object({
   archived: import_v46.z.boolean(),
   baseVariantId: import_v46.z.string().nullable(),
   config: listPlansConfigSchema,
+  billingControls: import_v46.z.union([listPlansBillingControlsSchema, import_v46.z.undefined()]).optional(),
   metadata: import_v46.z.record(import_v46.z.string(), import_v46.z.any()),
   customerEligibility: import_v46.z.union([listPlansCustomerEligibilitySchema, import_v46.z.undefined()]).optional()
 });
@@ -21532,11 +23950,6 @@ var multiAttachAttachDiscountSchema = import_v47.z.object({
   rewardId: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
   promotionCode: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional()
 });
-var multiAttachSpendLimitSchema = import_v47.z.object({
-  featureId: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
-  enabled: import_v47.z.union([import_v47.z.boolean(), import_v47.z.undefined()]).optional(),
-  overageLimit: import_v47.z.union([import_v47.z.number(), import_v47.z.undefined()]).optional()
-});
 var multiAttachOverageAllowedSchema = import_v47.z.object({
   featureId: import_v47.z.string(),
   enabled: import_v47.z.union([import_v47.z.boolean(), import_v47.z.undefined()]).optional()
@@ -21628,10 +24041,12 @@ var multiAttachAttachDiscountOutboundSchema = import_v47.z.object({
 var multiAttachSpendLimitOutboundSchema = import_v47.z.object({
   feature_id: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
   enabled: import_v47.z.boolean(),
+  limit_type: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
   overage_limit: import_v47.z.union([import_v47.z.number(), import_v47.z.undefined()]).optional()
 });
 var multiAttachUsageLimitOutboundSchema = import_v47.z.object({
   feature_id: import_v47.z.string(),
+  enabled: import_v47.z.boolean(),
   limit: import_v47.z.number(),
   interval: import_v47.z.string()
 });
@@ -21727,9 +24142,17 @@ var multiAttachFreeTrialParamsSchema = import_v47.z.object({
   onEnd: import_v47.z.union([multiAttachOnEndSchema, import_v47.z.undefined()]).optional()
 });
 var multiAttachRedirectModeSchema = closedEnumSchema4;
+var multiAttachLimitTypeSchema = closedEnumSchema4;
+var multiAttachSpendLimitSchema = import_v47.z.object({
+  featureId: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
+  enabled: import_v47.z.union([import_v47.z.boolean(), import_v47.z.undefined()]).optional(),
+  limitType: import_v47.z.union([multiAttachLimitTypeSchema, import_v47.z.undefined()]).optional(),
+  overageLimit: import_v47.z.union([import_v47.z.number(), import_v47.z.undefined()]).optional()
+});
 var multiAttachEntityDataIntervalSchema = closedEnumSchema4;
 var multiAttachUsageLimitSchema = import_v47.z.object({
   featureId: import_v47.z.string(),
+  enabled: import_v47.z.union([import_v47.z.boolean(), import_v47.z.undefined()]).optional(),
   limit: import_v47.z.number(),
   interval: multiAttachEntityDataIntervalSchema
 });
@@ -21837,6 +24260,10 @@ var previewAttachAddItemTierSchema = import_v49.z.object({
   amount: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional(),
   flatAmount: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional()
 });
+var previewAttachOverageAllowedSchema = import_v49.z.object({
+  featureId: import_v49.z.string(),
+  enabled: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional()
+});
 var previewAttachInvoiceModeSchema = import_v49.z.object({
   enabled: import_v49.z.boolean(),
   enablePlanImmediately: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional(),
@@ -22041,12 +24468,56 @@ var previewAttachFreeTrialParamsOutboundSchema = import_v49.z.object({
   card_required: import_v49.z.boolean(),
   on_end: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional()
 });
+var previewAttachPurchaseLimitOutboundSchema = import_v49.z.object({
+  interval: import_v49.z.string(),
+  interval_count: import_v49.z.number(),
+  limit: import_v49.z.number()
+});
+var previewAttachAutoTopupOutboundSchema = import_v49.z.object({
+  feature_id: import_v49.z.string(),
+  enabled: import_v49.z.boolean(),
+  threshold: import_v49.z.number(),
+  quantity: import_v49.z.number(),
+  purchase_limit: import_v49.z.union([previewAttachPurchaseLimitOutboundSchema, import_v49.z.undefined()]).optional(),
+  invoice_mode: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional()
+});
+var previewAttachSpendLimitOutboundSchema = import_v49.z.object({
+  feature_id: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional(),
+  enabled: import_v49.z.boolean(),
+  limit_type: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional(),
+  overage_limit: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional()
+});
+var previewAttachUsageLimitOutboundSchema = import_v49.z.object({
+  feature_id: import_v49.z.string(),
+  enabled: import_v49.z.boolean(),
+  limit: import_v49.z.number(),
+  interval: import_v49.z.string()
+});
+var previewAttachUsageAlertOutboundSchema = import_v49.z.object({
+  feature_id: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional(),
+  enabled: import_v49.z.boolean(),
+  threshold: import_v49.z.number(),
+  threshold_type: import_v49.z.string(),
+  name: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional()
+});
+var previewAttachOverageAllowedOutboundSchema = import_v49.z.object({
+  feature_id: import_v49.z.string(),
+  enabled: import_v49.z.boolean()
+});
+var previewAttachBillingControlsOutboundSchema = import_v49.z.object({
+  auto_topups: import_v49.z.union([import_v49.z.array(previewAttachAutoTopupOutboundSchema), import_v49.z.undefined()]).optional(),
+  spend_limits: import_v49.z.union([import_v49.z.array(previewAttachSpendLimitOutboundSchema), import_v49.z.undefined()]).optional(),
+  usage_limits: import_v49.z.union([import_v49.z.array(previewAttachUsageLimitOutboundSchema), import_v49.z.undefined()]).optional(),
+  usage_alerts: import_v49.z.union([import_v49.z.array(previewAttachUsageAlertOutboundSchema), import_v49.z.undefined()]).optional(),
+  overage_allowed: import_v49.z.union([import_v49.z.array(previewAttachOverageAllowedOutboundSchema), import_v49.z.undefined()]).optional()
+});
 var previewAttachCustomizeOutboundSchema = import_v49.z.object({
   price: import_v49.z.union([previewAttachBasePriceOutboundSchema, import_v49.z.undefined()]).optional().nullable(),
   items: import_v49.z.union([import_v49.z.array(previewAttachItemPlanItemOutboundSchema), import_v49.z.undefined()]).optional(),
   add_items: import_v49.z.union([import_v49.z.array(previewAttachAddItemPlanItemOutboundSchema), import_v49.z.undefined()]).optional(),
   remove_items: import_v49.z.union([import_v49.z.array(previewAttachPlanItemFilterOutboundSchema), import_v49.z.undefined()]).optional(),
-  free_trial: import_v49.z.union([previewAttachFreeTrialParamsOutboundSchema, import_v49.z.undefined()]).optional().nullable()
+  free_trial: import_v49.z.union([previewAttachFreeTrialParamsOutboundSchema, import_v49.z.undefined()]).optional().nullable(),
+  billing_controls: import_v49.z.union([previewAttachBillingControlsOutboundSchema, import_v49.z.undefined()]).optional()
 });
 var previewAttachInvoiceModeOutboundSchema = import_v49.z.object({
   enabled: import_v49.z.boolean(),
@@ -22217,12 +24688,56 @@ var previewAttachFreeTrialParamsSchema = import_v49.z.object({
   cardRequired: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional(),
   onEnd: import_v49.z.union([previewAttachOnEndSchema, import_v49.z.undefined()]).optional()
 });
+var previewAttachPurchaseLimitIntervalSchema = closedEnumSchema5;
+var previewAttachPurchaseLimitSchema = import_v49.z.object({
+  interval: previewAttachPurchaseLimitIntervalSchema,
+  intervalCount: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional(),
+  limit: import_v49.z.number()
+});
+var previewAttachAutoTopupSchema = import_v49.z.object({
+  featureId: import_v49.z.string(),
+  enabled: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional(),
+  threshold: import_v49.z.number(),
+  quantity: import_v49.z.number(),
+  purchaseLimit: import_v49.z.union([previewAttachPurchaseLimitSchema, import_v49.z.undefined()]).optional(),
+  invoiceMode: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional()
+});
+var previewAttachLimitTypeSchema = closedEnumSchema5;
+var previewAttachSpendLimitSchema = import_v49.z.object({
+  featureId: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional(),
+  enabled: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional(),
+  limitType: import_v49.z.union([previewAttachLimitTypeSchema, import_v49.z.undefined()]).optional(),
+  overageLimit: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional()
+});
+var previewAttachUsageLimitIntervalSchema = closedEnumSchema5;
+var previewAttachUsageLimitSchema = import_v49.z.object({
+  featureId: import_v49.z.string(),
+  enabled: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional(),
+  limit: import_v49.z.number(),
+  interval: previewAttachUsageLimitIntervalSchema
+});
+var previewAttachThresholdTypeSchema = closedEnumSchema5;
+var previewAttachUsageAlertSchema = import_v49.z.object({
+  featureId: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional(),
+  enabled: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional(),
+  threshold: import_v49.z.number(),
+  thresholdType: previewAttachThresholdTypeSchema,
+  name: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional()
+});
+var previewAttachBillingControlsSchema = import_v49.z.object({
+  autoTopups: import_v49.z.union([import_v49.z.array(previewAttachAutoTopupSchema), import_v49.z.undefined()]).optional(),
+  spendLimits: import_v49.z.union([import_v49.z.array(previewAttachSpendLimitSchema), import_v49.z.undefined()]).optional(),
+  usageLimits: import_v49.z.union([import_v49.z.array(previewAttachUsageLimitSchema), import_v49.z.undefined()]).optional(),
+  usageAlerts: import_v49.z.union([import_v49.z.array(previewAttachUsageAlertSchema), import_v49.z.undefined()]).optional(),
+  overageAllowed: import_v49.z.union([import_v49.z.array(previewAttachOverageAllowedSchema), import_v49.z.undefined()]).optional()
+});
 var previewAttachCustomizeSchema = import_v49.z.object({
   price: import_v49.z.union([previewAttachBasePriceSchema, import_v49.z.undefined()]).optional().nullable(),
   items: import_v49.z.union([import_v49.z.array(previewAttachItemPlanItemSchema), import_v49.z.undefined()]).optional(),
   addItems: import_v49.z.union([import_v49.z.array(previewAttachAddItemPlanItemSchema), import_v49.z.undefined()]).optional(),
   removeItems: import_v49.z.union([import_v49.z.array(previewAttachPlanItemFilterSchema), import_v49.z.undefined()]).optional(),
-  freeTrial: import_v49.z.union([previewAttachFreeTrialParamsSchema, import_v49.z.undefined()]).optional().nullable()
+  freeTrial: import_v49.z.union([previewAttachFreeTrialParamsSchema, import_v49.z.undefined()]).optional().nullable(),
+  billingControls: import_v49.z.union([previewAttachBillingControlsSchema, import_v49.z.undefined()]).optional()
 });
 var previewAttachProrationBehaviorSchema = closedEnumSchema5;
 var previewAttachRedirectModeSchema = closedEnumSchema5;
@@ -22324,11 +24839,6 @@ var previewMultiAttachAttachDiscountSchema = import_v410.z.object({
   rewardId: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
   promotionCode: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional()
 });
-var previewMultiAttachSpendLimitSchema = import_v410.z.object({
-  featureId: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
-  enabled: import_v410.z.union([import_v410.z.boolean(), import_v410.z.undefined()]).optional(),
-  overageLimit: import_v410.z.union([import_v410.z.number(), import_v410.z.undefined()]).optional()
-});
 var previewMultiAttachOverageAllowedSchema = import_v410.z.object({
   featureId: import_v410.z.string(),
   enabled: import_v410.z.union([import_v410.z.boolean(), import_v410.z.undefined()]).optional()
@@ -22490,10 +25000,12 @@ var previewMultiAttachAttachDiscountOutboundSchema = import_v410.z.object({
 var previewMultiAttachSpendLimitOutboundSchema = import_v410.z.object({
   feature_id: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
   enabled: import_v410.z.boolean(),
+  limit_type: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
   overage_limit: import_v410.z.union([import_v410.z.number(), import_v410.z.undefined()]).optional()
 });
 var previewMultiAttachUsageLimitOutboundSchema = import_v410.z.object({
   feature_id: import_v410.z.string(),
+  enabled: import_v410.z.boolean(),
   limit: import_v410.z.number(),
   interval: import_v410.z.string()
 });
@@ -22596,9 +25108,17 @@ var previewMultiAttachFreeTrialParamsSchema = import_v410.z.object({
   onEnd: import_v410.z.union([previewMultiAttachOnEndSchema, import_v410.z.undefined()]).optional()
 });
 var previewMultiAttachRedirectModeSchema = closedEnumSchema6;
+var previewMultiAttachLimitTypeSchema = closedEnumSchema6;
+var previewMultiAttachSpendLimitSchema = import_v410.z.object({
+  featureId: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
+  enabled: import_v410.z.union([import_v410.z.boolean(), import_v410.z.undefined()]).optional(),
+  limitType: import_v410.z.union([previewMultiAttachLimitTypeSchema, import_v410.z.undefined()]).optional(),
+  overageLimit: import_v410.z.union([import_v410.z.number(), import_v410.z.undefined()]).optional()
+});
 var previewMultiAttachEntityDataIntervalSchema = closedEnumSchema6;
 var previewMultiAttachUsageLimitSchema = import_v410.z.object({
   featureId: import_v410.z.string(),
+  enabled: import_v410.z.union([import_v410.z.boolean(), import_v410.z.undefined()]).optional(),
   limit: import_v410.z.number(),
   interval: previewMultiAttachEntityDataIntervalSchema
 });
@@ -22717,6 +25237,10 @@ var previewUpdateAddItemTierSchema = import_v411.z.object({
   amount: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional(),
   flatAmount: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional()
 });
+var previewUpdateOverageAllowedSchema = import_v411.z.object({
+  featureId: import_v411.z.string(),
+  enabled: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional()
+});
 var previewUpdateInvoiceModeSchema = import_v411.z.object({
   enabled: import_v411.z.boolean(),
   enablePlanImmediately: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
@@ -22916,12 +25440,56 @@ var previewUpdateFreeTrialParamsOutboundSchema = import_v411.z.object({
   card_required: import_v411.z.boolean(),
   on_end: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional()
 });
+var previewUpdatePurchaseLimitOutboundSchema = import_v411.z.object({
+  interval: import_v411.z.string(),
+  interval_count: import_v411.z.number(),
+  limit: import_v411.z.number()
+});
+var previewUpdateAutoTopupOutboundSchema = import_v411.z.object({
+  feature_id: import_v411.z.string(),
+  enabled: import_v411.z.boolean(),
+  threshold: import_v411.z.number(),
+  quantity: import_v411.z.number(),
+  purchase_limit: import_v411.z.union([previewUpdatePurchaseLimitOutboundSchema, import_v411.z.undefined()]).optional(),
+  invoice_mode: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional()
+});
+var previewUpdateSpendLimitOutboundSchema = import_v411.z.object({
+  feature_id: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
+  enabled: import_v411.z.boolean(),
+  limit_type: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
+  overage_limit: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional()
+});
+var previewUpdateUsageLimitOutboundSchema = import_v411.z.object({
+  feature_id: import_v411.z.string(),
+  enabled: import_v411.z.boolean(),
+  limit: import_v411.z.number(),
+  interval: import_v411.z.string()
+});
+var previewUpdateUsageAlertOutboundSchema = import_v411.z.object({
+  feature_id: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
+  enabled: import_v411.z.boolean(),
+  threshold: import_v411.z.number(),
+  threshold_type: import_v411.z.string(),
+  name: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional()
+});
+var previewUpdateOverageAllowedOutboundSchema = import_v411.z.object({
+  feature_id: import_v411.z.string(),
+  enabled: import_v411.z.boolean()
+});
+var previewUpdateBillingControlsOutboundSchema = import_v411.z.object({
+  auto_topups: import_v411.z.union([import_v411.z.array(previewUpdateAutoTopupOutboundSchema), import_v411.z.undefined()]).optional(),
+  spend_limits: import_v411.z.union([import_v411.z.array(previewUpdateSpendLimitOutboundSchema), import_v411.z.undefined()]).optional(),
+  usage_limits: import_v411.z.union([import_v411.z.array(previewUpdateUsageLimitOutboundSchema), import_v411.z.undefined()]).optional(),
+  usage_alerts: import_v411.z.union([import_v411.z.array(previewUpdateUsageAlertOutboundSchema), import_v411.z.undefined()]).optional(),
+  overage_allowed: import_v411.z.union([import_v411.z.array(previewUpdateOverageAllowedOutboundSchema), import_v411.z.undefined()]).optional()
+});
 var previewUpdateCustomizeOutboundSchema = import_v411.z.object({
   price: import_v411.z.union([previewUpdateBasePriceOutboundSchema, import_v411.z.undefined()]).optional().nullable(),
   items: import_v411.z.union([import_v411.z.array(previewUpdateItemPlanItemOutboundSchema), import_v411.z.undefined()]).optional(),
   add_items: import_v411.z.union([import_v411.z.array(previewUpdateAddItemPlanItemOutboundSchema), import_v411.z.undefined()]).optional(),
   remove_items: import_v411.z.union([import_v411.z.array(previewUpdatePlanItemFilterOutboundSchema), import_v411.z.undefined()]).optional(),
-  free_trial: import_v411.z.union([previewUpdateFreeTrialParamsOutboundSchema, import_v411.z.undefined()]).optional().nullable()
+  free_trial: import_v411.z.union([previewUpdateFreeTrialParamsOutboundSchema, import_v411.z.undefined()]).optional().nullable(),
+  billing_controls: import_v411.z.union([previewUpdateBillingControlsOutboundSchema, import_v411.z.undefined()]).optional()
 });
 var previewUpdateInvoiceModeOutboundSchema = import_v411.z.object({
   enabled: import_v411.z.boolean(),
@@ -23076,12 +25644,56 @@ var previewUpdateFreeTrialParamsSchema = import_v411.z.object({
   cardRequired: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
   onEnd: import_v411.z.union([previewUpdateOnEndSchema, import_v411.z.undefined()]).optional()
 });
+var previewUpdatePurchaseLimitIntervalSchema = closedEnumSchema7;
+var previewUpdatePurchaseLimitSchema = import_v411.z.object({
+  interval: previewUpdatePurchaseLimitIntervalSchema,
+  intervalCount: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional(),
+  limit: import_v411.z.number()
+});
+var previewUpdateAutoTopupSchema = import_v411.z.object({
+  featureId: import_v411.z.string(),
+  enabled: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
+  threshold: import_v411.z.number(),
+  quantity: import_v411.z.number(),
+  purchaseLimit: import_v411.z.union([previewUpdatePurchaseLimitSchema, import_v411.z.undefined()]).optional(),
+  invoiceMode: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional()
+});
+var previewUpdateLimitTypeSchema = closedEnumSchema7;
+var previewUpdateSpendLimitSchema = import_v411.z.object({
+  featureId: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
+  enabled: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
+  limitType: import_v411.z.union([previewUpdateLimitTypeSchema, import_v411.z.undefined()]).optional(),
+  overageLimit: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional()
+});
+var previewUpdateUsageLimitIntervalSchema = closedEnumSchema7;
+var previewUpdateUsageLimitSchema = import_v411.z.object({
+  featureId: import_v411.z.string(),
+  enabled: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
+  limit: import_v411.z.number(),
+  interval: previewUpdateUsageLimitIntervalSchema
+});
+var previewUpdateThresholdTypeSchema = closedEnumSchema7;
+var previewUpdateUsageAlertSchema = import_v411.z.object({
+  featureId: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
+  enabled: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
+  threshold: import_v411.z.number(),
+  thresholdType: previewUpdateThresholdTypeSchema,
+  name: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional()
+});
+var previewUpdateBillingControlsSchema = import_v411.z.object({
+  autoTopups: import_v411.z.union([import_v411.z.array(previewUpdateAutoTopupSchema), import_v411.z.undefined()]).optional(),
+  spendLimits: import_v411.z.union([import_v411.z.array(previewUpdateSpendLimitSchema), import_v411.z.undefined()]).optional(),
+  usageLimits: import_v411.z.union([import_v411.z.array(previewUpdateUsageLimitSchema), import_v411.z.undefined()]).optional(),
+  usageAlerts: import_v411.z.union([import_v411.z.array(previewUpdateUsageAlertSchema), import_v411.z.undefined()]).optional(),
+  overageAllowed: import_v411.z.union([import_v411.z.array(previewUpdateOverageAllowedSchema), import_v411.z.undefined()]).optional()
+});
 var previewUpdateCustomizeSchema = import_v411.z.object({
   price: import_v411.z.union([previewUpdateBasePriceSchema, import_v411.z.undefined()]).optional().nullable(),
   items: import_v411.z.union([import_v411.z.array(previewUpdateItemPlanItemSchema), import_v411.z.undefined()]).optional(),
   addItems: import_v411.z.union([import_v411.z.array(previewUpdateAddItemPlanItemSchema), import_v411.z.undefined()]).optional(),
   removeItems: import_v411.z.union([import_v411.z.array(previewUpdatePlanItemFilterSchema), import_v411.z.undefined()]).optional(),
-  freeTrial: import_v411.z.union([previewUpdateFreeTrialParamsSchema, import_v411.z.undefined()]).optional().nullable()
+  freeTrial: import_v411.z.union([previewUpdateFreeTrialParamsSchema, import_v411.z.undefined()]).optional().nullable(),
+  billingControls: import_v411.z.union([previewUpdateBillingControlsSchema, import_v411.z.undefined()]).optional()
 });
 var previewUpdateProrationBehaviorSchema = closedEnumSchema7;
 var previewUpdateRedirectModeSchema = closedEnumSchema7;
@@ -23185,6 +25797,10 @@ var setupPaymentAddItemTierSchema = import_v413.z.object({
   amount: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional(),
   flatAmount: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional()
 });
+var setupPaymentOverageAllowedSchema = import_v413.z.object({
+  featureId: import_v413.z.string(),
+  enabled: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional()
+});
 var setupPaymentAttachDiscountSchema = import_v413.z.object({
   rewardId: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
   promotionCode: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional()
@@ -23316,12 +25932,56 @@ var setupPaymentFreeTrialParamsOutboundSchema = import_v413.z.object({
   card_required: import_v413.z.boolean(),
   on_end: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional()
 });
+var setupPaymentPurchaseLimitOutboundSchema = import_v413.z.object({
+  interval: import_v413.z.string(),
+  interval_count: import_v413.z.number(),
+  limit: import_v413.z.number()
+});
+var setupPaymentAutoTopupOutboundSchema = import_v413.z.object({
+  feature_id: import_v413.z.string(),
+  enabled: import_v413.z.boolean(),
+  threshold: import_v413.z.number(),
+  quantity: import_v413.z.number(),
+  purchase_limit: import_v413.z.union([setupPaymentPurchaseLimitOutboundSchema, import_v413.z.undefined()]).optional(),
+  invoice_mode: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional()
+});
+var setupPaymentSpendLimitOutboundSchema = import_v413.z.object({
+  feature_id: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
+  enabled: import_v413.z.boolean(),
+  limit_type: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
+  overage_limit: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional()
+});
+var setupPaymentUsageLimitOutboundSchema = import_v413.z.object({
+  feature_id: import_v413.z.string(),
+  enabled: import_v413.z.boolean(),
+  limit: import_v413.z.number(),
+  interval: import_v413.z.string()
+});
+var setupPaymentUsageAlertOutboundSchema = import_v413.z.object({
+  feature_id: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
+  enabled: import_v413.z.boolean(),
+  threshold: import_v413.z.number(),
+  threshold_type: import_v413.z.string(),
+  name: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional()
+});
+var setupPaymentOverageAllowedOutboundSchema = import_v413.z.object({
+  feature_id: import_v413.z.string(),
+  enabled: import_v413.z.boolean()
+});
+var setupPaymentBillingControlsOutboundSchema = import_v413.z.object({
+  auto_topups: import_v413.z.union([import_v413.z.array(setupPaymentAutoTopupOutboundSchema), import_v413.z.undefined()]).optional(),
+  spend_limits: import_v413.z.union([import_v413.z.array(setupPaymentSpendLimitOutboundSchema), import_v413.z.undefined()]).optional(),
+  usage_limits: import_v413.z.union([import_v413.z.array(setupPaymentUsageLimitOutboundSchema), import_v413.z.undefined()]).optional(),
+  usage_alerts: import_v413.z.union([import_v413.z.array(setupPaymentUsageAlertOutboundSchema), import_v413.z.undefined()]).optional(),
+  overage_allowed: import_v413.z.union([import_v413.z.array(setupPaymentOverageAllowedOutboundSchema), import_v413.z.undefined()]).optional()
+});
 var setupPaymentCustomizeOutboundSchema = import_v413.z.object({
   price: import_v413.z.union([setupPaymentBasePriceOutboundSchema, import_v413.z.undefined()]).optional().nullable(),
   items: import_v413.z.union([import_v413.z.array(setupPaymentItemPlanItemOutboundSchema), import_v413.z.undefined()]).optional(),
   add_items: import_v413.z.union([import_v413.z.array(setupPaymentAddItemPlanItemOutboundSchema), import_v413.z.undefined()]).optional(),
   remove_items: import_v413.z.union([import_v413.z.array(setupPaymentPlanItemFilterOutboundSchema), import_v413.z.undefined()]).optional(),
-  free_trial: import_v413.z.union([setupPaymentFreeTrialParamsOutboundSchema, import_v413.z.undefined()]).optional().nullable()
+  free_trial: import_v413.z.union([setupPaymentFreeTrialParamsOutboundSchema, import_v413.z.undefined()]).optional().nullable(),
+  billing_controls: import_v413.z.union([setupPaymentBillingControlsOutboundSchema, import_v413.z.undefined()]).optional()
 });
 var setupPaymentAttachDiscountOutboundSchema = import_v413.z.object({
   reward_id: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
@@ -23475,12 +26135,56 @@ var setupPaymentFreeTrialParamsSchema = import_v413.z.object({
   cardRequired: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional(),
   onEnd: import_v413.z.union([setupPaymentOnEndSchema, import_v413.z.undefined()]).optional()
 });
+var setupPaymentPurchaseLimitIntervalSchema = closedEnumSchema8;
+var setupPaymentPurchaseLimitSchema = import_v413.z.object({
+  interval: setupPaymentPurchaseLimitIntervalSchema,
+  intervalCount: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional(),
+  limit: import_v413.z.number()
+});
+var setupPaymentAutoTopupSchema = import_v413.z.object({
+  featureId: import_v413.z.string(),
+  enabled: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional(),
+  threshold: import_v413.z.number(),
+  quantity: import_v413.z.number(),
+  purchaseLimit: import_v413.z.union([setupPaymentPurchaseLimitSchema, import_v413.z.undefined()]).optional(),
+  invoiceMode: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional()
+});
+var setupPaymentLimitTypeSchema = closedEnumSchema8;
+var setupPaymentSpendLimitSchema = import_v413.z.object({
+  featureId: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
+  enabled: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional(),
+  limitType: import_v413.z.union([setupPaymentLimitTypeSchema, import_v413.z.undefined()]).optional(),
+  overageLimit: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional()
+});
+var setupPaymentUsageLimitIntervalSchema = closedEnumSchema8;
+var setupPaymentUsageLimitSchema = import_v413.z.object({
+  featureId: import_v413.z.string(),
+  enabled: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional(),
+  limit: import_v413.z.number(),
+  interval: setupPaymentUsageLimitIntervalSchema
+});
+var setupPaymentThresholdTypeSchema = closedEnumSchema8;
+var setupPaymentUsageAlertSchema = import_v413.z.object({
+  featureId: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
+  enabled: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional(),
+  threshold: import_v413.z.number(),
+  thresholdType: setupPaymentThresholdTypeSchema,
+  name: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional()
+});
+var setupPaymentBillingControlsSchema = import_v413.z.object({
+  autoTopups: import_v413.z.union([import_v413.z.array(setupPaymentAutoTopupSchema), import_v413.z.undefined()]).optional(),
+  spendLimits: import_v413.z.union([import_v413.z.array(setupPaymentSpendLimitSchema), import_v413.z.undefined()]).optional(),
+  usageLimits: import_v413.z.union([import_v413.z.array(setupPaymentUsageLimitSchema), import_v413.z.undefined()]).optional(),
+  usageAlerts: import_v413.z.union([import_v413.z.array(setupPaymentUsageAlertSchema), import_v413.z.undefined()]).optional(),
+  overageAllowed: import_v413.z.union([import_v413.z.array(setupPaymentOverageAllowedSchema), import_v413.z.undefined()]).optional()
+});
 var setupPaymentCustomizeSchema = import_v413.z.object({
   price: import_v413.z.union([setupPaymentBasePriceSchema, import_v413.z.undefined()]).optional().nullable(),
   items: import_v413.z.union([import_v413.z.array(setupPaymentItemPlanItemSchema), import_v413.z.undefined()]).optional(),
   addItems: import_v413.z.union([import_v413.z.array(setupPaymentAddItemPlanItemSchema), import_v413.z.undefined()]).optional(),
   removeItems: import_v413.z.union([import_v413.z.array(setupPaymentPlanItemFilterSchema), import_v413.z.undefined()]).optional(),
-  freeTrial: import_v413.z.union([setupPaymentFreeTrialParamsSchema, import_v413.z.undefined()]).optional().nullable()
+  freeTrial: import_v413.z.union([setupPaymentFreeTrialParamsSchema, import_v413.z.undefined()]).optional().nullable(),
+  billingControls: import_v413.z.union([setupPaymentBillingControlsSchema, import_v413.z.undefined()]).optional()
 });
 var setupPaymentProrationBehaviorSchema = closedEnumSchema8;
 var setupPaymentParamsSchema = import_v413.z.object({
@@ -23530,6 +26234,10 @@ var billingUpdateAddItemTierSchema = import_v414.z.object({
   amount: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional(),
   flatAmount: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional()
 });
+var billingUpdateOverageAllowedSchema = import_v414.z.object({
+  featureId: import_v414.z.string(),
+  enabled: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional()
+});
 var billingUpdateInvoiceModeSchema = import_v414.z.object({
   enabled: import_v414.z.boolean(),
   enablePlanImmediately: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
@@ -23665,12 +26373,56 @@ var billingUpdateFreeTrialParamsOutboundSchema = import_v414.z.object({
   card_required: import_v414.z.boolean(),
   on_end: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional()
 });
+var billingUpdatePurchaseLimitOutboundSchema = import_v414.z.object({
+  interval: import_v414.z.string(),
+  interval_count: import_v414.z.number(),
+  limit: import_v414.z.number()
+});
+var billingUpdateAutoTopupOutboundSchema = import_v414.z.object({
+  feature_id: import_v414.z.string(),
+  enabled: import_v414.z.boolean(),
+  threshold: import_v414.z.number(),
+  quantity: import_v414.z.number(),
+  purchase_limit: import_v414.z.union([billingUpdatePurchaseLimitOutboundSchema, import_v414.z.undefined()]).optional(),
+  invoice_mode: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional()
+});
+var billingUpdateSpendLimitOutboundSchema = import_v414.z.object({
+  feature_id: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
+  enabled: import_v414.z.boolean(),
+  limit_type: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
+  overage_limit: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional()
+});
+var billingUpdateUsageLimitOutboundSchema = import_v414.z.object({
+  feature_id: import_v414.z.string(),
+  enabled: import_v414.z.boolean(),
+  limit: import_v414.z.number(),
+  interval: import_v414.z.string()
+});
+var billingUpdateUsageAlertOutboundSchema = import_v414.z.object({
+  feature_id: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
+  enabled: import_v414.z.boolean(),
+  threshold: import_v414.z.number(),
+  threshold_type: import_v414.z.string(),
+  name: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional()
+});
+var billingUpdateOverageAllowedOutboundSchema = import_v414.z.object({
+  feature_id: import_v414.z.string(),
+  enabled: import_v414.z.boolean()
+});
+var billingUpdateBillingControlsOutboundSchema = import_v414.z.object({
+  auto_topups: import_v414.z.union([import_v414.z.array(billingUpdateAutoTopupOutboundSchema), import_v414.z.undefined()]).optional(),
+  spend_limits: import_v414.z.union([import_v414.z.array(billingUpdateSpendLimitOutboundSchema), import_v414.z.undefined()]).optional(),
+  usage_limits: import_v414.z.union([import_v414.z.array(billingUpdateUsageLimitOutboundSchema), import_v414.z.undefined()]).optional(),
+  usage_alerts: import_v414.z.union([import_v414.z.array(billingUpdateUsageAlertOutboundSchema), import_v414.z.undefined()]).optional(),
+  overage_allowed: import_v414.z.union([import_v414.z.array(billingUpdateOverageAllowedOutboundSchema), import_v414.z.undefined()]).optional()
+});
 var billingUpdateCustomizeOutboundSchema = import_v414.z.object({
   price: import_v414.z.union([billingUpdateBasePriceOutboundSchema, import_v414.z.undefined()]).optional().nullable(),
   items: import_v414.z.union([import_v414.z.array(billingUpdateItemPlanItemOutboundSchema), import_v414.z.undefined()]).optional(),
   add_items: import_v414.z.union([import_v414.z.array(billingUpdateAddItemPlanItemOutboundSchema), import_v414.z.undefined()]).optional(),
   remove_items: import_v414.z.union([import_v414.z.array(billingUpdatePlanItemFilterOutboundSchema), import_v414.z.undefined()]).optional(),
-  free_trial: import_v414.z.union([billingUpdateFreeTrialParamsOutboundSchema, import_v414.z.undefined()]).optional().nullable()
+  free_trial: import_v414.z.union([billingUpdateFreeTrialParamsOutboundSchema, import_v414.z.undefined()]).optional().nullable(),
+  billing_controls: import_v414.z.union([billingUpdateBillingControlsOutboundSchema, import_v414.z.undefined()]).optional()
 });
 var billingUpdateInvoiceModeOutboundSchema = import_v414.z.object({
   enabled: import_v414.z.boolean(),
@@ -23821,12 +26573,56 @@ var billingUpdateFreeTrialParamsSchema = import_v414.z.object({
   cardRequired: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
   onEnd: import_v414.z.union([billingUpdateOnEndSchema, import_v414.z.undefined()]).optional()
 });
+var billingUpdatePurchaseLimitIntervalSchema = closedEnumSchema9;
+var billingUpdatePurchaseLimitSchema = import_v414.z.object({
+  interval: billingUpdatePurchaseLimitIntervalSchema,
+  intervalCount: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional(),
+  limit: import_v414.z.number()
+});
+var billingUpdateAutoTopupSchema = import_v414.z.object({
+  featureId: import_v414.z.string(),
+  enabled: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
+  threshold: import_v414.z.number(),
+  quantity: import_v414.z.number(),
+  purchaseLimit: import_v414.z.union([billingUpdatePurchaseLimitSchema, import_v414.z.undefined()]).optional(),
+  invoiceMode: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional()
+});
+var billingUpdateLimitTypeSchema = closedEnumSchema9;
+var billingUpdateSpendLimitSchema = import_v414.z.object({
+  featureId: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
+  enabled: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
+  limitType: import_v414.z.union([billingUpdateLimitTypeSchema, import_v414.z.undefined()]).optional(),
+  overageLimit: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional()
+});
+var billingUpdateUsageLimitIntervalSchema = closedEnumSchema9;
+var billingUpdateUsageLimitSchema = import_v414.z.object({
+  featureId: import_v414.z.string(),
+  enabled: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
+  limit: import_v414.z.number(),
+  interval: billingUpdateUsageLimitIntervalSchema
+});
+var billingUpdateThresholdTypeSchema = closedEnumSchema9;
+var billingUpdateUsageAlertSchema = import_v414.z.object({
+  featureId: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
+  enabled: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
+  threshold: import_v414.z.number(),
+  thresholdType: billingUpdateThresholdTypeSchema,
+  name: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional()
+});
+var billingUpdateBillingControlsSchema = import_v414.z.object({
+  autoTopups: import_v414.z.union([import_v414.z.array(billingUpdateAutoTopupSchema), import_v414.z.undefined()]).optional(),
+  spendLimits: import_v414.z.union([import_v414.z.array(billingUpdateSpendLimitSchema), import_v414.z.undefined()]).optional(),
+  usageLimits: import_v414.z.union([import_v414.z.array(billingUpdateUsageLimitSchema), import_v414.z.undefined()]).optional(),
+  usageAlerts: import_v414.z.union([import_v414.z.array(billingUpdateUsageAlertSchema), import_v414.z.undefined()]).optional(),
+  overageAllowed: import_v414.z.union([import_v414.z.array(billingUpdateOverageAllowedSchema), import_v414.z.undefined()]).optional()
+});
 var billingUpdateCustomizeSchema = import_v414.z.object({
   price: import_v414.z.union([billingUpdateBasePriceSchema, import_v414.z.undefined()]).optional().nullable(),
   items: import_v414.z.union([import_v414.z.array(billingUpdateItemPlanItemSchema), import_v414.z.undefined()]).optional(),
   addItems: import_v414.z.union([import_v414.z.array(billingUpdateAddItemPlanItemSchema), import_v414.z.undefined()]).optional(),
   removeItems: import_v414.z.union([import_v414.z.array(billingUpdatePlanItemFilterSchema), import_v414.z.undefined()]).optional(),
-  freeTrial: import_v414.z.union([billingUpdateFreeTrialParamsSchema, import_v414.z.undefined()]).optional().nullable()
+  freeTrial: import_v414.z.union([billingUpdateFreeTrialParamsSchema, import_v414.z.undefined()]).optional().nullable(),
+  billingControls: import_v414.z.union([billingUpdateBillingControlsSchema, import_v414.z.undefined()]).optional()
 });
 var billingUpdateProrationBehaviorSchema = closedEnumSchema9;
 var billingUpdateRedirectModeSchema = closedEnumSchema9;