autumn-js 1.3.37 → 1.3.39

package/dist/backend/core/index.js

@@ -86,8 +86,8 @@ var SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "2.4.0",
   sdkVersion: "0.10.18",
-  genVersion: "2.882.0",
-  userAgent: "speakeasy-sdk/typescript 0.10.18 2.882.0 2.4.0 @useautumn/sdk"
+  genVersion: "2.884.13",
+  userAgent: "speakeasy-sdk/typescript 0.10.18 2.884.13 2.4.0 @useautumn/sdk"
 };
 
 // ../sdk/src/lib/http.ts
@@ -12581,7 +12581,7 @@ var CreatePlanDimensionsToItemRequestBodyEnum1 = {
 var CreatePlanToItemRequestBodyEnum = {
   Inf: "inf"
 };
-var CreatePlanPriceLicenseInterval = {
+var CreatePlanPriceLicenseIntervalRequestBody = {
   OneOff: "one_off",
   Week: "week",
   Month: "month",
@@ -12589,7 +12589,7 @@ var CreatePlanPriceLicenseInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var CreatePlanLicenseResetInterval = {
+var CreatePlanLicenseResetIntervalRequestBody = {
   OneOff: "one_off",
   Minute: "minute",
   Hour: "hour",
@@ -12600,11 +12600,11 @@ var CreatePlanLicenseResetInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var CreatePlanLicenseTierBehavior = {
+var CreatePlanLicenseTierBehaviorRequestBody = {
   Graduated: "graduated",
   Volume: "volume"
 };
-var CreatePlanLicenseAddItemPriceInterval = {
+var CreatePlanAddItemPriceIntervalRequestBody = {
   OneOff: "one_off",
   Week: "week",
   Month: "month",
@@ -12612,47 +12612,47 @@ var CreatePlanLicenseAddItemPriceInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var CreatePlanLicenseAddItemBillingMethod = {
+var CreatePlanAddItemBillingMethodRequestBody = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
-var CreatePlanLicenseOnIncrease = {
+var CreatePlanLicenseOnIncreaseRequestBody = {
   BillImmediately: "bill_immediately",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
   BillNextCycle: "bill_next_cycle"
 };
-var CreatePlanLicenseOnDecrease = {
+var CreatePlanLicenseOnDecreaseRequestBody = {
   Prorate: "prorate",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
   None: "none",
   NoProrations: "no_prorations"
 };
-var CreatePlanLicenseExpiryDurationType = {
+var CreatePlanLicenseExpiryDurationTypeRequestBody = {
   Month: "month",
   Forever: "forever"
 };
-var CreatePlanLicenseDuration = {
+var CreatePlanLicenseDurationRequestBody = {
   Day: "day",
   Week: "week",
   Month: "month",
   Year: "year"
 };
-var CreatePlanDimensionsToLicenseEnum2 = {
+var CreatePlanDimensionsToLicenseRequestBodyEnum2 = {
   Inf: "inf"
 };
-var CreatePlanDimensionsToLicenseEnum1 = {
+var CreatePlanDimensionsToLicenseRequestBodyEnum1 = {
   Inf: "inf"
 };
-var CreatePlanToLicenseEnum = {
+var CreatePlanToLicenseRequestBodyEnum = {
   Inf: "inf"
 };
-var CreatePlanLicenseRemoveItemBillingMethod = {
+var CreatePlanRemoveItemBillingMethodRequestBody = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
-var CreatePlanIntervalLicenseRemoveItemEnum2 = {
+var CreatePlanIntervalRemoveItemRequestBodyEnum2 = {
   OneOff: "one_off",
   Minute: "minute",
   Hour: "hour",
@@ -12663,7 +12663,7 @@ var CreatePlanIntervalLicenseRemoveItemEnum2 = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var CreatePlanIntervalLicenseRemoveItemEnum1 = {
+var CreatePlanIntervalRemoveItemRequestBodyEnum1 = {
   OneOff: "one_off",
   Week: "week",
   Month: "month",
@@ -13186,19 +13186,21 @@ var CreatePlanItemPlanItem$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanPriceLicenseInterval$outboundSchema = z27.enum(CreatePlanPriceLicenseInterval);
-var CreatePlanLicenseAdditionalCurrency$outboundSchema = z27.object({
+var CreatePlanPriceLicenseIntervalRequestBody$outboundSchema = z27.enum(
+  CreatePlanPriceLicenseIntervalRequestBody
+);
+var CreatePlanLicenseAdditionalCurrencyRequestBody$outboundSchema = z27.object({
   currency: z27.string(),
   amount: z27.number()
 });
-var CreatePlanLicenseBasePrice$outboundSchema = z27.pipe(
+var CreatePlanBasePriceRequestBody$outboundSchema = z27.pipe(
   z27.object({
     amount: z27.number(),
-    interval: CreatePlanPriceLicenseInterval$outboundSchema,
+    interval: CreatePlanPriceLicenseIntervalRequestBody$outboundSchema,
     intervalCount: z27._default(z27.number(), 1),
-    additionalCurrencies: z27.optional(
-      z27.array(z27.lazy(() => CreatePlanLicenseAdditionalCurrency$outboundSchema))
-    )
+    additionalCurrencies: z27.optional(z27.array(z27.lazy(
+      () => CreatePlanLicenseAdditionalCurrencyRequestBody$outboundSchema
+    )))
   }),
   z27.transform((v) => {
     return remap(v, {
@@ -13207,13 +13209,15 @@ var CreatePlanLicenseBasePrice$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseThresholdBilling$outboundSchema = z27.object({
+var CreatePlanLicenseThresholdBillingRequestBody$outboundSchema = z27.object({
   threshold: z27.number()
 });
-var CreatePlanLicenseResetInterval$outboundSchema = z27.enum(CreatePlanLicenseResetInterval);
-var CreatePlanLicenseReset$outboundSchema = z27.pipe(
+var CreatePlanLicenseResetIntervalRequestBody$outboundSchema = z27.enum(
+  CreatePlanLicenseResetIntervalRequestBody
+);
+var CreatePlanLicenseResetRequestBody$outboundSchema = z27.pipe(
   z27.object({
-    interval: CreatePlanLicenseResetInterval$outboundSchema,
+    interval: CreatePlanLicenseResetIntervalRequestBody$outboundSchema,
     intervalCount: z27._default(z27.number(), 1)
   }),
   z27.transform((v) => {
@@ -13222,12 +13226,12 @@ var CreatePlanLicenseReset$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseAddItemAdditionalCurrency$outboundSchema = z27.object({
+var CreatePlanAddItemAdditionalCurrencyRequestBody$outboundSchema = z27.object({
   currency: z27.string(),
   amount: z27.number()
 });
-var CreatePlanLicensePriceTo$outboundSchema = smartUnion([z27.number(), z27.string()]);
-var CreatePlanLicenseTierAdditionalCurrency$outboundSchema = z27.pipe(
+var CreatePlanLicensePriceToRequestBody$outboundSchema = smartUnion([z27.number(), z27.string()]);
+var CreatePlanLicenseTierAdditionalCurrencyRequestBody$outboundSchema = z27.pipe(
   z27.object({
     currency: z27.string(),
     amount: z27.optional(z27.number()),
@@ -13239,13 +13243,13 @@ var CreatePlanLicenseTierAdditionalCurrency$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicensePriceTier$outboundSchema = z27.pipe(
+var CreatePlanLicensePriceTierRequestBody$outboundSchema = z27.pipe(
   z27.object({
     to: smartUnion([z27.number(), z27.string()]),
     amount: z27.optional(z27.number()),
     flatAmount: z27.optional(z27.number()),
     additionalCurrencies: z27.optional(z27.array(z27.lazy(
-      () => CreatePlanLicenseTierAdditionalCurrency$outboundSchema
+      () => CreatePlanLicenseTierAdditionalCurrencyRequestBody$outboundSchema
     )))
   }),
   z27.transform((v) => {
@@ -13255,27 +13259,31 @@ var CreatePlanLicensePriceTier$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseTierBehavior$outboundSchema = z27.enum(CreatePlanLicenseTierBehavior);
-var CreatePlanLicenseAddItemPriceInterval$outboundSchema = z27.enum(
-  CreatePlanLicenseAddItemPriceInterval
+var CreatePlanLicenseTierBehaviorRequestBody$outboundSchema = z27.enum(
+  CreatePlanLicenseTierBehaviorRequestBody
+);
+var CreatePlanAddItemPriceIntervalRequestBody$outboundSchema = z27.enum(
+  CreatePlanAddItemPriceIntervalRequestBody
 );
-var CreatePlanLicenseAddItemBillingMethod$outboundSchema = z27.enum(
-  CreatePlanLicenseAddItemBillingMethod
+var CreatePlanAddItemBillingMethodRequestBody$outboundSchema = z27.enum(
+  CreatePlanAddItemBillingMethodRequestBody
 );
-var CreatePlanLicensePrice$outboundSchema = z27.pipe(
+var CreatePlanLicensePriceRequestBody$outboundSchema = z27.pipe(
   z27.object({
     amount: z27.optional(z27.number()),
     additionalCurrencies: z27.optional(z27.array(z27.lazy(
-      () => CreatePlanLicenseAddItemAdditionalCurrency$outboundSchema
+      () => CreatePlanAddItemAdditionalCurrencyRequestBody$outboundSchema
     ))),
     tiers: z27.optional(z27.array(z27.lazy(
-      () => CreatePlanLicensePriceTier$outboundSchema
+      () => CreatePlanLicensePriceTierRequestBody$outboundSchema
     ))),
-    tierBehavior: z27.optional(CreatePlanLicenseTierBehavior$outboundSchema),
-    interval: CreatePlanLicenseAddItemPriceInterval$outboundSchema,
+    tierBehavior: z27.optional(
+      CreatePlanLicenseTierBehaviorRequestBody$outboundSchema
+    ),
+    interval: CreatePlanAddItemPriceIntervalRequestBody$outboundSchema,
     intervalCount: z27._default(z27.number(), 1),
     billingUnits: z27._default(z27.number(), 1),
-    billingMethod: CreatePlanLicenseAddItemBillingMethod$outboundSchema,
+    billingMethod: CreatePlanAddItemBillingMethodRequestBody$outboundSchema,
     maxPurchase: z27.optional(z27.nullable(z27.number()))
   }),
   z27.transform((v) => {
@@ -13289,12 +13297,16 @@ var CreatePlanLicensePrice$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseOnIncrease$outboundSchema = z27.enum(CreatePlanLicenseOnIncrease);
-var CreatePlanLicenseOnDecrease$outboundSchema = z27.enum(CreatePlanLicenseOnDecrease);
-var CreatePlanLicenseProration$outboundSchema = z27.pipe(
+var CreatePlanLicenseOnIncreaseRequestBody$outboundSchema = z27.enum(
+  CreatePlanLicenseOnIncreaseRequestBody
+);
+var CreatePlanLicenseOnDecreaseRequestBody$outboundSchema = z27.enum(
+  CreatePlanLicenseOnDecreaseRequestBody
+);
+var CreatePlanLicenseProrationRequestBody$outboundSchema = z27.pipe(
   z27.object({
-    onIncrease: CreatePlanLicenseOnIncrease$outboundSchema,
-    onDecrease: CreatePlanLicenseOnDecrease$outboundSchema
+    onIncrease: CreatePlanLicenseOnIncreaseRequestBody$outboundSchema,
+    onDecrease: CreatePlanLicenseOnDecreaseRequestBody$outboundSchema
   }),
   z27.transform((v) => {
     return remap(v, {
@@ -13303,12 +13315,14 @@ var CreatePlanLicenseProration$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseExpiryDurationType$outboundSchema = z27.enum(CreatePlanLicenseExpiryDurationType);
-var CreatePlanLicenseRollover$outboundSchema = z27.pipe(
+var CreatePlanLicenseExpiryDurationTypeRequestBody$outboundSchema = z27.enum(
+  CreatePlanLicenseExpiryDurationTypeRequestBody
+);
+var CreatePlanLicenseRolloverRequestBody$outboundSchema = z27.pipe(
   z27.object({
     max: z27.optional(z27.number()),
     maxPercentage: z27.optional(z27.number()),
-    expiryDurationType: CreatePlanLicenseExpiryDurationType$outboundSchema,
+    expiryDurationType: CreatePlanLicenseExpiryDurationTypeRequestBody$outboundSchema,
     expiryDurationLength: z27.optional(z27.number())
   }),
   z27.transform((v) => {
@@ -13319,13 +13333,13 @@ var CreatePlanLicenseRollover$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseDuration$outboundSchema = z27.enum(CreatePlanLicenseDuration);
-var CreatePlanLicenseExpiry$outboundSchema = z27.object({
-  duration: CreatePlanLicenseDuration$outboundSchema,
+var CreatePlanLicenseDurationRequestBody$outboundSchema = z27.enum(CreatePlanLicenseDurationRequestBody);
+var CreatePlanLicenseExpiryRequestBody$outboundSchema = z27.object({
+  duration: CreatePlanLicenseDurationRequestBody$outboundSchema,
   length: z27.number()
 });
 var CreatePlanDimensionsLicenseMatch4$outboundSchema = smartUnion([z27.string(), z27.number(), z27.boolean()]);
-var CreatePlanDimensionsLicense4$outboundSchema = z27.pipe(
+var CreatePlanDimensionsLicenseRequestBody4$outboundSchema = z27.pipe(
   z27.object({
     match: z27.record(
       z27.string(),
@@ -13341,13 +13355,18 @@ var CreatePlanDimensionsLicense4$outboundSchema = z27.pipe(
   })
 );
 var CreatePlanDimensionsLicenseMatch3$outboundSchema = smartUnion([z27.string(), z27.number(), z27.boolean()]);
-var CreatePlanDimensionsToLicenseEnum2$outboundSchema = z27.enum(CreatePlanDimensionsToLicenseEnum2);
-var CreatePlanDimensionsLicenseToUnion2$outboundSchema = smartUnion([z27.number(), CreatePlanDimensionsToLicenseEnum2$outboundSchema]);
-var CreatePlanDimensionsLicenseTier2$outboundSchema = z27.pipe(
+var CreatePlanDimensionsToLicenseRequestBodyEnum2$outboundSchema = z27.enum(
+  CreatePlanDimensionsToLicenseRequestBodyEnum2
+);
+var CreatePlanDimensionsLicenseToRequestBodyUnion2$outboundSchema = smartUnion([
+  z27.number(),
+  CreatePlanDimensionsToLicenseRequestBodyEnum2$outboundSchema
+]);
+var CreatePlanDimensionsLicenseTierRequestBody2$outboundSchema = z27.pipe(
   z27.object({
     to: smartUnion([
       z27.number(),
-      CreatePlanDimensionsToLicenseEnum2$outboundSchema
+      CreatePlanDimensionsToLicenseRequestBodyEnum2$outboundSchema
     ]),
     creditCost: z27.number()
   }),
@@ -13357,7 +13376,7 @@ var CreatePlanDimensionsLicenseTier2$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanDimensionsLicense3$outboundSchema = z27.pipe(
+var CreatePlanDimensionsLicenseRequestBody3$outboundSchema = z27.pipe(
   z27.object({
     match: z27.record(
       z27.string(),
@@ -13366,7 +13385,9 @@ var CreatePlanDimensionsLicense3$outboundSchema = z27.pipe(
     priority: z27.optional(z27.int()),
     tierBehavior: z27.literal("graduated"),
     tiers: z27.array(
-      z27.lazy(() => CreatePlanDimensionsLicenseTier2$outboundSchema)
+      z27.lazy(
+        () => CreatePlanDimensionsLicenseTierRequestBody2$outboundSchema
+      )
     )
   }),
   z27.transform((v) => {
@@ -13375,12 +13396,12 @@ var CreatePlanDimensionsLicense3$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseDimensionsUnion2$outboundSchema = smartUnion([
-  z27.lazy(() => CreatePlanDimensionsLicense3$outboundSchema),
-  z27.lazy(() => CreatePlanDimensionsLicense4$outboundSchema)
+var CreatePlanLicenseDimensionsRequestBodyUnion2$outboundSchema = smartUnion([
+  z27.lazy(() => CreatePlanDimensionsLicenseRequestBody3$outboundSchema),
+  z27.lazy(() => CreatePlanDimensionsLicenseRequestBody4$outboundSchema)
 ]);
 var CreatePlanLicenseMultipliersMatch2$outboundSchema = smartUnion([z27.string(), z27.number(), z27.boolean()]);
-var CreatePlanLicenseMultipliers2$outboundSchema = z27.object({
+var CreatePlanLicenseMultipliersRequestBody2$outboundSchema = z27.object({
   match: z27.record(
     z27.string(),
     smartUnion([z27.string(), z27.number(), z27.boolean()])
@@ -13388,20 +13409,20 @@ var CreatePlanLicenseMultipliers2$outboundSchema = z27.object({
   factor: z27.optional(z27.number()),
   add: z27.optional(z27.number())
 });
-var CreatePlanCreditSchemaLicense2$outboundSchema = z27.pipe(
+var CreatePlanCreditSchemaLicenseRequestBody2$outboundSchema = z27.pipe(
   z27.object({
     meteredFeatureId: z27.string(),
     billingUnits: z27.optional(z27.number()),
     dimensions: z27.optional(z27.record(
       z27.string(),
       smartUnion([
-        z27.lazy(() => CreatePlanDimensionsLicense3$outboundSchema),
-        z27.lazy(() => CreatePlanDimensionsLicense4$outboundSchema)
+        z27.lazy(() => CreatePlanDimensionsLicenseRequestBody3$outboundSchema),
+        z27.lazy(() => CreatePlanDimensionsLicenseRequestBody4$outboundSchema)
       ])
     )),
     multipliers: z27.optional(z27.record(
       z27.string(),
-      z27.lazy(() => CreatePlanLicenseMultipliers2$outboundSchema)
+      z27.lazy(() => CreatePlanLicenseMultipliersRequestBody2$outboundSchema)
     )),
     creditCost: z27.number()
   }),
@@ -13414,7 +13435,7 @@ var CreatePlanCreditSchemaLicense2$outboundSchema = z27.pipe(
   })
 );
 var CreatePlanDimensionsLicenseMatch2$outboundSchema = smartUnion([z27.string(), z27.number(), z27.boolean()]);
-var CreatePlanDimensionsLicense2$outboundSchema = z27.pipe(
+var CreatePlanDimensionsLicenseRequestBody2$outboundSchema = z27.pipe(
   z27.object({
     match: z27.record(
       z27.string(),
@@ -13430,13 +13451,18 @@ var CreatePlanDimensionsLicense2$outboundSchema = z27.pipe(
   })
 );
 var CreatePlanDimensionsLicenseMatch1$outboundSchema = smartUnion([z27.string(), z27.number(), z27.boolean()]);
-var CreatePlanDimensionsToLicenseEnum1$outboundSchema = z27.enum(CreatePlanDimensionsToLicenseEnum1);
-var CreatePlanDimensionsLicenseToUnion1$outboundSchema = smartUnion([z27.number(), CreatePlanDimensionsToLicenseEnum1$outboundSchema]);
-var CreatePlanDimensionsLicenseTier1$outboundSchema = z27.pipe(
+var CreatePlanDimensionsToLicenseRequestBodyEnum1$outboundSchema = z27.enum(
+  CreatePlanDimensionsToLicenseRequestBodyEnum1
+);
+var CreatePlanDimensionsLicenseToRequestBodyUnion1$outboundSchema = smartUnion([
+  z27.number(),
+  CreatePlanDimensionsToLicenseRequestBodyEnum1$outboundSchema
+]);
+var CreatePlanDimensionsLicenseTierRequestBody1$outboundSchema = z27.pipe(
   z27.object({
     to: smartUnion([
       z27.number(),
-      CreatePlanDimensionsToLicenseEnum1$outboundSchema
+      CreatePlanDimensionsToLicenseRequestBodyEnum1$outboundSchema
     ]),
     creditCost: z27.number()
   }),
@@ -13446,7 +13472,7 @@ var CreatePlanDimensionsLicenseTier1$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanDimensionsLicense1$outboundSchema = z27.pipe(
+var CreatePlanDimensionsLicenseRequestBody1$outboundSchema = z27.pipe(
   z27.object({
     match: z27.record(
       z27.string(),
@@ -13455,7 +13481,9 @@ var CreatePlanDimensionsLicense1$outboundSchema = z27.pipe(
     priority: z27.optional(z27.int()),
     tierBehavior: z27.literal("graduated"),
     tiers: z27.array(
-      z27.lazy(() => CreatePlanDimensionsLicenseTier1$outboundSchema)
+      z27.lazy(
+        () => CreatePlanDimensionsLicenseTierRequestBody1$outboundSchema
+      )
     )
   }),
   z27.transform((v) => {
@@ -13464,12 +13492,12 @@ var CreatePlanDimensionsLicense1$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseDimensionsUnion1$outboundSchema = smartUnion([
-  z27.lazy(() => CreatePlanDimensionsLicense1$outboundSchema),
-  z27.lazy(() => CreatePlanDimensionsLicense2$outboundSchema)
+var CreatePlanLicenseDimensionsRequestBodyUnion1$outboundSchema = smartUnion([
+  z27.lazy(() => CreatePlanDimensionsLicenseRequestBody1$outboundSchema),
+  z27.lazy(() => CreatePlanDimensionsLicenseRequestBody2$outboundSchema)
 ]);
 var CreatePlanLicenseMultipliersMatch1$outboundSchema = smartUnion([z27.string(), z27.number(), z27.boolean()]);
-var CreatePlanLicenseMultipliers1$outboundSchema = z27.object({
+var CreatePlanLicenseMultipliersRequestBody1$outboundSchema = z27.object({
   match: z27.record(
     z27.string(),
     smartUnion([z27.string(), z27.number(), z27.boolean()])
@@ -13477,11 +13505,17 @@ var CreatePlanLicenseMultipliers1$outboundSchema = z27.object({
   factor: z27.optional(z27.number()),
   add: z27.optional(z27.number())
 });
-var CreatePlanToLicenseEnum$outboundSchema = z27.enum(CreatePlanToLicenseEnum);
-var CreatePlanLicenseFeatureOverrideToUnion$outboundSchema = smartUnion([z27.number(), CreatePlanToLicenseEnum$outboundSchema]);
-var CreatePlanLicenseFeatureOverrideTier$outboundSchema = z27.pipe(
+var CreatePlanToLicenseRequestBodyEnum$outboundSchema = z27.enum(CreatePlanToLicenseRequestBodyEnum);
+var CreatePlanLicenseFeatureOverrideToRequestBodyUnion$outboundSchema = smartUnion([
+  z27.number(),
+  CreatePlanToLicenseRequestBodyEnum$outboundSchema
+]);
+var CreatePlanLicenseFeatureOverrideTierRequestBody$outboundSchema = z27.pipe(
   z27.object({
-    to: smartUnion([z27.number(), CreatePlanToLicenseEnum$outboundSchema]),
+    to: smartUnion([
+      z27.number(),
+      CreatePlanToLicenseRequestBodyEnum$outboundSchema
+    ]),
     creditCost: z27.number()
   }),
   z27.transform((v) => {
@@ -13490,24 +13524,24 @@ var CreatePlanLicenseFeatureOverrideTier$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanCreditSchemaLicense1$outboundSchema = z27.pipe(
+var CreatePlanCreditSchemaLicenseRequestBody1$outboundSchema = z27.pipe(
   z27.object({
     meteredFeatureId: z27.string(),
     billingUnits: z27.optional(z27.number()),
     dimensions: z27.optional(z27.record(
       z27.string(),
       smartUnion([
-        z27.lazy(() => CreatePlanDimensionsLicense1$outboundSchema),
-        z27.lazy(() => CreatePlanDimensionsLicense2$outboundSchema)
+        z27.lazy(() => CreatePlanDimensionsLicenseRequestBody1$outboundSchema),
+        z27.lazy(() => CreatePlanDimensionsLicenseRequestBody2$outboundSchema)
       ])
     )),
     multipliers: z27.optional(z27.record(
       z27.string(),
-      z27.lazy(() => CreatePlanLicenseMultipliers1$outboundSchema)
+      z27.lazy(() => CreatePlanLicenseMultipliersRequestBody1$outboundSchema)
     )),
     tierBehavior: z27.literal("graduated"),
     tiers: z27.array(z27.lazy(
-      () => CreatePlanLicenseFeatureOverrideTier$outboundSchema
+      () => CreatePlanLicenseFeatureOverrideTierRequestBody$outboundSchema
     ))
   }),
   z27.transform((v) => {
@@ -13518,14 +13552,14 @@ var CreatePlanCreditSchemaLicense1$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseCreditSchemaUnion$outboundSchema = smartUnion([
-  z27.lazy(() => CreatePlanCreditSchemaLicense1$outboundSchema),
-  z27.lazy(() => CreatePlanCreditSchemaLicense2$outboundSchema)
+var CreatePlanLicenseCreditSchemaRequestBodyUnion$outboundSchema = smartUnion([
+  z27.lazy(() => CreatePlanCreditSchemaLicenseRequestBody1$outboundSchema),
+  z27.lazy(() => CreatePlanCreditSchemaLicenseRequestBody2$outboundSchema)
 ]);
-var CreatePlanLicenseProviderMarkups$outboundSchema = z27.object({
+var CreatePlanLicenseProviderMarkupsRequestBody$outboundSchema = z27.object({
   markup: z27.number()
 });
-var CreatePlanLicenseModelMarkups$outboundSchema = z27.pipe(
+var CreatePlanLicenseModelMarkupsRequestBody$outboundSchema = z27.pipe(
   z27.object({
     markup: z27.optional(z27.number()),
     inputCost: z27.optional(z27.number()),
@@ -13538,16 +13572,16 @@ var CreatePlanLicenseModelMarkups$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseMarkups$outboundSchema = z27.pipe(
+var CreatePlanLicenseMarkupsRequestBody$outboundSchema = z27.pipe(
   z27.object({
     defaultMarkup: z27.optional(z27.number()),
     providerMarkups: z27.optional(z27.nullable(z27.record(
       z27.string(),
-      z27.lazy(() => CreatePlanLicenseProviderMarkups$outboundSchema)
+      z27.lazy(() => CreatePlanLicenseProviderMarkupsRequestBody$outboundSchema)
     ))),
     modelMarkups: z27.optional(z27.nullable(z27.record(
       z27.string(),
-      z27.lazy(() => CreatePlanLicenseModelMarkups$outboundSchema)
+      z27.lazy(() => CreatePlanLicenseModelMarkupsRequestBody$outboundSchema)
     )))
   }),
   z27.transform((v) => {
@@ -13558,16 +13592,16 @@ var CreatePlanLicenseMarkups$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseFeatureOverride$outboundSchema = z27.pipe(
+var CreatePlanLicenseFeatureOverrideRequestBody$outboundSchema = z27.pipe(
   z27.object({
     creditSchema: z27.optional(z27.array(smartUnion([
-      z27.lazy(() => CreatePlanCreditSchemaLicense1$outboundSchema),
+      z27.lazy(() => CreatePlanCreditSchemaLicenseRequestBody1$outboundSchema),
       z27.lazy(
-        () => CreatePlanCreditSchemaLicense2$outboundSchema
+        () => CreatePlanCreditSchemaLicenseRequestBody2$outboundSchema
       )
     ]))),
     markups: z27.optional(z27.lazy(
-      () => CreatePlanLicenseMarkups$outboundSchema
+      () => CreatePlanLicenseMarkupsRequestBody$outboundSchema
     ))
   }),
   z27.transform((v) => {
@@ -13576,29 +13610,33 @@ var CreatePlanLicenseFeatureOverride$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicensePlanItem$outboundSchema = z27.pipe(
+var CreatePlanLicensePlanItemRequestBody$outboundSchema = z27.pipe(
   z27.object({
-    thresholdBilling: z27.optional(
-      z27.nullable(
-        z27.lazy(() => CreatePlanLicenseThresholdBilling$outboundSchema)
-      )
-    ),
+    thresholdBilling: z27.optional(z27.nullable(z27.lazy(
+      () => CreatePlanLicenseThresholdBillingRequestBody$outboundSchema
+    ))),
     featureId: z27.string(),
     included: z27.optional(z27.number()),
     unlimited: z27.optional(z27.boolean()),
     pooled: z27._default(z27.boolean(), false),
-    reset: z27.optional(z27.lazy(() => CreatePlanLicenseReset$outboundSchema)),
-    price: z27.optional(z27.lazy(() => CreatePlanLicensePrice$outboundSchema)),
-    proration: z27.optional(
-      z27.lazy(() => CreatePlanLicenseProration$outboundSchema)
-    ),
-    rollover: z27.optional(
-      z27.lazy(() => CreatePlanLicenseRollover$outboundSchema)
-    ),
-    expiry: z27.optional(z27.lazy(() => CreatePlanLicenseExpiry$outboundSchema)),
-    featureOverride: z27.optional(
-      z27.lazy(() => CreatePlanLicenseFeatureOverride$outboundSchema)
-    )
+    reset: z27.optional(z27.lazy(
+      () => CreatePlanLicenseResetRequestBody$outboundSchema
+    )),
+    price: z27.optional(z27.lazy(
+      () => CreatePlanLicensePriceRequestBody$outboundSchema
+    )),
+    proration: z27.optional(z27.lazy(
+      () => CreatePlanLicenseProrationRequestBody$outboundSchema
+    )),
+    rollover: z27.optional(z27.lazy(
+      () => CreatePlanLicenseRolloverRequestBody$outboundSchema
+    )),
+    expiry: z27.optional(z27.lazy(
+      () => CreatePlanLicenseExpiryRequestBody$outboundSchema
+    )),
+    featureOverride: z27.optional(z27.lazy(
+      () => CreatePlanLicenseFeatureOverrideRequestBody$outboundSchema
+    ))
   }),
   z27.transform((v) => {
     return remap(v, {
@@ -13608,29 +13646,29 @@ var CreatePlanLicensePlanItem$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseRemoveItemBillingMethod$outboundSchema = z27.enum(
-  CreatePlanLicenseRemoveItemBillingMethod
+var CreatePlanRemoveItemBillingMethodRequestBody$outboundSchema = z27.enum(
+  CreatePlanRemoveItemBillingMethodRequestBody
 );
-var CreatePlanIntervalLicenseRemoveItemEnum2$outboundSchema = z27.enum(
-  CreatePlanIntervalLicenseRemoveItemEnum2
+var CreatePlanIntervalRemoveItemRequestBodyEnum2$outboundSchema = z27.enum(
+  CreatePlanIntervalRemoveItemRequestBodyEnum2
 );
-var CreatePlanIntervalLicenseRemoveItemEnum1$outboundSchema = z27.enum(
-  CreatePlanIntervalLicenseRemoveItemEnum1
+var CreatePlanIntervalRemoveItemRequestBodyEnum1$outboundSchema = z27.enum(
+  CreatePlanIntervalRemoveItemRequestBodyEnum1
 );
-var CreatePlanLicenseIntervalUnion$outboundSchema = smartUnion([
-  CreatePlanIntervalLicenseRemoveItemEnum1$outboundSchema,
-  CreatePlanIntervalLicenseRemoveItemEnum2$outboundSchema
+var CreatePlanIntervalRequestBodyUnion$outboundSchema = smartUnion([
+  CreatePlanIntervalRemoveItemRequestBodyEnum1$outboundSchema,
+  CreatePlanIntervalRemoveItemRequestBodyEnum2$outboundSchema
 ]);
-var CreatePlanLicensePlanItemFilter$outboundSchema = z27.pipe(
+var CreatePlanPlanItemFilterRequestBody$outboundSchema = z27.pipe(
   z27.object({
     featureId: z27.optional(z27.string()),
     billingMethod: z27.optional(
-      CreatePlanLicenseRemoveItemBillingMethod$outboundSchema
+      CreatePlanRemoveItemBillingMethodRequestBody$outboundSchema
     ),
     interval: z27.optional(
       smartUnion([
-        CreatePlanIntervalLicenseRemoveItemEnum1$outboundSchema,
-        CreatePlanIntervalLicenseRemoveItemEnum2$outboundSchema
+        CreatePlanIntervalRemoveItemRequestBodyEnum1$outboundSchema,
+        CreatePlanIntervalRemoveItemRequestBodyEnum2$outboundSchema
       ])
     ),
     intervalCount: z27.optional(z27.int()),
@@ -13644,16 +13682,18 @@ var CreatePlanLicensePlanItemFilter$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicenseCustomize$outboundSchema = z27.pipe(
+var CreatePlanCustomizeRequestBody$outboundSchema = z27.pipe(
   z27.object({
     price: z27.optional(
-      z27.nullable(z27.lazy(() => CreatePlanLicenseBasePrice$outboundSchema))
+      z27.nullable(z27.lazy(() => CreatePlanBasePriceRequestBody$outboundSchema))
     ),
     addItems: z27.optional(
-      z27.array(z27.lazy(() => CreatePlanLicensePlanItem$outboundSchema))
+      z27.array(
+        z27.lazy(() => CreatePlanLicensePlanItemRequestBody$outboundSchema)
+      )
     ),
     removeItems: z27.optional(
-      z27.array(z27.lazy(() => CreatePlanLicensePlanItemFilter$outboundSchema))
+      z27.array(z27.lazy(() => CreatePlanPlanItemFilterRequestBody$outboundSchema))
     )
   }),
   z27.transform((v) => {
@@ -13663,14 +13703,14 @@ var CreatePlanLicenseCustomize$outboundSchema = z27.pipe(
     });
   })
 );
-var CreatePlanLicense$outboundSchema = z27.pipe(
+var CreatePlanLicenseRequest$outboundSchema = z27.pipe(
   z27.object({
     licensePlanId: z27.string(),
     versionSlug: z27.optional(z27.string()),
     included: z27.optional(z27.int()),
     prepaidOnly: z27.optional(z27.boolean()),
     customize: z27.optional(
-      z27.nullable(z27.lazy(() => CreatePlanLicenseCustomize$outboundSchema))
+      z27.nullable(z27.lazy(() => CreatePlanCustomizeRequestBody$outboundSchema))
     ),
     metadata: z27.optional(z27.record(z27.string(), z27.any()))
   }),
@@ -13876,7 +13916,7 @@ var CreatePlanParams$outboundSchema = z27.pipe(
       z27.array(z27.lazy(() => CreatePlanItemPlanItem$outboundSchema))
     ),
     licenses: z27.optional(
-      z27.array(z27.lazy(() => CreatePlanLicense$outboundSchema))
+      z27.array(z27.lazy(() => CreatePlanLicenseRequest$outboundSchema))
     ),
     freeTrial: z27.optional(z27.lazy(() => FreeTrialRequestBody$outboundSchema)),
     config: z27.optional(
@@ -14147,17 +14187,17 @@ var CreatePlanVariantDetailsAddItemPriceInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var CreatePlanAddItemBillingMethodResponse = {
+var CreatePlanVariantDetailsAddItemBillingMethod = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
-var CreatePlanOnIncreaseResponse = {
+var CreatePlanVariantDetailsOnIncrease = {
   BillImmediately: "bill_immediately",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
   BillNextCycle: "bill_next_cycle"
 };
-var CreatePlanOnDecreaseResponse = {
+var CreatePlanVariantDetailsOnDecrease = {
   Prorate: "prorate",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
@@ -14183,7 +14223,7 @@ var CreatePlanDimensionsToVariantDetailsEnum1 = {
 var CreatePlanToVariantDetailsEnum = {
   Inf: "inf"
 };
-var CreatePlanRemoveItemBillingMethodResponse = {
+var CreatePlanVariantDetailsRemoveItemBillingMethod = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
@@ -14908,7 +14948,7 @@ var CreatePlanVariantDetailsAdditionalCurrency$inboundSchema = z28.object(
     amount: number2()
   }
 );
-var CreatePlanBasePriceResponse$inboundSchema = z28.pipe(
+var CreatePlanVariantDetailsBasePrice$inboundSchema = z28.pipe(
   z28.object({
     amount: number2(),
     interval: CreatePlanPriceVariantDetailsInterval$inboundSchema,
@@ -14939,7 +14979,7 @@ var CreatePlanVariantDetailsReset$inboundSchema = z28.pipe(
     });
   })
 );
-var CreatePlanAddItemAdditionalCurrencyResponse$inboundSchema = z28.object({
+var CreatePlanVariantDetailsAddItemAdditionalCurrency$inboundSchema = z28.object({
   currency: string5(),
   amount: number2()
 });
@@ -14974,12 +15014,12 @@ var CreatePlanVariantDetailsPriceTier$inboundSchema = z28.pipe(
 );
 var CreatePlanVariantDetailsTierBehavior$inboundSchema = inboundSchema(CreatePlanVariantDetailsTierBehavior);
 var CreatePlanVariantDetailsAddItemPriceInterval$inboundSchema = inboundSchema(CreatePlanVariantDetailsAddItemPriceInterval);
-var CreatePlanAddItemBillingMethodResponse$inboundSchema = inboundSchema(CreatePlanAddItemBillingMethodResponse);
+var CreatePlanVariantDetailsAddItemBillingMethod$inboundSchema = inboundSchema(CreatePlanVariantDetailsAddItemBillingMethod);
 var CreatePlanVariantDetailsPrice$inboundSchema = z28.pipe(
   z28.object({
     amount: optional3(number2()),
     additional_currencies: optional3(z28.array(z28.lazy(
-      () => CreatePlanAddItemAdditionalCurrencyResponse$inboundSchema
+      () => CreatePlanVariantDetailsAddItemAdditionalCurrency$inboundSchema
     ))),
     tiers: optional3(z28.array(z28.lazy(
       () => CreatePlanVariantDetailsPriceTier$inboundSchema
@@ -14990,7 +15030,7 @@ var CreatePlanVariantDetailsPrice$inboundSchema = z28.pipe(
     interval: CreatePlanVariantDetailsAddItemPriceInterval$inboundSchema,
     interval_count: z28._default(number2(), 1),
     billing_units: z28._default(number2(), 1),
-    billing_method: CreatePlanAddItemBillingMethodResponse$inboundSchema,
+    billing_method: CreatePlanVariantDetailsAddItemBillingMethod$inboundSchema,
     max_purchase: z28.optional(z28.nullable(number2()))
   }),
   z28.transform((v) => {
@@ -15004,12 +15044,12 @@ var CreatePlanVariantDetailsPrice$inboundSchema = z28.pipe(
     });
   })
 );
-var CreatePlanOnIncreaseResponse$inboundSchema = inboundSchema(CreatePlanOnIncreaseResponse);
-var CreatePlanOnDecreaseResponse$inboundSchema = inboundSchema(CreatePlanOnDecreaseResponse);
-var CreatePlanProrationResponse$inboundSchema = z28.pipe(
+var CreatePlanVariantDetailsOnIncrease$inboundSchema = inboundSchema(CreatePlanVariantDetailsOnIncrease);
+var CreatePlanVariantDetailsOnDecrease$inboundSchema = inboundSchema(CreatePlanVariantDetailsOnDecrease);
+var CreatePlanVariantDetailsProration$inboundSchema = z28.pipe(
   z28.object({
-    on_increase: CreatePlanOnIncreaseResponse$inboundSchema,
-    on_decrease: CreatePlanOnDecreaseResponse$inboundSchema
+    on_increase: CreatePlanVariantDetailsOnIncrease$inboundSchema,
+    on_decrease: CreatePlanVariantDetailsOnDecrease$inboundSchema
   }),
   z28.transform((v) => {
     return remap(v, {
@@ -15284,7 +15324,7 @@ var CreatePlanVariantDetailsFeatureOverride$inboundSchema = z28.pipe(
     });
   })
 );
-var CreatePlanPlanItemResponse$inboundSchema = z28.pipe(
+var CreatePlanVariantDetailsPlanItem$inboundSchema = z28.pipe(
   z28.object({
     threshold_billing: z28.optional(z28.nullable(z28.lazy(
       () => CreatePlanVariantDetailsThresholdBilling$inboundSchema
@@ -15300,7 +15340,7 @@ var CreatePlanPlanItemResponse$inboundSchema = z28.pipe(
       () => CreatePlanVariantDetailsPrice$inboundSchema
     )),
     proration: optional3(z28.lazy(
-      () => CreatePlanProrationResponse$inboundSchema
+      () => CreatePlanVariantDetailsProration$inboundSchema
     )),
     rollover: optional3(z28.lazy(
       () => CreatePlanVariantDetailsRollover$inboundSchema
@@ -15320,18 +15360,18 @@ var CreatePlanPlanItemResponse$inboundSchema = z28.pipe(
     });
   })
 );
-var CreatePlanRemoveItemBillingMethodResponse$inboundSchema = inboundSchema(CreatePlanRemoveItemBillingMethodResponse);
+var CreatePlanVariantDetailsRemoveItemBillingMethod$inboundSchema = inboundSchema(CreatePlanVariantDetailsRemoveItemBillingMethod);
 var CreatePlanIntervalVariantDetailsRemoveItemEnum2$inboundSchema = inboundSchema(CreatePlanIntervalVariantDetailsRemoveItemEnum2);
 var CreatePlanIntervalVariantDetailsRemoveItemEnum1$inboundSchema = inboundSchema(CreatePlanIntervalVariantDetailsRemoveItemEnum1);
 var CreatePlanVariantDetailsIntervalUnion$inboundSchema = smartUnion([
   CreatePlanIntervalVariantDetailsRemoveItemEnum1$inboundSchema,
   CreatePlanIntervalVariantDetailsRemoveItemEnum2$inboundSchema
 ]);
-var CreatePlanPlanItemFilterResponse$inboundSchema = z28.pipe(
+var CreatePlanVariantDetailsPlanItemFilter$inboundSchema = z28.pipe(
   z28.object({
     feature_id: optional3(string5()),
     billing_method: optional3(
-      CreatePlanRemoveItemBillingMethodResponse$inboundSchema
+      CreatePlanVariantDetailsRemoveItemBillingMethod$inboundSchema
     ),
     interval: optional3(
       smartUnion([
@@ -15654,6 +15694,96 @@ var CreatePlanIntervalUpsertLicenseRemoveItemEnum1 = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
+var CreatePlanPriceLicenseIntervalResponse = {
+  OneOff: "one_off",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var CreatePlanLicenseResetIntervalResponse = {
+  OneOff: "one_off",
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var CreatePlanLicenseTierBehaviorResponse = {
+  Graduated: "graduated",
+  Volume: "volume"
+};
+var CreatePlanLicenseAddItemPriceIntervalResponse = {
+  OneOff: "one_off",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var CreatePlanLicenseAddItemBillingMethodResponse = {
+  Prepaid: "prepaid",
+  UsageBased: "usage_based"
+};
+var CreatePlanLicenseOnIncreaseResponse = {
+  BillImmediately: "bill_immediately",
+  ProrateImmediately: "prorate_immediately",
+  ProrateNextCycle: "prorate_next_cycle",
+  BillNextCycle: "bill_next_cycle"
+};
+var CreatePlanLicenseOnDecreaseResponse = {
+  Prorate: "prorate",
+  ProrateImmediately: "prorate_immediately",
+  ProrateNextCycle: "prorate_next_cycle",
+  None: "none",
+  NoProrations: "no_prorations"
+};
+var CreatePlanLicenseExpiryDurationTypeResponse = {
+  Month: "month",
+  Forever: "forever"
+};
+var CreatePlanLicenseDurationResponse = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var CreatePlanDimensionsToLicenseResponseEnum2 = {
+  Inf: "inf"
+};
+var CreatePlanDimensionsToLicenseResponseEnum1 = {
+  Inf: "inf"
+};
+var CreatePlanToLicenseResponseEnum = {
+  Inf: "inf"
+};
+var CreatePlanLicenseRemoveItemBillingMethodResponse = {
+  Prepaid: "prepaid",
+  UsageBased: "usage_based"
+};
+var CreatePlanIntervalLicenseRemoveItemResponseEnum2 = {
+  OneOff: "one_off",
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var CreatePlanIntervalLicenseRemoveItemResponseEnum1 = {
+  OneOff: "one_off",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
 var CreatePlanUpsertLicenseProration$inboundSchema = z29.pipe(
   z29.object({
     on_increase: CreatePlanUpsertLicenseOnIncrease$inboundSchema,
@@ -16042,14 +16172,16 @@ var CreatePlanRemoveLicense$inboundSchema = z29.pipe(
     });
   })
 );
-var CreatePlanCustomizeResponse$inboundSchema = z29.pipe(
+var CreatePlanVariantDetailsCustomize$inboundSchema = z29.pipe(
   z29.object({
-    price: z29.optional(z29.nullable(CreatePlanBasePriceResponse$inboundSchema)),
+    price: z29.optional(
+      z29.nullable(CreatePlanVariantDetailsBasePrice$inboundSchema)
+    ),
     add_items: optional3(
-      z29.array(CreatePlanPlanItemResponse$inboundSchema)
+      z29.array(CreatePlanVariantDetailsPlanItem$inboundSchema)
     ),
     remove_items: optional3(
-      z29.array(CreatePlanPlanItemFilterResponse$inboundSchema)
+      z29.array(CreatePlanVariantDetailsPlanItemFilter$inboundSchema)
     ),
     free_trial: z29.optional(z29.nullable(CreatePlanFreeTrialParams$inboundSchema)),
     billing_controls: optional3(
@@ -16077,7 +16209,7 @@ var CreatePlanVariantDetails$inboundSchema = z29.pipe(
   z29.object({
     base_plan_id: string5(),
     customize: optional3(
-      z29.lazy(() => CreatePlanCustomizeResponse$inboundSchema)
+      z29.lazy(() => CreatePlanVariantDetailsCustomize$inboundSchema)
     )
   }),
   z29.transform((v) => {
@@ -16086,6 +16218,493 @@ var CreatePlanVariantDetails$inboundSchema = z29.pipe(
     });
   })
 );
+var CreatePlanPriceLicenseIntervalResponse$inboundSchema = inboundSchema(CreatePlanPriceLicenseIntervalResponse);
+var CreatePlanLicenseAdditionalCurrencyResponse$inboundSchema = z29.object({
+  currency: string5(),
+  amount: number2()
+});
+var CreatePlanLicenseBasePriceResponse$inboundSchema = z29.pipe(
+  z29.object({
+    amount: number2(),
+    interval: CreatePlanPriceLicenseIntervalResponse$inboundSchema,
+    interval_count: z29._default(number2(), 1),
+    additional_currencies: optional3(z29.array(z29.lazy(
+      () => CreatePlanLicenseAdditionalCurrencyResponse$inboundSchema
+    )))
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount",
+      "additional_currencies": "additionalCurrencies"
+    });
+  })
+);
+var CreatePlanLicenseThresholdBillingResponse$inboundSchema = z29.object({
+  threshold: number2()
+});
+var CreatePlanLicenseResetIntervalResponse$inboundSchema = inboundSchema(CreatePlanLicenseResetIntervalResponse);
+var CreatePlanLicenseResetResponse$inboundSchema = z29.pipe(
+  z29.object({
+    interval: CreatePlanLicenseResetIntervalResponse$inboundSchema,
+    interval_count: z29._default(number2(), 1)
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var CreatePlanLicenseAddItemAdditionalCurrencyResponse$inboundSchema = z29.object({
+  currency: string5(),
+  amount: number2()
+});
+var CreatePlanLicensePriceToResponse$inboundSchema = smartUnion([number2(), string5()]);
+var CreatePlanLicenseTierAdditionalCurrencyResponse$inboundSchema = z29.pipe(
+  z29.object({
+    currency: string5(),
+    amount: optional3(number2()),
+    flat_amount: optional3(number2())
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "flat_amount": "flatAmount"
+    });
+  })
+);
+var CreatePlanLicensePriceTierResponse$inboundSchema = z29.pipe(
+  z29.object({
+    to: smartUnion([number2(), string5()]),
+    amount: number2(),
+    flat_amount: optional3(number2()),
+    additional_currencies: optional3(z29.array(z29.lazy(
+      () => CreatePlanLicenseTierAdditionalCurrencyResponse$inboundSchema
+    )))
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "flat_amount": "flatAmount",
+      "additional_currencies": "additionalCurrencies"
+    });
+  })
+);
+var CreatePlanLicenseTierBehaviorResponse$inboundSchema = inboundSchema(CreatePlanLicenseTierBehaviorResponse);
+var CreatePlanLicenseAddItemPriceIntervalResponse$inboundSchema = inboundSchema(CreatePlanLicenseAddItemPriceIntervalResponse);
+var CreatePlanLicenseAddItemBillingMethodResponse$inboundSchema = inboundSchema(CreatePlanLicenseAddItemBillingMethodResponse);
+var CreatePlanLicensePriceResponse$inboundSchema = z29.pipe(
+  z29.object({
+    amount: optional3(number2()),
+    additional_currencies: optional3(z29.array(z29.lazy(
+      () => CreatePlanLicenseAddItemAdditionalCurrencyResponse$inboundSchema
+    ))),
+    tiers: optional3(z29.array(z29.lazy(
+      () => CreatePlanLicensePriceTierResponse$inboundSchema
+    ))),
+    tier_behavior: optional3(
+      CreatePlanLicenseTierBehaviorResponse$inboundSchema
+    ),
+    interval: CreatePlanLicenseAddItemPriceIntervalResponse$inboundSchema,
+    interval_count: z29._default(number2(), 1),
+    billing_units: z29._default(number2(), 1),
+    billing_method: CreatePlanLicenseAddItemBillingMethodResponse$inboundSchema,
+    max_purchase: z29.optional(z29.nullable(number2()))
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "additional_currencies": "additionalCurrencies",
+      "tier_behavior": "tierBehavior",
+      "interval_count": "intervalCount",
+      "billing_units": "billingUnits",
+      "billing_method": "billingMethod",
+      "max_purchase": "maxPurchase"
+    });
+  })
+);
+var CreatePlanLicenseOnIncreaseResponse$inboundSchema = inboundSchema(CreatePlanLicenseOnIncreaseResponse);
+var CreatePlanLicenseOnDecreaseResponse$inboundSchema = inboundSchema(CreatePlanLicenseOnDecreaseResponse);
+var CreatePlanLicenseProrationResponse$inboundSchema = z29.pipe(
+  z29.object({
+    on_increase: CreatePlanLicenseOnIncreaseResponse$inboundSchema,
+    on_decrease: CreatePlanLicenseOnDecreaseResponse$inboundSchema
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "on_increase": "onIncrease",
+      "on_decrease": "onDecrease"
+    });
+  })
+);
+var CreatePlanLicenseExpiryDurationTypeResponse$inboundSchema = inboundSchema(CreatePlanLicenseExpiryDurationTypeResponse);
+var CreatePlanLicenseRolloverResponse$inboundSchema = z29.pipe(
+  z29.object({
+    max: optional3(number2()),
+    max_percentage: optional3(number2()),
+    expiry_duration_type: CreatePlanLicenseExpiryDurationTypeResponse$inboundSchema,
+    expiry_duration_length: optional3(number2())
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "max_percentage": "maxPercentage",
+      "expiry_duration_type": "expiryDurationType",
+      "expiry_duration_length": "expiryDurationLength"
+    });
+  })
+);
+var CreatePlanLicenseDurationResponse$inboundSchema = inboundSchema(CreatePlanLicenseDurationResponse);
+var CreatePlanLicenseExpiryResponse$inboundSchema = z29.object({
+  duration: CreatePlanLicenseDurationResponse$inboundSchema,
+  length: number2()
+});
+var CreatePlanDimensionsLicenseResponse4$inboundSchema = z29.pipe(
+  z29.object({
+    match: z29.record(z29.string(), string5()),
+    priority: optional3(number2()),
+    credit_cost: number2()
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var CreatePlanDimensionsToLicenseResponseEnum2$inboundSchema = z29.enum(
+  CreatePlanDimensionsToLicenseResponseEnum2
+);
+var CreatePlanDimensionsLicenseToResponseUnion2$inboundSchema = smartUnion([
+  number2(),
+  CreatePlanDimensionsToLicenseResponseEnum2$inboundSchema
+]);
+var CreatePlanDimensionsLicenseTierResponse2$inboundSchema = z29.pipe(
+  z29.object({
+    to: smartUnion([
+      number2(),
+      CreatePlanDimensionsToLicenseResponseEnum2$inboundSchema
+    ]),
+    credit_cost: number2()
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var CreatePlanDimensionsLicenseResponse3$inboundSchema = z29.pipe(
+  z29.object({
+    match: z29.record(z29.string(), string5()),
+    priority: optional3(number2()),
+    tier_behavior: literal3("graduated"),
+    tiers: z29.array(
+      z29.lazy(() => CreatePlanDimensionsLicenseTierResponse2$inboundSchema)
+    )
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "tier_behavior": "tierBehavior"
+    });
+  })
+);
+var CreatePlanLicenseDimensionsResponseUnion2$inboundSchema = smartUnion([
+  z29.lazy(() => CreatePlanDimensionsLicenseResponse3$inboundSchema),
+  z29.lazy(() => CreatePlanDimensionsLicenseResponse4$inboundSchema)
+]);
+var CreatePlanLicenseMultipliersResponse2$inboundSchema = z29.object({
+  match: z29.record(z29.string(), string5()),
+  factor: optional3(number2()),
+  add: optional3(number2())
+});
+var CreatePlanCreditSchemaLicenseResponse2$inboundSchema = z29.pipe(
+  z29.object({
+    metered_feature_id: string5(),
+    billing_units: optional3(number2()),
+    dimensions: optional3(z29.record(
+      z29.string(),
+      smartUnion([
+        z29.lazy(() => CreatePlanDimensionsLicenseResponse3$inboundSchema),
+        z29.lazy(() => CreatePlanDimensionsLicenseResponse4$inboundSchema)
+      ])
+    )),
+    multipliers: optional3(z29.record(
+      z29.string(),
+      z29.lazy(() => CreatePlanLicenseMultipliersResponse2$inboundSchema)
+    )),
+    credit_cost: number2()
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "metered_feature_id": "meteredFeatureId",
+      "billing_units": "billingUnits",
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var CreatePlanDimensionsLicenseResponse2$inboundSchema = z29.pipe(
+  z29.object({
+    match: z29.record(z29.string(), string5()),
+    priority: optional3(number2()),
+    credit_cost: number2()
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var CreatePlanDimensionsToLicenseResponseEnum1$inboundSchema = z29.enum(
+  CreatePlanDimensionsToLicenseResponseEnum1
+);
+var CreatePlanDimensionsLicenseToResponseUnion1$inboundSchema = smartUnion([
+  number2(),
+  CreatePlanDimensionsToLicenseResponseEnum1$inboundSchema
+]);
+var CreatePlanDimensionsLicenseTierResponse1$inboundSchema = z29.pipe(
+  z29.object({
+    to: smartUnion([
+      number2(),
+      CreatePlanDimensionsToLicenseResponseEnum1$inboundSchema
+    ]),
+    credit_cost: number2()
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var CreatePlanDimensionsLicenseResponse1$inboundSchema = z29.pipe(
+  z29.object({
+    match: z29.record(z29.string(), string5()),
+    priority: optional3(number2()),
+    tier_behavior: literal3("graduated"),
+    tiers: z29.array(
+      z29.lazy(() => CreatePlanDimensionsLicenseTierResponse1$inboundSchema)
+    )
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "tier_behavior": "tierBehavior"
+    });
+  })
+);
+var CreatePlanLicenseDimensionsResponseUnion1$inboundSchema = smartUnion([
+  z29.lazy(() => CreatePlanDimensionsLicenseResponse1$inboundSchema),
+  z29.lazy(() => CreatePlanDimensionsLicenseResponse2$inboundSchema)
+]);
+var CreatePlanLicenseMultipliersResponse1$inboundSchema = z29.object({
+  match: z29.record(z29.string(), string5()),
+  factor: optional3(number2()),
+  add: optional3(number2())
+});
+var CreatePlanToLicenseResponseEnum$inboundSchema = z29.enum(CreatePlanToLicenseResponseEnum);
+var CreatePlanLicenseFeatureOverrideToResponseUnion$inboundSchema = smartUnion([number2(), CreatePlanToLicenseResponseEnum$inboundSchema]);
+var CreatePlanLicenseFeatureOverrideTierResponse$inboundSchema = z29.pipe(
+  z29.object({
+    to: smartUnion([
+      number2(),
+      CreatePlanToLicenseResponseEnum$inboundSchema
+    ]),
+    credit_cost: number2()
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var CreatePlanCreditSchemaLicenseResponse1$inboundSchema = z29.pipe(
+  z29.object({
+    metered_feature_id: string5(),
+    billing_units: optional3(number2()),
+    dimensions: optional3(z29.record(
+      z29.string(),
+      smartUnion([
+        z29.lazy(() => CreatePlanDimensionsLicenseResponse1$inboundSchema),
+        z29.lazy(() => CreatePlanDimensionsLicenseResponse2$inboundSchema)
+      ])
+    )),
+    multipliers: optional3(z29.record(
+      z29.string(),
+      z29.lazy(() => CreatePlanLicenseMultipliersResponse1$inboundSchema)
+    )),
+    tier_behavior: literal3("graduated"),
+    tiers: z29.array(z29.lazy(
+      () => CreatePlanLicenseFeatureOverrideTierResponse$inboundSchema
+    ))
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "metered_feature_id": "meteredFeatureId",
+      "billing_units": "billingUnits",
+      "tier_behavior": "tierBehavior"
+    });
+  })
+);
+var CreatePlanLicenseCreditSchemaResponseUnion$inboundSchema = smartUnion([
+  z29.lazy(() => CreatePlanCreditSchemaLicenseResponse1$inboundSchema),
+  z29.lazy(() => CreatePlanCreditSchemaLicenseResponse2$inboundSchema)
+]);
+var CreatePlanLicenseProviderMarkupsResponse$inboundSchema = z29.object({
+  markup: number2()
+});
+var CreatePlanLicenseModelMarkupsResponse$inboundSchema = z29.pipe(
+  z29.object({
+    markup: optional3(number2()),
+    input_cost: optional3(number2()),
+    output_cost: optional3(number2())
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "input_cost": "inputCost",
+      "output_cost": "outputCost"
+    });
+  })
+);
+var CreatePlanLicenseMarkupsResponse$inboundSchema = z29.pipe(
+  z29.object({
+    default_markup: optional3(number2()),
+    provider_markups: z29.optional(z29.nullable(z29.record(
+      z29.string(),
+      z29.lazy(() => CreatePlanLicenseProviderMarkupsResponse$inboundSchema)
+    ))),
+    model_markups: z29.optional(z29.nullable(z29.record(
+      z29.string(),
+      z29.lazy(() => CreatePlanLicenseModelMarkupsResponse$inboundSchema)
+    )))
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "default_markup": "defaultMarkup",
+      "provider_markups": "providerMarkups",
+      "model_markups": "modelMarkups"
+    });
+  })
+);
+var CreatePlanLicenseFeatureOverrideResponse$inboundSchema = z29.pipe(
+  z29.object({
+    credit_schema: optional3(z29.array(smartUnion([
+      z29.lazy(() => CreatePlanCreditSchemaLicenseResponse1$inboundSchema),
+      z29.lazy(
+        () => CreatePlanCreditSchemaLicenseResponse2$inboundSchema
+      )
+    ]))),
+    markups: optional3(z29.lazy(
+      () => CreatePlanLicenseMarkupsResponse$inboundSchema
+    ))
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "credit_schema": "creditSchema"
+    });
+  })
+);
+var CreatePlanLicensePlanItemResponse$inboundSchema = z29.pipe(
+  z29.object({
+    threshold_billing: z29.optional(z29.nullable(z29.lazy(
+      () => CreatePlanLicenseThresholdBillingResponse$inboundSchema
+    ))),
+    feature_id: string5(),
+    included: optional3(number2()),
+    unlimited: optional3(boolean2()),
+    pooled: z29._default(boolean2(), false),
+    reset: optional3(z29.lazy(
+      () => CreatePlanLicenseResetResponse$inboundSchema
+    )),
+    price: optional3(z29.lazy(
+      () => CreatePlanLicensePriceResponse$inboundSchema
+    )),
+    proration: optional3(z29.lazy(
+      () => CreatePlanLicenseProrationResponse$inboundSchema
+    )),
+    rollover: optional3(z29.lazy(
+      () => CreatePlanLicenseRolloverResponse$inboundSchema
+    )),
+    expiry: optional3(z29.lazy(
+      () => CreatePlanLicenseExpiryResponse$inboundSchema
+    )),
+    feature_override: optional3(z29.lazy(
+      () => CreatePlanLicenseFeatureOverrideResponse$inboundSchema
+    ))
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "threshold_billing": "thresholdBilling",
+      "feature_id": "featureId",
+      "feature_override": "featureOverride"
+    });
+  })
+);
+var CreatePlanLicenseRemoveItemBillingMethodResponse$inboundSchema = inboundSchema(CreatePlanLicenseRemoveItemBillingMethodResponse);
+var CreatePlanIntervalLicenseRemoveItemResponseEnum2$inboundSchema = inboundSchema(CreatePlanIntervalLicenseRemoveItemResponseEnum2);
+var CreatePlanIntervalLicenseRemoveItemResponseEnum1$inboundSchema = inboundSchema(CreatePlanIntervalLicenseRemoveItemResponseEnum1);
+var CreatePlanLicenseIntervalResponseUnion$inboundSchema = smartUnion([
+  CreatePlanIntervalLicenseRemoveItemResponseEnum1$inboundSchema,
+  CreatePlanIntervalLicenseRemoveItemResponseEnum2$inboundSchema
+]);
+var CreatePlanLicensePlanItemFilterResponse$inboundSchema = z29.pipe(
+  z29.object({
+    feature_id: optional3(string5()),
+    billing_method: optional3(
+      CreatePlanLicenseRemoveItemBillingMethodResponse$inboundSchema
+    ),
+    interval: optional3(
+      smartUnion([
+        CreatePlanIntervalLicenseRemoveItemResponseEnum1$inboundSchema,
+        CreatePlanIntervalLicenseRemoveItemResponseEnum2$inboundSchema
+      ])
+    ),
+    interval_count: optional3(number2()),
+    included: optional3(number2())
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "billing_method": "billingMethod",
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var CreatePlanLicenseCustomizeResponse$inboundSchema = z29.pipe(
+  z29.object({
+    price: z29.optional(
+      z29.nullable(
+        z29.lazy(() => CreatePlanLicenseBasePriceResponse$inboundSchema)
+      )
+    ),
+    add_items: optional3(
+      z29.array(z29.lazy(() => CreatePlanLicensePlanItemResponse$inboundSchema))
+    ),
+    remove_items: optional3(
+      z29.array(
+        z29.lazy(() => CreatePlanLicensePlanItemFilterResponse$inboundSchema)
+      )
+    )
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "add_items": "addItems",
+      "remove_items": "removeItems"
+    });
+  })
+);
+var CreatePlanLicenseResponse$inboundSchema = z29.pipe(
+  z29.object({
+    license_plan_id: string5(),
+    version: number2(),
+    version_slug: optional3(string5()),
+    included: number2(),
+    prepaid_only: boolean2(),
+    customize: optional3(
+      z29.lazy(() => CreatePlanLicenseCustomizeResponse$inboundSchema)
+    ),
+    metadata: optional3(z29.record(z29.string(), z29.any())),
+    plan: optional3(Plan$inboundSchema)
+  }),
+  z29.transform((v) => {
+    return remap(v, {
+      "license_plan_id": "licensePlanId",
+      "version_slug": "versionSlug",
+      "prepaid_only": "prepaidOnly"
+    });
+  })
+);
 var CreatePlanResponse$inboundSchema = z29.pipe(
   z29.object({
     id: string5(),
@@ -16115,6 +16734,9 @@ var CreatePlanResponse$inboundSchema = z29.pipe(
     base_variant_id: nullable(string5()),
     variant_details: optional3(
       z29.lazy(() => CreatePlanVariantDetails$inboundSchema)
+    ),
+    licenses: optional3(
+      z29.array(z29.lazy(() => CreatePlanLicenseResponse$inboundSchema))
     )
   }),
   z29.transform((v) => {
@@ -24237,7 +24859,7 @@ var GetPlanPriceVariantDetailsInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var GetPlanAddItemResetInterval = {
+var GetPlanVariantDetailsResetInterval = {
   OneOff: "one_off",
   Minute: "minute",
   Hour: "hour",
@@ -24252,7 +24874,7 @@ var GetPlanVariantDetailsTierBehavior = {
   Graduated: "graduated",
   Volume: "volume"
 };
-var GetPlanAddItemPriceInterval = {
+var GetPlanVariantDetailsAddItemPriceInterval = {
   OneOff: "one_off",
   Week: "week",
   Month: "month",
@@ -24260,17 +24882,17 @@ var GetPlanAddItemPriceInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var GetPlanAddItemBillingMethod = {
+var GetPlanVariantDetailsAddItemBillingMethod = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
-var GetPlanOnIncrease = {
+var GetPlanVariantDetailsOnIncrease = {
   BillImmediately: "bill_immediately",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
   BillNextCycle: "bill_next_cycle"
 };
-var GetPlanOnDecrease = {
+var GetPlanVariantDetailsOnDecrease = {
   Prorate: "prorate",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
@@ -24296,11 +24918,11 @@ var GetPlanDimensionsToVariantDetailsEnum1 = {
 var GetPlanToVariantDetailsEnum = {
   Inf: "inf"
 };
-var GetPlanRemoveItemBillingMethod = {
+var GetPlanVariantDetailsRemoveItemBillingMethod = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
-var GetPlanIntervalRemoveItemEnum2 = {
+var GetPlanIntervalVariantDetailsRemoveItemEnum2 = {
   OneOff: "one_off",
   Minute: "minute",
   Hour: "hour",
@@ -24311,7 +24933,7 @@ var GetPlanIntervalRemoveItemEnum2 = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var GetPlanIntervalRemoveItemEnum1 = {
+var GetPlanIntervalVariantDetailsRemoveItemEnum1 = {
   OneOff: "one_off",
   Week: "week",
   Month: "month",
@@ -25071,7 +25693,7 @@ var GetPlanVariantDetailsAdditionalCurrency$inboundSchema = z56.object({
   currency: string5(),
   amount: number2()
 });
-var GetPlanBasePrice$inboundSchema = z56.pipe(
+var GetPlanVariantDetailsBasePrice$inboundSchema = z56.pipe(
   z56.object({
     amount: number2(),
     interval: GetPlanPriceVariantDetailsInterval$inboundSchema,
@@ -25090,10 +25712,10 @@ var GetPlanBasePrice$inboundSchema = z56.pipe(
 var GetPlanVariantDetailsThresholdBilling$inboundSchema = z56.object({
   threshold: number2()
 });
-var GetPlanAddItemResetInterval$inboundSchema = inboundSchema(GetPlanAddItemResetInterval);
+var GetPlanVariantDetailsResetInterval$inboundSchema = inboundSchema(GetPlanVariantDetailsResetInterval);
 var GetPlanVariantDetailsReset$inboundSchema = z56.pipe(
   z56.object({
-    interval: GetPlanAddItemResetInterval$inboundSchema,
+    interval: GetPlanVariantDetailsResetInterval$inboundSchema,
     interval_count: z56._default(number2(), 1)
   }),
   z56.transform((v) => {
@@ -25102,7 +25724,7 @@ var GetPlanVariantDetailsReset$inboundSchema = z56.pipe(
     });
   })
 );
-var GetPlanAddItemAdditionalCurrency$inboundSchema = z56.object({
+var GetPlanVariantDetailsAddItemAdditionalCurrency$inboundSchema = z56.object({
   currency: string5(),
   amount: number2()
 });
@@ -25136,24 +25758,24 @@ var GetPlanVariantDetailsPriceTier$inboundSchema = z56.pipe(
   })
 );
 var GetPlanVariantDetailsTierBehavior$inboundSchema = inboundSchema(GetPlanVariantDetailsTierBehavior);
-var GetPlanAddItemPriceInterval$inboundSchema = inboundSchema(GetPlanAddItemPriceInterval);
-var GetPlanAddItemBillingMethod$inboundSchema = inboundSchema(GetPlanAddItemBillingMethod);
+var GetPlanVariantDetailsAddItemPriceInterval$inboundSchema = inboundSchema(GetPlanVariantDetailsAddItemPriceInterval);
+var GetPlanVariantDetailsAddItemBillingMethod$inboundSchema = inboundSchema(GetPlanVariantDetailsAddItemBillingMethod);
 var GetPlanVariantDetailsPrice$inboundSchema = z56.pipe(
   z56.object({
     amount: optional3(number2()),
-    additional_currencies: optional3(
-      z56.array(z56.lazy(() => GetPlanAddItemAdditionalCurrency$inboundSchema))
-    ),
-    tiers: optional3(
-      z56.array(z56.lazy(() => GetPlanVariantDetailsPriceTier$inboundSchema))
-    ),
+    additional_currencies: optional3(z56.array(z56.lazy(
+      () => GetPlanVariantDetailsAddItemAdditionalCurrency$inboundSchema
+    ))),
+    tiers: optional3(z56.array(z56.lazy(
+      () => GetPlanVariantDetailsPriceTier$inboundSchema
+    ))),
     tier_behavior: optional3(
       GetPlanVariantDetailsTierBehavior$inboundSchema
     ),
-    interval: GetPlanAddItemPriceInterval$inboundSchema,
+    interval: GetPlanVariantDetailsAddItemPriceInterval$inboundSchema,
     interval_count: z56._default(number2(), 1),
     billing_units: z56._default(number2(), 1),
-    billing_method: GetPlanAddItemBillingMethod$inboundSchema,
+    billing_method: GetPlanVariantDetailsAddItemBillingMethod$inboundSchema,
     max_purchase: z56.optional(z56.nullable(number2()))
   }),
   z56.transform((v) => {
@@ -25167,12 +25789,12 @@ var GetPlanVariantDetailsPrice$inboundSchema = z56.pipe(
     });
   })
 );
-var GetPlanOnIncrease$inboundSchema = inboundSchema(GetPlanOnIncrease);
-var GetPlanOnDecrease$inboundSchema = inboundSchema(GetPlanOnDecrease);
-var GetPlanProration$inboundSchema = z56.pipe(
+var GetPlanVariantDetailsOnIncrease$inboundSchema = inboundSchema(GetPlanVariantDetailsOnIncrease);
+var GetPlanVariantDetailsOnDecrease$inboundSchema = inboundSchema(GetPlanVariantDetailsOnDecrease);
+var GetPlanVariantDetailsProration$inboundSchema = z56.pipe(
   z56.object({
-    on_increase: GetPlanOnIncrease$inboundSchema,
-    on_decrease: GetPlanOnDecrease$inboundSchema
+    on_increase: GetPlanVariantDetailsOnIncrease$inboundSchema,
+    on_decrease: GetPlanVariantDetailsOnDecrease$inboundSchema
   }),
   z56.transform((v) => {
     return remap(v, {
@@ -25443,7 +26065,7 @@ var GetPlanVariantDetailsFeatureOverride$inboundSchema = z56.pipe(
     });
   })
 );
-var GetPlanPlanItem$inboundSchema = z56.pipe(
+var GetPlanVariantDetailsPlanItem$inboundSchema = z56.pipe(
   z56.object({
     threshold_billing: z56.optional(z56.nullable(z56.lazy(
       () => GetPlanVariantDetailsThresholdBilling$inboundSchema
@@ -25458,7 +26080,9 @@ var GetPlanPlanItem$inboundSchema = z56.pipe(
     price: optional3(
       z56.lazy(() => GetPlanVariantDetailsPrice$inboundSchema)
     ),
-    proration: optional3(z56.lazy(() => GetPlanProration$inboundSchema)),
+    proration: optional3(
+      z56.lazy(() => GetPlanVariantDetailsProration$inboundSchema)
+    ),
     rollover: optional3(
       z56.lazy(() => GetPlanVariantDetailsRollover$inboundSchema)
     ),
@@ -25477,23 +26101,23 @@ var GetPlanPlanItem$inboundSchema = z56.pipe(
     });
   })
 );
-var GetPlanRemoveItemBillingMethod$inboundSchema = inboundSchema(GetPlanRemoveItemBillingMethod);
-var GetPlanIntervalRemoveItemEnum2$inboundSchema = inboundSchema(GetPlanIntervalRemoveItemEnum2);
-var GetPlanIntervalRemoveItemEnum1$inboundSchema = inboundSchema(GetPlanIntervalRemoveItemEnum1);
-var GetPlanIntervalUnion$inboundSchema = smartUnion([
-  GetPlanIntervalRemoveItemEnum1$inboundSchema,
-  GetPlanIntervalRemoveItemEnum2$inboundSchema
+var GetPlanVariantDetailsRemoveItemBillingMethod$inboundSchema = inboundSchema(GetPlanVariantDetailsRemoveItemBillingMethod);
+var GetPlanIntervalVariantDetailsRemoveItemEnum2$inboundSchema = inboundSchema(GetPlanIntervalVariantDetailsRemoveItemEnum2);
+var GetPlanIntervalVariantDetailsRemoveItemEnum1$inboundSchema = inboundSchema(GetPlanIntervalVariantDetailsRemoveItemEnum1);
+var GetPlanVariantDetailsIntervalUnion$inboundSchema = smartUnion([
+  GetPlanIntervalVariantDetailsRemoveItemEnum1$inboundSchema,
+  GetPlanIntervalVariantDetailsRemoveItemEnum2$inboundSchema
 ]);
-var GetPlanPlanItemFilter$inboundSchema = z56.pipe(
+var GetPlanVariantDetailsPlanItemFilter$inboundSchema = z56.pipe(
   z56.object({
     feature_id: optional3(string5()),
     billing_method: optional3(
-      GetPlanRemoveItemBillingMethod$inboundSchema
+      GetPlanVariantDetailsRemoveItemBillingMethod$inboundSchema
     ),
     interval: optional3(
       smartUnion([
-        GetPlanIntervalRemoveItemEnum1$inboundSchema,
-        GetPlanIntervalRemoveItemEnum2$inboundSchema
+        GetPlanIntervalVariantDetailsRemoveItemEnum1$inboundSchema,
+        GetPlanIntervalVariantDetailsRemoveItemEnum2$inboundSchema
       ])
     ),
     interval_count: optional3(number2()),
@@ -25717,6 +26341,96 @@ var GetPlanIntervalUpsertLicenseRemoveItemEnum1 = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
+var GetPlanPriceLicenseInterval = {
+  OneOff: "one_off",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var GetPlanLicenseResetInterval = {
+  OneOff: "one_off",
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var GetPlanLicenseTierBehavior = {
+  Graduated: "graduated",
+  Volume: "volume"
+};
+var GetPlanLicenseAddItemPriceInterval = {
+  OneOff: "one_off",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var GetPlanLicenseAddItemBillingMethod = {
+  Prepaid: "prepaid",
+  UsageBased: "usage_based"
+};
+var GetPlanLicenseOnIncrease = {
+  BillImmediately: "bill_immediately",
+  ProrateImmediately: "prorate_immediately",
+  ProrateNextCycle: "prorate_next_cycle",
+  BillNextCycle: "bill_next_cycle"
+};
+var GetPlanLicenseOnDecrease = {
+  Prorate: "prorate",
+  ProrateImmediately: "prorate_immediately",
+  ProrateNextCycle: "prorate_next_cycle",
+  None: "none",
+  NoProrations: "no_prorations"
+};
+var GetPlanLicenseExpiryDurationType = {
+  Month: "month",
+  Forever: "forever"
+};
+var GetPlanLicenseDuration = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var GetPlanDimensionsToLicenseEnum2 = {
+  Inf: "inf"
+};
+var GetPlanDimensionsToLicenseEnum1 = {
+  Inf: "inf"
+};
+var GetPlanToLicenseEnum = {
+  Inf: "inf"
+};
+var GetPlanLicenseRemoveItemBillingMethod = {
+  Prepaid: "prepaid",
+  UsageBased: "usage_based"
+};
+var GetPlanIntervalLicenseRemoveItemEnum2 = {
+  OneOff: "one_off",
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var GetPlanIntervalLicenseRemoveItemEnum1 = {
+  OneOff: "one_off",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
 var GetPlanVariantDetailsOverageAllowed$inboundSchema = z57.pipe(
   z57.object({
     feature_id: string5(),
@@ -26245,11 +26959,15 @@ var GetPlanRemoveLicense$inboundSchema = z57.pipe(
     });
   })
 );
-var GetPlanCustomize$inboundSchema = z57.pipe(
+var GetPlanVariantDetailsCustomize$inboundSchema = z57.pipe(
   z57.object({
-    price: z57.optional(z57.nullable(GetPlanBasePrice$inboundSchema)),
-    add_items: optional3(z57.array(GetPlanPlanItem$inboundSchema)),
-    remove_items: optional3(z57.array(GetPlanPlanItemFilter$inboundSchema)),
+    price: z57.optional(z57.nullable(GetPlanVariantDetailsBasePrice$inboundSchema)),
+    add_items: optional3(
+      z57.array(GetPlanVariantDetailsPlanItem$inboundSchema)
+    ),
+    remove_items: optional3(
+      z57.array(GetPlanVariantDetailsPlanItemFilter$inboundSchema)
+    ),
     free_trial: z57.optional(z57.nullable(GetPlanFreeTrialParams$inboundSchema)),
     billing_controls: optional3(
       z57.lazy(() => GetPlanVariantDetailsBillingControls$inboundSchema)
@@ -26275,7 +26993,9 @@ var GetPlanCustomize$inboundSchema = z57.pipe(
 var GetPlanVariantDetails$inboundSchema = z57.pipe(
   z57.object({
     base_plan_id: string5(),
-    customize: optional3(z57.lazy(() => GetPlanCustomize$inboundSchema))
+    customize: optional3(
+      z57.lazy(() => GetPlanVariantDetailsCustomize$inboundSchema)
+    )
   }),
   z57.transform((v) => {
     return remap(v, {
@@ -26283,6 +27003,464 @@ var GetPlanVariantDetails$inboundSchema = z57.pipe(
     });
   })
 );
+var GetPlanPriceLicenseInterval$inboundSchema = inboundSchema(GetPlanPriceLicenseInterval);
+var GetPlanLicenseAdditionalCurrency$inboundSchema = z57.object({
+  currency: string5(),
+  amount: number2()
+});
+var GetPlanLicenseBasePrice$inboundSchema = z57.pipe(
+  z57.object({
+    amount: number2(),
+    interval: GetPlanPriceLicenseInterval$inboundSchema,
+    interval_count: z57._default(number2(), 1),
+    additional_currencies: optional3(
+      z57.array(z57.lazy(() => GetPlanLicenseAdditionalCurrency$inboundSchema))
+    )
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount",
+      "additional_currencies": "additionalCurrencies"
+    });
+  })
+);
+var GetPlanLicenseThresholdBilling$inboundSchema = z57.object({
+  threshold: number2()
+});
+var GetPlanLicenseResetInterval$inboundSchema = inboundSchema(GetPlanLicenseResetInterval);
+var GetPlanLicenseReset$inboundSchema = z57.pipe(
+  z57.object({
+    interval: GetPlanLicenseResetInterval$inboundSchema,
+    interval_count: z57._default(number2(), 1)
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var GetPlanLicenseAddItemAdditionalCurrency$inboundSchema = z57.object({
+  currency: string5(),
+  amount: number2()
+});
+var GetPlanLicensePriceTo$inboundSchema = smartUnion([number2(), string5()]);
+var GetPlanLicenseTierAdditionalCurrency$inboundSchema = z57.pipe(
+  z57.object({
+    currency: string5(),
+    amount: optional3(number2()),
+    flat_amount: optional3(number2())
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "flat_amount": "flatAmount"
+    });
+  })
+);
+var GetPlanLicensePriceTier$inboundSchema = z57.pipe(
+  z57.object({
+    to: smartUnion([number2(), string5()]),
+    amount: number2(),
+    flat_amount: optional3(number2()),
+    additional_currencies: optional3(
+      z57.array(z57.lazy(() => GetPlanLicenseTierAdditionalCurrency$inboundSchema))
+    )
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "flat_amount": "flatAmount",
+      "additional_currencies": "additionalCurrencies"
+    });
+  })
+);
+var GetPlanLicenseTierBehavior$inboundSchema = inboundSchema(GetPlanLicenseTierBehavior);
+var GetPlanLicenseAddItemPriceInterval$inboundSchema = inboundSchema(GetPlanLicenseAddItemPriceInterval);
+var GetPlanLicenseAddItemBillingMethod$inboundSchema = inboundSchema(GetPlanLicenseAddItemBillingMethod);
+var GetPlanLicensePrice$inboundSchema = z57.pipe(
+  z57.object({
+    amount: optional3(number2()),
+    additional_currencies: optional3(z57.array(z57.lazy(
+      () => GetPlanLicenseAddItemAdditionalCurrency$inboundSchema
+    ))),
+    tiers: optional3(z57.array(z57.lazy(
+      () => GetPlanLicensePriceTier$inboundSchema
+    ))),
+    tier_behavior: optional3(GetPlanLicenseTierBehavior$inboundSchema),
+    interval: GetPlanLicenseAddItemPriceInterval$inboundSchema,
+    interval_count: z57._default(number2(), 1),
+    billing_units: z57._default(number2(), 1),
+    billing_method: GetPlanLicenseAddItemBillingMethod$inboundSchema,
+    max_purchase: z57.optional(z57.nullable(number2()))
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "additional_currencies": "additionalCurrencies",
+      "tier_behavior": "tierBehavior",
+      "interval_count": "intervalCount",
+      "billing_units": "billingUnits",
+      "billing_method": "billingMethod",
+      "max_purchase": "maxPurchase"
+    });
+  })
+);
+var GetPlanLicenseOnIncrease$inboundSchema = inboundSchema(GetPlanLicenseOnIncrease);
+var GetPlanLicenseOnDecrease$inboundSchema = inboundSchema(GetPlanLicenseOnDecrease);
+var GetPlanLicenseProration$inboundSchema = z57.pipe(
+  z57.object({
+    on_increase: GetPlanLicenseOnIncrease$inboundSchema,
+    on_decrease: GetPlanLicenseOnDecrease$inboundSchema
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "on_increase": "onIncrease",
+      "on_decrease": "onDecrease"
+    });
+  })
+);
+var GetPlanLicenseExpiryDurationType$inboundSchema = inboundSchema(GetPlanLicenseExpiryDurationType);
+var GetPlanLicenseRollover$inboundSchema = z57.pipe(
+  z57.object({
+    max: optional3(number2()),
+    max_percentage: optional3(number2()),
+    expiry_duration_type: GetPlanLicenseExpiryDurationType$inboundSchema,
+    expiry_duration_length: optional3(number2())
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "max_percentage": "maxPercentage",
+      "expiry_duration_type": "expiryDurationType",
+      "expiry_duration_length": "expiryDurationLength"
+    });
+  })
+);
+var GetPlanLicenseDuration$inboundSchema = inboundSchema(GetPlanLicenseDuration);
+var GetPlanLicenseExpiry$inboundSchema = z57.object({
+  duration: GetPlanLicenseDuration$inboundSchema,
+  length: number2()
+});
+var GetPlanDimensionsLicense4$inboundSchema = z57.pipe(
+  z57.object({
+    match: z57.record(z57.string(), string5()),
+    priority: optional3(number2()),
+    credit_cost: number2()
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var GetPlanDimensionsToLicenseEnum2$inboundSchema = z57.enum(GetPlanDimensionsToLicenseEnum2);
+var GetPlanDimensionsLicenseToUnion2$inboundSchema = smartUnion([number2(), GetPlanDimensionsToLicenseEnum2$inboundSchema]);
+var GetPlanDimensionsLicenseTier2$inboundSchema = z57.pipe(
+  z57.object({
+    to: smartUnion([
+      number2(),
+      GetPlanDimensionsToLicenseEnum2$inboundSchema
+    ]),
+    credit_cost: number2()
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var GetPlanDimensionsLicense3$inboundSchema = z57.pipe(
+  z57.object({
+    match: z57.record(z57.string(), string5()),
+    priority: optional3(number2()),
+    tier_behavior: literal3("graduated"),
+    tiers: z57.array(z57.lazy(() => GetPlanDimensionsLicenseTier2$inboundSchema))
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "tier_behavior": "tierBehavior"
+    });
+  })
+);
+var GetPlanLicenseDimensionsUnion2$inboundSchema = smartUnion([
+  z57.lazy(() => GetPlanDimensionsLicense3$inboundSchema),
+  z57.lazy(() => GetPlanDimensionsLicense4$inboundSchema)
+]);
+var GetPlanLicenseMultipliers2$inboundSchema = z57.object({
+  match: z57.record(z57.string(), string5()),
+  factor: optional3(number2()),
+  add: optional3(number2())
+});
+var GetPlanCreditSchemaLicense2$inboundSchema = z57.pipe(
+  z57.object({
+    metered_feature_id: string5(),
+    billing_units: optional3(number2()),
+    dimensions: optional3(z57.record(
+      z57.string(),
+      smartUnion([
+        z57.lazy(() => GetPlanDimensionsLicense3$inboundSchema),
+        z57.lazy(() => GetPlanDimensionsLicense4$inboundSchema)
+      ])
+    )),
+    multipliers: optional3(z57.record(
+      z57.string(),
+      z57.lazy(() => GetPlanLicenseMultipliers2$inboundSchema)
+    )),
+    credit_cost: number2()
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "metered_feature_id": "meteredFeatureId",
+      "billing_units": "billingUnits",
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var GetPlanDimensionsLicense2$inboundSchema = z57.pipe(
+  z57.object({
+    match: z57.record(z57.string(), string5()),
+    priority: optional3(number2()),
+    credit_cost: number2()
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var GetPlanDimensionsToLicenseEnum1$inboundSchema = z57.enum(GetPlanDimensionsToLicenseEnum1);
+var GetPlanDimensionsLicenseToUnion1$inboundSchema = smartUnion([number2(), GetPlanDimensionsToLicenseEnum1$inboundSchema]);
+var GetPlanDimensionsLicenseTier1$inboundSchema = z57.pipe(
+  z57.object({
+    to: smartUnion([
+      number2(),
+      GetPlanDimensionsToLicenseEnum1$inboundSchema
+    ]),
+    credit_cost: number2()
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var GetPlanDimensionsLicense1$inboundSchema = z57.pipe(
+  z57.object({
+    match: z57.record(z57.string(), string5()),
+    priority: optional3(number2()),
+    tier_behavior: literal3("graduated"),
+    tiers: z57.array(z57.lazy(() => GetPlanDimensionsLicenseTier1$inboundSchema))
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "tier_behavior": "tierBehavior"
+    });
+  })
+);
+var GetPlanLicenseDimensionsUnion1$inboundSchema = smartUnion([
+  z57.lazy(() => GetPlanDimensionsLicense1$inboundSchema),
+  z57.lazy(() => GetPlanDimensionsLicense2$inboundSchema)
+]);
+var GetPlanLicenseMultipliers1$inboundSchema = z57.object({
+  match: z57.record(z57.string(), string5()),
+  factor: optional3(number2()),
+  add: optional3(number2())
+});
+var GetPlanToLicenseEnum$inboundSchema = z57.enum(GetPlanToLicenseEnum);
+var GetPlanLicenseFeatureOverrideToUnion$inboundSchema = smartUnion([number2(), GetPlanToLicenseEnum$inboundSchema]);
+var GetPlanLicenseFeatureOverrideTier$inboundSchema = z57.pipe(
+  z57.object({
+    to: smartUnion([number2(), GetPlanToLicenseEnum$inboundSchema]),
+    credit_cost: number2()
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var GetPlanCreditSchemaLicense1$inboundSchema = z57.pipe(
+  z57.object({
+    metered_feature_id: string5(),
+    billing_units: optional3(number2()),
+    dimensions: optional3(z57.record(
+      z57.string(),
+      smartUnion([
+        z57.lazy(() => GetPlanDimensionsLicense1$inboundSchema),
+        z57.lazy(() => GetPlanDimensionsLicense2$inboundSchema)
+      ])
+    )),
+    multipliers: optional3(z57.record(
+      z57.string(),
+      z57.lazy(() => GetPlanLicenseMultipliers1$inboundSchema)
+    )),
+    tier_behavior: literal3("graduated"),
+    tiers: z57.array(z57.lazy(
+      () => GetPlanLicenseFeatureOverrideTier$inboundSchema
+    ))
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "metered_feature_id": "meteredFeatureId",
+      "billing_units": "billingUnits",
+      "tier_behavior": "tierBehavior"
+    });
+  })
+);
+var GetPlanLicenseCreditSchemaUnion$inboundSchema = smartUnion([
+  z57.lazy(() => GetPlanCreditSchemaLicense1$inboundSchema),
+  z57.lazy(() => GetPlanCreditSchemaLicense2$inboundSchema)
+]);
+var GetPlanLicenseProviderMarkups$inboundSchema = z57.object({
+  markup: number2()
+});
+var GetPlanLicenseModelMarkups$inboundSchema = z57.pipe(
+  z57.object({
+    markup: optional3(number2()),
+    input_cost: optional3(number2()),
+    output_cost: optional3(number2())
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "input_cost": "inputCost",
+      "output_cost": "outputCost"
+    });
+  })
+);
+var GetPlanLicenseMarkups$inboundSchema = z57.pipe(
+  z57.object({
+    default_markup: optional3(number2()),
+    provider_markups: z57.optional(z57.nullable(z57.record(
+      z57.string(),
+      z57.lazy(() => GetPlanLicenseProviderMarkups$inboundSchema)
+    ))),
+    model_markups: z57.optional(z57.nullable(z57.record(
+      z57.string(),
+      z57.lazy(() => GetPlanLicenseModelMarkups$inboundSchema)
+    )))
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "default_markup": "defaultMarkup",
+      "provider_markups": "providerMarkups",
+      "model_markups": "modelMarkups"
+    });
+  })
+);
+var GetPlanLicenseFeatureOverride$inboundSchema = z57.pipe(
+  z57.object({
+    credit_schema: optional3(z57.array(smartUnion([
+      z57.lazy(() => GetPlanCreditSchemaLicense1$inboundSchema),
+      z57.lazy(
+        () => GetPlanCreditSchemaLicense2$inboundSchema
+      )
+    ]))),
+    markups: optional3(z57.lazy(
+      () => GetPlanLicenseMarkups$inboundSchema
+    ))
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "credit_schema": "creditSchema"
+    });
+  })
+);
+var GetPlanLicensePlanItem$inboundSchema = z57.pipe(
+  z57.object({
+    threshold_billing: z57.optional(
+      z57.nullable(z57.lazy(() => GetPlanLicenseThresholdBilling$inboundSchema))
+    ),
+    feature_id: string5(),
+    included: optional3(number2()),
+    unlimited: optional3(boolean2()),
+    pooled: z57._default(boolean2(), false),
+    reset: optional3(z57.lazy(() => GetPlanLicenseReset$inboundSchema)),
+    price: optional3(z57.lazy(() => GetPlanLicensePrice$inboundSchema)),
+    proration: optional3(
+      z57.lazy(() => GetPlanLicenseProration$inboundSchema)
+    ),
+    rollover: optional3(
+      z57.lazy(() => GetPlanLicenseRollover$inboundSchema)
+    ),
+    expiry: optional3(z57.lazy(() => GetPlanLicenseExpiry$inboundSchema)),
+    feature_override: optional3(
+      z57.lazy(() => GetPlanLicenseFeatureOverride$inboundSchema)
+    )
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "threshold_billing": "thresholdBilling",
+      "feature_id": "featureId",
+      "feature_override": "featureOverride"
+    });
+  })
+);
+var GetPlanLicenseRemoveItemBillingMethod$inboundSchema = inboundSchema(GetPlanLicenseRemoveItemBillingMethod);
+var GetPlanIntervalLicenseRemoveItemEnum2$inboundSchema = inboundSchema(GetPlanIntervalLicenseRemoveItemEnum2);
+var GetPlanIntervalLicenseRemoveItemEnum1$inboundSchema = inboundSchema(GetPlanIntervalLicenseRemoveItemEnum1);
+var GetPlanLicenseIntervalUnion$inboundSchema = smartUnion([
+  GetPlanIntervalLicenseRemoveItemEnum1$inboundSchema,
+  GetPlanIntervalLicenseRemoveItemEnum2$inboundSchema
+]);
+var GetPlanLicensePlanItemFilter$inboundSchema = z57.pipe(
+  z57.object({
+    feature_id: optional3(string5()),
+    billing_method: optional3(
+      GetPlanLicenseRemoveItemBillingMethod$inboundSchema
+    ),
+    interval: optional3(
+      smartUnion([
+        GetPlanIntervalLicenseRemoveItemEnum1$inboundSchema,
+        GetPlanIntervalLicenseRemoveItemEnum2$inboundSchema
+      ])
+    ),
+    interval_count: optional3(number2()),
+    included: optional3(number2())
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "billing_method": "billingMethod",
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var GetPlanLicenseCustomize$inboundSchema = z57.pipe(
+  z57.object({
+    price: z57.optional(
+      z57.nullable(z57.lazy(() => GetPlanLicenseBasePrice$inboundSchema))
+    ),
+    add_items: optional3(
+      z57.array(z57.lazy(() => GetPlanLicensePlanItem$inboundSchema))
+    ),
+    remove_items: optional3(
+      z57.array(z57.lazy(() => GetPlanLicensePlanItemFilter$inboundSchema))
+    )
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "add_items": "addItems",
+      "remove_items": "removeItems"
+    });
+  })
+);
+var GetPlanLicense$inboundSchema = z57.pipe(
+  z57.object({
+    license_plan_id: string5(),
+    version: number2(),
+    version_slug: optional3(string5()),
+    included: number2(),
+    prepaid_only: boolean2(),
+    customize: optional3(
+      z57.lazy(() => GetPlanLicenseCustomize$inboundSchema)
+    ),
+    metadata: optional3(z57.record(z57.string(), z57.any())),
+    plan: optional3(Plan$inboundSchema)
+  }),
+  z57.transform((v) => {
+    return remap(v, {
+      "license_plan_id": "licensePlanId",
+      "version_slug": "versionSlug",
+      "prepaid_only": "prepaidOnly"
+    });
+  })
+);
 var GetPlanResponse$inboundSchema = z57.pipe(
   z57.object({
     id: string5(),
@@ -26310,6 +27488,9 @@ var GetPlanResponse$inboundSchema = z57.pipe(
     base_variant_id: nullable(string5()),
     variant_details: optional3(
       z57.lazy(() => GetPlanVariantDetails$inboundSchema)
+    ),
+    licenses: optional3(
+      z57.array(z57.lazy(() => GetPlanLicense$inboundSchema))
     )
   }),
   z57.transform((v) => {
@@ -48238,7 +49419,7 @@ var UpdatePlanDimensionsToItemRequestBodyEnum1 = {
 var UpdatePlanToItemRequestBodyEnum = {
   Inf: "inf"
 };
-var UpdatePlanPriceLicenseInterval = {
+var UpdatePlanPriceLicenseIntervalRequestBody = {
   OneOff: "one_off",
   Week: "week",
   Month: "month",
@@ -48246,7 +49427,7 @@ var UpdatePlanPriceLicenseInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var UpdatePlanLicenseResetInterval = {
+var UpdatePlanLicenseResetIntervalRequestBody = {
   OneOff: "one_off",
   Minute: "minute",
   Hour: "hour",
@@ -48257,11 +49438,11 @@ var UpdatePlanLicenseResetInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var UpdatePlanLicenseTierBehavior = {
+var UpdatePlanLicenseTierBehaviorRequestBody = {
   Graduated: "graduated",
   Volume: "volume"
 };
-var UpdatePlanLicenseAddItemPriceInterval = {
+var UpdatePlanLicenseAddItemPriceIntervalRequestBody = {
   OneOff: "one_off",
   Week: "week",
   Month: "month",
@@ -48269,47 +49450,47 @@ var UpdatePlanLicenseAddItemPriceInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var UpdatePlanLicenseAddItemBillingMethod = {
+var UpdatePlanLicenseAddItemBillingMethodRequestBody = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
-var UpdatePlanLicenseOnIncrease = {
+var UpdatePlanLicenseOnIncreaseRequestBody = {
   BillImmediately: "bill_immediately",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
   BillNextCycle: "bill_next_cycle"
 };
-var UpdatePlanLicenseOnDecrease = {
+var UpdatePlanLicenseOnDecreaseRequestBody = {
   Prorate: "prorate",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
   None: "none",
   NoProrations: "no_prorations"
 };
-var UpdatePlanLicenseExpiryDurationType = {
+var UpdatePlanLicenseExpiryDurationTypeRequestBody = {
   Month: "month",
   Forever: "forever"
 };
-var UpdatePlanLicenseDuration = {
+var UpdatePlanLicenseDurationRequestBody = {
   Day: "day",
   Week: "week",
   Month: "month",
   Year: "year"
 };
-var UpdatePlanDimensionsToLicenseEnum2 = {
+var UpdatePlanDimensionsToLicenseRequestBodyEnum2 = {
   Inf: "inf"
 };
-var UpdatePlanDimensionsToLicenseEnum1 = {
+var UpdatePlanDimensionsToLicenseRequestBodyEnum1 = {
   Inf: "inf"
 };
-var UpdatePlanToLicenseEnum = {
+var UpdatePlanToLicenseRequestBodyEnum = {
   Inf: "inf"
 };
-var UpdatePlanLicenseRemoveItemBillingMethod = {
+var UpdatePlanLicenseRemoveItemBillingMethodRequestBody = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
-var UpdatePlanIntervalLicenseRemoveItemEnum2 = {
+var UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum2 = {
   OneOff: "one_off",
   Minute: "minute",
   Hour: "hour",
@@ -48320,7 +49501,7 @@ var UpdatePlanIntervalLicenseRemoveItemEnum2 = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var UpdatePlanIntervalLicenseRemoveItemEnum1 = {
+var UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum1 = {
   OneOff: "one_off",
   Week: "week",
   Month: "month",
@@ -48851,19 +50032,21 @@ var UpdatePlanItemPlanItem$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanPriceLicenseInterval$outboundSchema = z113.enum(UpdatePlanPriceLicenseInterval);
-var UpdatePlanLicenseAdditionalCurrency$outboundSchema = z113.object({
+var UpdatePlanPriceLicenseIntervalRequestBody$outboundSchema = z113.enum(
+  UpdatePlanPriceLicenseIntervalRequestBody
+);
+var UpdatePlanLicenseAdditionalCurrencyRequestBody$outboundSchema = z113.object({
   currency: z113.string(),
   amount: z113.number()
 });
-var UpdatePlanLicenseBasePrice$outboundSchema = z113.pipe(
+var UpdatePlanLicenseBasePriceRequestBody$outboundSchema = z113.pipe(
   z113.object({
     amount: z113.number(),
-    interval: UpdatePlanPriceLicenseInterval$outboundSchema,
+    interval: UpdatePlanPriceLicenseIntervalRequestBody$outboundSchema,
     intervalCount: z113._default(z113.number(), 1),
-    additionalCurrencies: z113.optional(
-      z113.array(z113.lazy(() => UpdatePlanLicenseAdditionalCurrency$outboundSchema))
-    )
+    additionalCurrencies: z113.optional(z113.array(z113.lazy(
+      () => UpdatePlanLicenseAdditionalCurrencyRequestBody$outboundSchema
+    )))
   }),
   z113.transform((v) => {
     return remap(v, {
@@ -48872,13 +50055,15 @@ var UpdatePlanLicenseBasePrice$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseThresholdBilling$outboundSchema = z113.object({
+var UpdatePlanLicenseThresholdBillingRequestBody$outboundSchema = z113.object({
   threshold: z113.number()
 });
-var UpdatePlanLicenseResetInterval$outboundSchema = z113.enum(UpdatePlanLicenseResetInterval);
-var UpdatePlanLicenseReset$outboundSchema = z113.pipe(
+var UpdatePlanLicenseResetIntervalRequestBody$outboundSchema = z113.enum(
+  UpdatePlanLicenseResetIntervalRequestBody
+);
+var UpdatePlanLicenseResetRequestBody$outboundSchema = z113.pipe(
   z113.object({
-    interval: UpdatePlanLicenseResetInterval$outboundSchema,
+    interval: UpdatePlanLicenseResetIntervalRequestBody$outboundSchema,
     intervalCount: z113._default(z113.number(), 1)
   }),
   z113.transform((v) => {
@@ -48887,12 +50072,12 @@ var UpdatePlanLicenseReset$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseAddItemAdditionalCurrency$outboundSchema = z113.object({
+var UpdatePlanLicenseAddItemAdditionalCurrencyRequestBody$outboundSchema = z113.object({
   currency: z113.string(),
   amount: z113.number()
 });
-var UpdatePlanLicensePriceTo$outboundSchema = smartUnion([z113.number(), z113.string()]);
-var UpdatePlanLicenseTierAdditionalCurrency$outboundSchema = z113.pipe(
+var UpdatePlanLicensePriceToRequestBody$outboundSchema = smartUnion([z113.number(), z113.string()]);
+var UpdatePlanLicenseTierAdditionalCurrencyRequestBody$outboundSchema = z113.pipe(
   z113.object({
     currency: z113.string(),
     amount: z113.optional(z113.number()),
@@ -48904,13 +50089,13 @@ var UpdatePlanLicenseTierAdditionalCurrency$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicensePriceTier$outboundSchema = z113.pipe(
+var UpdatePlanLicensePriceTierRequestBody$outboundSchema = z113.pipe(
   z113.object({
     to: smartUnion([z113.number(), z113.string()]),
     amount: z113.optional(z113.number()),
     flatAmount: z113.optional(z113.number()),
     additionalCurrencies: z113.optional(z113.array(z113.lazy(
-      () => UpdatePlanLicenseTierAdditionalCurrency$outboundSchema
+      () => UpdatePlanLicenseTierAdditionalCurrencyRequestBody$outboundSchema
     )))
   }),
   z113.transform((v) => {
@@ -48920,27 +50105,27 @@ var UpdatePlanLicensePriceTier$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseTierBehavior$outboundSchema = z113.enum(UpdatePlanLicenseTierBehavior);
-var UpdatePlanLicenseAddItemPriceInterval$outboundSchema = z113.enum(
-  UpdatePlanLicenseAddItemPriceInterval
-);
-var UpdatePlanLicenseAddItemBillingMethod$outboundSchema = z113.enum(
-  UpdatePlanLicenseAddItemBillingMethod
+var UpdatePlanLicenseTierBehaviorRequestBody$outboundSchema = z113.enum(
+  UpdatePlanLicenseTierBehaviorRequestBody
 );
-var UpdatePlanLicensePrice$outboundSchema = z113.pipe(
+var UpdatePlanLicenseAddItemPriceIntervalRequestBody$outboundSchema = z113.enum(UpdatePlanLicenseAddItemPriceIntervalRequestBody);
+var UpdatePlanLicenseAddItemBillingMethodRequestBody$outboundSchema = z113.enum(UpdatePlanLicenseAddItemBillingMethodRequestBody);
+var UpdatePlanLicensePriceRequestBody$outboundSchema = z113.pipe(
   z113.object({
     amount: z113.optional(z113.number()),
     additionalCurrencies: z113.optional(z113.array(z113.lazy(
-      () => UpdatePlanLicenseAddItemAdditionalCurrency$outboundSchema
+      () => UpdatePlanLicenseAddItemAdditionalCurrencyRequestBody$outboundSchema
     ))),
     tiers: z113.optional(z113.array(z113.lazy(
-      () => UpdatePlanLicensePriceTier$outboundSchema
+      () => UpdatePlanLicensePriceTierRequestBody$outboundSchema
     ))),
-    tierBehavior: z113.optional(UpdatePlanLicenseTierBehavior$outboundSchema),
-    interval: UpdatePlanLicenseAddItemPriceInterval$outboundSchema,
+    tierBehavior: z113.optional(
+      UpdatePlanLicenseTierBehaviorRequestBody$outboundSchema
+    ),
+    interval: UpdatePlanLicenseAddItemPriceIntervalRequestBody$outboundSchema,
     intervalCount: z113._default(z113.number(), 1),
     billingUnits: z113._default(z113.number(), 1),
-    billingMethod: UpdatePlanLicenseAddItemBillingMethod$outboundSchema,
+    billingMethod: UpdatePlanLicenseAddItemBillingMethodRequestBody$outboundSchema,
     maxPurchase: z113.optional(z113.nullable(z113.number()))
   }),
   z113.transform((v) => {
@@ -48954,12 +50139,16 @@ var UpdatePlanLicensePrice$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseOnIncrease$outboundSchema = z113.enum(UpdatePlanLicenseOnIncrease);
-var UpdatePlanLicenseOnDecrease$outboundSchema = z113.enum(UpdatePlanLicenseOnDecrease);
-var UpdatePlanLicenseProration$outboundSchema = z113.pipe(
+var UpdatePlanLicenseOnIncreaseRequestBody$outboundSchema = z113.enum(
+  UpdatePlanLicenseOnIncreaseRequestBody
+);
+var UpdatePlanLicenseOnDecreaseRequestBody$outboundSchema = z113.enum(
+  UpdatePlanLicenseOnDecreaseRequestBody
+);
+var UpdatePlanLicenseProrationRequestBody$outboundSchema = z113.pipe(
   z113.object({
-    onIncrease: UpdatePlanLicenseOnIncrease$outboundSchema,
-    onDecrease: UpdatePlanLicenseOnDecrease$outboundSchema
+    onIncrease: UpdatePlanLicenseOnIncreaseRequestBody$outboundSchema,
+    onDecrease: UpdatePlanLicenseOnDecreaseRequestBody$outboundSchema
   }),
   z113.transform((v) => {
     return remap(v, {
@@ -48968,12 +50157,14 @@ var UpdatePlanLicenseProration$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseExpiryDurationType$outboundSchema = z113.enum(UpdatePlanLicenseExpiryDurationType);
-var UpdatePlanLicenseRollover$outboundSchema = z113.pipe(
+var UpdatePlanLicenseExpiryDurationTypeRequestBody$outboundSchema = z113.enum(
+  UpdatePlanLicenseExpiryDurationTypeRequestBody
+);
+var UpdatePlanLicenseRolloverRequestBody$outboundSchema = z113.pipe(
   z113.object({
     max: z113.optional(z113.number()),
     maxPercentage: z113.optional(z113.number()),
-    expiryDurationType: UpdatePlanLicenseExpiryDurationType$outboundSchema,
+    expiryDurationType: UpdatePlanLicenseExpiryDurationTypeRequestBody$outboundSchema,
     expiryDurationLength: z113.optional(z113.number())
   }),
   z113.transform((v) => {
@@ -48984,13 +50175,13 @@ var UpdatePlanLicenseRollover$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseDuration$outboundSchema = z113.enum(UpdatePlanLicenseDuration);
-var UpdatePlanLicenseExpiry$outboundSchema = z113.object({
-  duration: UpdatePlanLicenseDuration$outboundSchema,
+var UpdatePlanLicenseDurationRequestBody$outboundSchema = z113.enum(UpdatePlanLicenseDurationRequestBody);
+var UpdatePlanLicenseExpiryRequestBody$outboundSchema = z113.object({
+  duration: UpdatePlanLicenseDurationRequestBody$outboundSchema,
   length: z113.number()
 });
 var UpdatePlanDimensionsLicenseMatch4$outboundSchema = smartUnion([z113.string(), z113.number(), z113.boolean()]);
-var UpdatePlanDimensionsLicense4$outboundSchema = z113.pipe(
+var UpdatePlanDimensionsLicenseRequestBody4$outboundSchema = z113.pipe(
   z113.object({
     match: z113.record(
       z113.string(),
@@ -49006,13 +50197,18 @@ var UpdatePlanDimensionsLicense4$outboundSchema = z113.pipe(
   })
 );
 var UpdatePlanDimensionsLicenseMatch3$outboundSchema = smartUnion([z113.string(), z113.number(), z113.boolean()]);
-var UpdatePlanDimensionsToLicenseEnum2$outboundSchema = z113.enum(UpdatePlanDimensionsToLicenseEnum2);
-var UpdatePlanDimensionsLicenseToUnion2$outboundSchema = smartUnion([z113.number(), UpdatePlanDimensionsToLicenseEnum2$outboundSchema]);
-var UpdatePlanDimensionsLicenseTier2$outboundSchema = z113.pipe(
+var UpdatePlanDimensionsToLicenseRequestBodyEnum2$outboundSchema = z113.enum(
+  UpdatePlanDimensionsToLicenseRequestBodyEnum2
+);
+var UpdatePlanDimensionsLicenseToRequestBodyUnion2$outboundSchema = smartUnion([
+  z113.number(),
+  UpdatePlanDimensionsToLicenseRequestBodyEnum2$outboundSchema
+]);
+var UpdatePlanDimensionsLicenseTierRequestBody2$outboundSchema = z113.pipe(
   z113.object({
     to: smartUnion([
       z113.number(),
-      UpdatePlanDimensionsToLicenseEnum2$outboundSchema
+      UpdatePlanDimensionsToLicenseRequestBodyEnum2$outboundSchema
     ]),
     creditCost: z113.number()
   }),
@@ -49022,7 +50218,7 @@ var UpdatePlanDimensionsLicenseTier2$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanDimensionsLicense3$outboundSchema = z113.pipe(
+var UpdatePlanDimensionsLicenseRequestBody3$outboundSchema = z113.pipe(
   z113.object({
     match: z113.record(
       z113.string(),
@@ -49031,7 +50227,9 @@ var UpdatePlanDimensionsLicense3$outboundSchema = z113.pipe(
     priority: z113.optional(z113.int()),
     tierBehavior: z113.literal("graduated"),
     tiers: z113.array(
-      z113.lazy(() => UpdatePlanDimensionsLicenseTier2$outboundSchema)
+      z113.lazy(
+        () => UpdatePlanDimensionsLicenseTierRequestBody2$outboundSchema
+      )
     )
   }),
   z113.transform((v) => {
@@ -49040,12 +50238,12 @@ var UpdatePlanDimensionsLicense3$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseDimensionsUnion2$outboundSchema = smartUnion([
-  z113.lazy(() => UpdatePlanDimensionsLicense3$outboundSchema),
-  z113.lazy(() => UpdatePlanDimensionsLicense4$outboundSchema)
+var UpdatePlanLicenseDimensionsRequestBodyUnion2$outboundSchema = smartUnion([
+  z113.lazy(() => UpdatePlanDimensionsLicenseRequestBody3$outboundSchema),
+  z113.lazy(() => UpdatePlanDimensionsLicenseRequestBody4$outboundSchema)
 ]);
 var UpdatePlanLicenseMultipliersMatch2$outboundSchema = smartUnion([z113.string(), z113.number(), z113.boolean()]);
-var UpdatePlanLicenseMultipliers2$outboundSchema = z113.object({
+var UpdatePlanLicenseMultipliersRequestBody2$outboundSchema = z113.object({
   match: z113.record(
     z113.string(),
     smartUnion([z113.string(), z113.number(), z113.boolean()])
@@ -49053,20 +50251,20 @@ var UpdatePlanLicenseMultipliers2$outboundSchema = z113.object({
   factor: z113.optional(z113.number()),
   add: z113.optional(z113.number())
 });
-var UpdatePlanCreditSchemaLicense2$outboundSchema = z113.pipe(
+var UpdatePlanCreditSchemaLicenseRequestBody2$outboundSchema = z113.pipe(
   z113.object({
     meteredFeatureId: z113.string(),
     billingUnits: z113.optional(z113.number()),
     dimensions: z113.optional(z113.record(
       z113.string(),
       smartUnion([
-        z113.lazy(() => UpdatePlanDimensionsLicense3$outboundSchema),
-        z113.lazy(() => UpdatePlanDimensionsLicense4$outboundSchema)
+        z113.lazy(() => UpdatePlanDimensionsLicenseRequestBody3$outboundSchema),
+        z113.lazy(() => UpdatePlanDimensionsLicenseRequestBody4$outboundSchema)
       ])
     )),
     multipliers: z113.optional(z113.record(
       z113.string(),
-      z113.lazy(() => UpdatePlanLicenseMultipliers2$outboundSchema)
+      z113.lazy(() => UpdatePlanLicenseMultipliersRequestBody2$outboundSchema)
     )),
     creditCost: z113.number()
   }),
@@ -49079,7 +50277,7 @@ var UpdatePlanCreditSchemaLicense2$outboundSchema = z113.pipe(
   })
 );
 var UpdatePlanDimensionsLicenseMatch2$outboundSchema = smartUnion([z113.string(), z113.number(), z113.boolean()]);
-var UpdatePlanDimensionsLicense2$outboundSchema = z113.pipe(
+var UpdatePlanDimensionsLicenseRequestBody2$outboundSchema = z113.pipe(
   z113.object({
     match: z113.record(
       z113.string(),
@@ -49095,13 +50293,18 @@ var UpdatePlanDimensionsLicense2$outboundSchema = z113.pipe(
   })
 );
 var UpdatePlanDimensionsLicenseMatch1$outboundSchema = smartUnion([z113.string(), z113.number(), z113.boolean()]);
-var UpdatePlanDimensionsToLicenseEnum1$outboundSchema = z113.enum(UpdatePlanDimensionsToLicenseEnum1);
-var UpdatePlanDimensionsLicenseToUnion1$outboundSchema = smartUnion([z113.number(), UpdatePlanDimensionsToLicenseEnum1$outboundSchema]);
-var UpdatePlanDimensionsLicenseTier1$outboundSchema = z113.pipe(
+var UpdatePlanDimensionsToLicenseRequestBodyEnum1$outboundSchema = z113.enum(
+  UpdatePlanDimensionsToLicenseRequestBodyEnum1
+);
+var UpdatePlanDimensionsLicenseToRequestBodyUnion1$outboundSchema = smartUnion([
+  z113.number(),
+  UpdatePlanDimensionsToLicenseRequestBodyEnum1$outboundSchema
+]);
+var UpdatePlanDimensionsLicenseTierRequestBody1$outboundSchema = z113.pipe(
   z113.object({
     to: smartUnion([
       z113.number(),
-      UpdatePlanDimensionsToLicenseEnum1$outboundSchema
+      UpdatePlanDimensionsToLicenseRequestBodyEnum1$outboundSchema
     ]),
     creditCost: z113.number()
   }),
@@ -49111,7 +50314,7 @@ var UpdatePlanDimensionsLicenseTier1$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanDimensionsLicense1$outboundSchema = z113.pipe(
+var UpdatePlanDimensionsLicenseRequestBody1$outboundSchema = z113.pipe(
   z113.object({
     match: z113.record(
       z113.string(),
@@ -49120,7 +50323,9 @@ var UpdatePlanDimensionsLicense1$outboundSchema = z113.pipe(
     priority: z113.optional(z113.int()),
     tierBehavior: z113.literal("graduated"),
     tiers: z113.array(
-      z113.lazy(() => UpdatePlanDimensionsLicenseTier1$outboundSchema)
+      z113.lazy(
+        () => UpdatePlanDimensionsLicenseTierRequestBody1$outboundSchema
+      )
     )
   }),
   z113.transform((v) => {
@@ -49129,12 +50334,12 @@ var UpdatePlanDimensionsLicense1$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseDimensionsUnion1$outboundSchema = smartUnion([
-  z113.lazy(() => UpdatePlanDimensionsLicense1$outboundSchema),
-  z113.lazy(() => UpdatePlanDimensionsLicense2$outboundSchema)
+var UpdatePlanLicenseDimensionsRequestBodyUnion1$outboundSchema = smartUnion([
+  z113.lazy(() => UpdatePlanDimensionsLicenseRequestBody1$outboundSchema),
+  z113.lazy(() => UpdatePlanDimensionsLicenseRequestBody2$outboundSchema)
 ]);
 var UpdatePlanLicenseMultipliersMatch1$outboundSchema = smartUnion([z113.string(), z113.number(), z113.boolean()]);
-var UpdatePlanLicenseMultipliers1$outboundSchema = z113.object({
+var UpdatePlanLicenseMultipliersRequestBody1$outboundSchema = z113.object({
   match: z113.record(
     z113.string(),
     smartUnion([z113.string(), z113.number(), z113.boolean()])
@@ -49142,11 +50347,17 @@ var UpdatePlanLicenseMultipliers1$outboundSchema = z113.object({
   factor: z113.optional(z113.number()),
   add: z113.optional(z113.number())
 });
-var UpdatePlanToLicenseEnum$outboundSchema = z113.enum(UpdatePlanToLicenseEnum);
-var UpdatePlanLicenseFeatureOverrideToUnion$outboundSchema = smartUnion([z113.number(), UpdatePlanToLicenseEnum$outboundSchema]);
-var UpdatePlanLicenseFeatureOverrideTier$outboundSchema = z113.pipe(
+var UpdatePlanToLicenseRequestBodyEnum$outboundSchema = z113.enum(UpdatePlanToLicenseRequestBodyEnum);
+var UpdatePlanLicenseFeatureOverrideToRequestBodyUnion$outboundSchema = smartUnion([
+  z113.number(),
+  UpdatePlanToLicenseRequestBodyEnum$outboundSchema
+]);
+var UpdatePlanLicenseFeatureOverrideTierRequestBody$outboundSchema = z113.pipe(
   z113.object({
-    to: smartUnion([z113.number(), UpdatePlanToLicenseEnum$outboundSchema]),
+    to: smartUnion([
+      z113.number(),
+      UpdatePlanToLicenseRequestBodyEnum$outboundSchema
+    ]),
     creditCost: z113.number()
   }),
   z113.transform((v) => {
@@ -49155,24 +50366,24 @@ var UpdatePlanLicenseFeatureOverrideTier$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanCreditSchemaLicense1$outboundSchema = z113.pipe(
+var UpdatePlanCreditSchemaLicenseRequestBody1$outboundSchema = z113.pipe(
   z113.object({
     meteredFeatureId: z113.string(),
     billingUnits: z113.optional(z113.number()),
     dimensions: z113.optional(z113.record(
       z113.string(),
       smartUnion([
-        z113.lazy(() => UpdatePlanDimensionsLicense1$outboundSchema),
-        z113.lazy(() => UpdatePlanDimensionsLicense2$outboundSchema)
+        z113.lazy(() => UpdatePlanDimensionsLicenseRequestBody1$outboundSchema),
+        z113.lazy(() => UpdatePlanDimensionsLicenseRequestBody2$outboundSchema)
       ])
     )),
     multipliers: z113.optional(z113.record(
       z113.string(),
-      z113.lazy(() => UpdatePlanLicenseMultipliers1$outboundSchema)
+      z113.lazy(() => UpdatePlanLicenseMultipliersRequestBody1$outboundSchema)
     )),
     tierBehavior: z113.literal("graduated"),
     tiers: z113.array(z113.lazy(
-      () => UpdatePlanLicenseFeatureOverrideTier$outboundSchema
+      () => UpdatePlanLicenseFeatureOverrideTierRequestBody$outboundSchema
     ))
   }),
   z113.transform((v) => {
@@ -49183,14 +50394,14 @@ var UpdatePlanCreditSchemaLicense1$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseCreditSchemaUnion$outboundSchema = smartUnion([
-  z113.lazy(() => UpdatePlanCreditSchemaLicense1$outboundSchema),
-  z113.lazy(() => UpdatePlanCreditSchemaLicense2$outboundSchema)
+var UpdatePlanLicenseCreditSchemaRequestBodyUnion$outboundSchema = smartUnion([
+  z113.lazy(() => UpdatePlanCreditSchemaLicenseRequestBody1$outboundSchema),
+  z113.lazy(() => UpdatePlanCreditSchemaLicenseRequestBody2$outboundSchema)
 ]);
-var UpdatePlanLicenseProviderMarkups$outboundSchema = z113.object({
+var UpdatePlanLicenseProviderMarkupsRequestBody$outboundSchema = z113.object({
   markup: z113.number()
 });
-var UpdatePlanLicenseModelMarkups$outboundSchema = z113.pipe(
+var UpdatePlanLicenseModelMarkupsRequestBody$outboundSchema = z113.pipe(
   z113.object({
     markup: z113.optional(z113.number()),
     inputCost: z113.optional(z113.number()),
@@ -49203,16 +50414,16 @@ var UpdatePlanLicenseModelMarkups$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseMarkups$outboundSchema = z113.pipe(
+var UpdatePlanLicenseMarkupsRequestBody$outboundSchema = z113.pipe(
   z113.object({
     defaultMarkup: z113.optional(z113.number()),
     providerMarkups: z113.optional(z113.nullable(z113.record(
       z113.string(),
-      z113.lazy(() => UpdatePlanLicenseProviderMarkups$outboundSchema)
+      z113.lazy(() => UpdatePlanLicenseProviderMarkupsRequestBody$outboundSchema)
     ))),
     modelMarkups: z113.optional(z113.nullable(z113.record(
       z113.string(),
-      z113.lazy(() => UpdatePlanLicenseModelMarkups$outboundSchema)
+      z113.lazy(() => UpdatePlanLicenseModelMarkupsRequestBody$outboundSchema)
     )))
   }),
   z113.transform((v) => {
@@ -49223,16 +50434,16 @@ var UpdatePlanLicenseMarkups$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseFeatureOverride$outboundSchema = z113.pipe(
+var UpdatePlanLicenseFeatureOverrideRequestBody$outboundSchema = z113.pipe(
   z113.object({
     creditSchema: z113.optional(z113.array(smartUnion([
-      z113.lazy(() => UpdatePlanCreditSchemaLicense1$outboundSchema),
+      z113.lazy(() => UpdatePlanCreditSchemaLicenseRequestBody1$outboundSchema),
       z113.lazy(
-        () => UpdatePlanCreditSchemaLicense2$outboundSchema
+        () => UpdatePlanCreditSchemaLicenseRequestBody2$outboundSchema
       )
     ]))),
     markups: z113.optional(z113.lazy(
-      () => UpdatePlanLicenseMarkups$outboundSchema
+      () => UpdatePlanLicenseMarkupsRequestBody$outboundSchema
     ))
   }),
   z113.transform((v) => {
@@ -49241,29 +50452,33 @@ var UpdatePlanLicenseFeatureOverride$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicensePlanItem$outboundSchema = z113.pipe(
+var UpdatePlanLicensePlanItemRequestBody$outboundSchema = z113.pipe(
   z113.object({
-    thresholdBilling: z113.optional(
-      z113.nullable(
-        z113.lazy(() => UpdatePlanLicenseThresholdBilling$outboundSchema)
-      )
-    ),
+    thresholdBilling: z113.optional(z113.nullable(z113.lazy(
+      () => UpdatePlanLicenseThresholdBillingRequestBody$outboundSchema
+    ))),
     featureId: z113.string(),
     included: z113.optional(z113.number()),
     unlimited: z113.optional(z113.boolean()),
     pooled: z113._default(z113.boolean(), false),
-    reset: z113.optional(z113.lazy(() => UpdatePlanLicenseReset$outboundSchema)),
-    price: z113.optional(z113.lazy(() => UpdatePlanLicensePrice$outboundSchema)),
-    proration: z113.optional(
-      z113.lazy(() => UpdatePlanLicenseProration$outboundSchema)
-    ),
-    rollover: z113.optional(
-      z113.lazy(() => UpdatePlanLicenseRollover$outboundSchema)
-    ),
-    expiry: z113.optional(z113.lazy(() => UpdatePlanLicenseExpiry$outboundSchema)),
-    featureOverride: z113.optional(
-      z113.lazy(() => UpdatePlanLicenseFeatureOverride$outboundSchema)
-    )
+    reset: z113.optional(z113.lazy(
+      () => UpdatePlanLicenseResetRequestBody$outboundSchema
+    )),
+    price: z113.optional(z113.lazy(
+      () => UpdatePlanLicensePriceRequestBody$outboundSchema
+    )),
+    proration: z113.optional(z113.lazy(
+      () => UpdatePlanLicenseProrationRequestBody$outboundSchema
+    )),
+    rollover: z113.optional(z113.lazy(
+      () => UpdatePlanLicenseRolloverRequestBody$outboundSchema
+    )),
+    expiry: z113.optional(z113.lazy(
+      () => UpdatePlanLicenseExpiryRequestBody$outboundSchema
+    )),
+    featureOverride: z113.optional(z113.lazy(
+      () => UpdatePlanLicenseFeatureOverrideRequestBody$outboundSchema
+    ))
   }),
   z113.transform((v) => {
     return remap(v, {
@@ -49273,29 +50488,23 @@ var UpdatePlanLicensePlanItem$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseRemoveItemBillingMethod$outboundSchema = z113.enum(
-  UpdatePlanLicenseRemoveItemBillingMethod
-);
-var UpdatePlanIntervalLicenseRemoveItemEnum2$outboundSchema = z113.enum(
-  UpdatePlanIntervalLicenseRemoveItemEnum2
-);
-var UpdatePlanIntervalLicenseRemoveItemEnum1$outboundSchema = z113.enum(
-  UpdatePlanIntervalLicenseRemoveItemEnum1
-);
-var UpdatePlanLicenseIntervalUnion$outboundSchema = smartUnion([
-  UpdatePlanIntervalLicenseRemoveItemEnum1$outboundSchema,
-  UpdatePlanIntervalLicenseRemoveItemEnum2$outboundSchema
+var UpdatePlanLicenseRemoveItemBillingMethodRequestBody$outboundSchema = z113.enum(UpdatePlanLicenseRemoveItemBillingMethodRequestBody);
+var UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum2$outboundSchema = z113.enum(UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum2);
+var UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum1$outboundSchema = z113.enum(UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum1);
+var UpdatePlanLicenseIntervalRequestBodyUnion$outboundSchema = smartUnion([
+  UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum1$outboundSchema,
+  UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum2$outboundSchema
 ]);
-var UpdatePlanLicensePlanItemFilter$outboundSchema = z113.pipe(
+var UpdatePlanLicensePlanItemFilterRequestBody$outboundSchema = z113.pipe(
   z113.object({
     featureId: z113.optional(z113.string()),
     billingMethod: z113.optional(
-      UpdatePlanLicenseRemoveItemBillingMethod$outboundSchema
+      UpdatePlanLicenseRemoveItemBillingMethodRequestBody$outboundSchema
     ),
     interval: z113.optional(
       smartUnion([
-        UpdatePlanIntervalLicenseRemoveItemEnum1$outboundSchema,
-        UpdatePlanIntervalLicenseRemoveItemEnum2$outboundSchema
+        UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum1$outboundSchema,
+        UpdatePlanIntervalLicenseRemoveItemRequestBodyEnum2$outboundSchema
       ])
     ),
     intervalCount: z113.optional(z113.int()),
@@ -49309,17 +50518,17 @@ var UpdatePlanLicensePlanItemFilter$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicenseCustomize$outboundSchema = z113.pipe(
+var UpdatePlanLicenseCustomizeRequestBody$outboundSchema = z113.pipe(
   z113.object({
-    price: z113.optional(
-      z113.nullable(z113.lazy(() => UpdatePlanLicenseBasePrice$outboundSchema))
-    ),
-    addItems: z113.optional(
-      z113.array(z113.lazy(() => UpdatePlanLicensePlanItem$outboundSchema))
-    ),
-    removeItems: z113.optional(
-      z113.array(z113.lazy(() => UpdatePlanLicensePlanItemFilter$outboundSchema))
-    )
+    price: z113.optional(z113.nullable(z113.lazy(
+      () => UpdatePlanLicenseBasePriceRequestBody$outboundSchema
+    ))),
+    addItems: z113.optional(z113.array(z113.lazy(
+      () => UpdatePlanLicensePlanItemRequestBody$outboundSchema
+    ))),
+    removeItems: z113.optional(z113.array(z113.lazy(
+      () => UpdatePlanLicensePlanItemFilterRequestBody$outboundSchema
+    )))
   }),
   z113.transform((v) => {
     return remap(v, {
@@ -49328,15 +50537,15 @@ var UpdatePlanLicenseCustomize$outboundSchema = z113.pipe(
     });
   })
 );
-var UpdatePlanLicense$outboundSchema = z113.pipe(
+var UpdatePlanLicenseRequest$outboundSchema = z113.pipe(
   z113.object({
     licensePlanId: z113.string(),
     versionSlug: z113.optional(z113.string()),
     included: z113.optional(z113.int()),
     prepaidOnly: z113.optional(z113.boolean()),
-    customize: z113.optional(
-      z113.nullable(z113.lazy(() => UpdatePlanLicenseCustomize$outboundSchema))
-    ),
+    customize: z113.optional(z113.nullable(z113.lazy(
+      () => UpdatePlanLicenseCustomizeRequestBody$outboundSchema
+    ))),
     metadata: z113.optional(z113.record(z113.string(), z113.any()))
   }),
   z113.transform((v) => {
@@ -51025,7 +52234,7 @@ var UpdatePlanParams$outboundSchema = z114.pipe(
       z114.nullable(UpdatePlanBasePriceRequestBody$outboundSchema)
     ),
     items: z114.optional(z114.array(UpdatePlanItemPlanItem$outboundSchema)),
-    licenses: z114.optional(z114.array(UpdatePlanLicense$outboundSchema)),
+    licenses: z114.optional(z114.array(UpdatePlanLicenseRequest$outboundSchema)),
     freeTrial: z114.optional(
       z114.nullable(UpdatePlanFreeTrialParamsRequestBody$outboundSchema)
     ),
@@ -51333,17 +52542,17 @@ var UpdatePlanVariantDetailsAddItemPriceInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var UpdatePlanAddItemBillingMethodResponse = {
+var UpdatePlanVariantDetailsAddItemBillingMethod = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
-var UpdatePlanOnIncreaseResponse = {
+var UpdatePlanVariantDetailsOnIncrease = {
   BillImmediately: "bill_immediately",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
   BillNextCycle: "bill_next_cycle"
 };
-var UpdatePlanOnDecreaseResponse = {
+var UpdatePlanVariantDetailsOnDecrease = {
   Prorate: "prorate",
   ProrateImmediately: "prorate_immediately",
   ProrateNextCycle: "prorate_next_cycle",
@@ -51369,7 +52578,7 @@ var UpdatePlanDimensionsToVariantDetailsEnum1 = {
 var UpdatePlanToVariantDetailsEnum = {
   Inf: "inf"
 };
-var UpdatePlanRemoveItemBillingMethodResponse = {
+var UpdatePlanVariantDetailsRemoveItemBillingMethod = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
@@ -51464,7 +52673,7 @@ var UpdatePlanVariantDetailsUpsertLicenseAddItemPriceInterval = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
-var UpdatePlanUpsertLicenseAddItemBillingMethodResponse = {
+var UpdatePlanVariantDetailsUpsertLicenseAddItemBillingMethod = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
@@ -51481,7 +52690,7 @@ var UpdatePlanUpsertLicenseOnDecreaseResponse = {
   None: "none",
   NoProrations: "no_prorations"
 };
-var UpdatePlanUpsertLicenseExpiryDurationTypeResponse = {
+var UpdatePlanVariantDetailsUpsertLicenseExpiryDurationType = {
   Month: "month",
   Forever: "forever"
 };
@@ -52068,7 +53277,7 @@ var UpdatePlanVariantDetailsAdditionalCurrency$inboundSchema = z115.object(
     amount: number2()
   }
 );
-var UpdatePlanBasePriceResponse$inboundSchema = z115.pipe(
+var UpdatePlanVariantDetailsBasePrice$inboundSchema = z115.pipe(
   z115.object({
     amount: number2(),
     interval: UpdatePlanPriceVariantDetailsInterval$inboundSchema,
@@ -52099,7 +53308,7 @@ var UpdatePlanVariantDetailsReset$inboundSchema = z115.pipe(
     });
   })
 );
-var UpdatePlanAddItemAdditionalCurrencyResponse$inboundSchema = z115.object({
+var UpdatePlanVariantDetailsAddItemAdditionalCurrency$inboundSchema = z115.object({
   currency: string5(),
   amount: number2()
 });
@@ -52134,12 +53343,12 @@ var UpdatePlanVariantDetailsPriceTier$inboundSchema = z115.pipe(
 );
 var UpdatePlanVariantDetailsTierBehavior$inboundSchema = inboundSchema(UpdatePlanVariantDetailsTierBehavior);
 var UpdatePlanVariantDetailsAddItemPriceInterval$inboundSchema = inboundSchema(UpdatePlanVariantDetailsAddItemPriceInterval);
-var UpdatePlanAddItemBillingMethodResponse$inboundSchema = inboundSchema(UpdatePlanAddItemBillingMethodResponse);
+var UpdatePlanVariantDetailsAddItemBillingMethod$inboundSchema = inboundSchema(UpdatePlanVariantDetailsAddItemBillingMethod);
 var UpdatePlanVariantDetailsPrice$inboundSchema = z115.pipe(
   z115.object({
     amount: optional3(number2()),
     additional_currencies: optional3(z115.array(z115.lazy(
-      () => UpdatePlanAddItemAdditionalCurrencyResponse$inboundSchema
+      () => UpdatePlanVariantDetailsAddItemAdditionalCurrency$inboundSchema
     ))),
     tiers: optional3(z115.array(z115.lazy(
       () => UpdatePlanVariantDetailsPriceTier$inboundSchema
@@ -52150,7 +53359,7 @@ var UpdatePlanVariantDetailsPrice$inboundSchema = z115.pipe(
     interval: UpdatePlanVariantDetailsAddItemPriceInterval$inboundSchema,
     interval_count: z115._default(number2(), 1),
     billing_units: z115._default(number2(), 1),
-    billing_method: UpdatePlanAddItemBillingMethodResponse$inboundSchema,
+    billing_method: UpdatePlanVariantDetailsAddItemBillingMethod$inboundSchema,
     max_purchase: z115.optional(z115.nullable(number2()))
   }),
   z115.transform((v) => {
@@ -52164,12 +53373,12 @@ var UpdatePlanVariantDetailsPrice$inboundSchema = z115.pipe(
     });
   })
 );
-var UpdatePlanOnIncreaseResponse$inboundSchema = inboundSchema(UpdatePlanOnIncreaseResponse);
-var UpdatePlanOnDecreaseResponse$inboundSchema = inboundSchema(UpdatePlanOnDecreaseResponse);
-var UpdatePlanProrationResponse$inboundSchema = z115.pipe(
+var UpdatePlanVariantDetailsOnIncrease$inboundSchema = inboundSchema(UpdatePlanVariantDetailsOnIncrease);
+var UpdatePlanVariantDetailsOnDecrease$inboundSchema = inboundSchema(UpdatePlanVariantDetailsOnDecrease);
+var UpdatePlanVariantDetailsProration$inboundSchema = z115.pipe(
   z115.object({
-    on_increase: UpdatePlanOnIncreaseResponse$inboundSchema,
-    on_decrease: UpdatePlanOnDecreaseResponse$inboundSchema
+    on_increase: UpdatePlanVariantDetailsOnIncrease$inboundSchema,
+    on_decrease: UpdatePlanVariantDetailsOnDecrease$inboundSchema
   }),
   z115.transform((v) => {
     return remap(v, {
@@ -52444,7 +53653,7 @@ var UpdatePlanVariantDetailsFeatureOverride$inboundSchema = z115.pipe(
     });
   })
 );
-var UpdatePlanPlanItemResponse$inboundSchema = z115.pipe(
+var UpdatePlanVariantDetailsPlanItem$inboundSchema = z115.pipe(
   z115.object({
     threshold_billing: z115.optional(z115.nullable(z115.lazy(
       () => UpdatePlanVariantDetailsThresholdBilling$inboundSchema
@@ -52460,7 +53669,7 @@ var UpdatePlanPlanItemResponse$inboundSchema = z115.pipe(
       () => UpdatePlanVariantDetailsPrice$inboundSchema
     )),
     proration: optional3(z115.lazy(
-      () => UpdatePlanProrationResponse$inboundSchema
+      () => UpdatePlanVariantDetailsProration$inboundSchema
     )),
     rollover: optional3(z115.lazy(
       () => UpdatePlanVariantDetailsRollover$inboundSchema
@@ -52480,18 +53689,18 @@ var UpdatePlanPlanItemResponse$inboundSchema = z115.pipe(
     });
   })
 );
-var UpdatePlanRemoveItemBillingMethodResponse$inboundSchema = inboundSchema(UpdatePlanRemoveItemBillingMethodResponse);
+var UpdatePlanVariantDetailsRemoveItemBillingMethod$inboundSchema = inboundSchema(UpdatePlanVariantDetailsRemoveItemBillingMethod);
 var UpdatePlanIntervalVariantDetailsRemoveItemEnum2$inboundSchema = inboundSchema(UpdatePlanIntervalVariantDetailsRemoveItemEnum2);
 var UpdatePlanIntervalVariantDetailsRemoveItemEnum1$inboundSchema = inboundSchema(UpdatePlanIntervalVariantDetailsRemoveItemEnum1);
 var UpdatePlanVariantDetailsIntervalUnion$inboundSchema = smartUnion([
   UpdatePlanIntervalVariantDetailsRemoveItemEnum1$inboundSchema,
   UpdatePlanIntervalVariantDetailsRemoveItemEnum2$inboundSchema
 ]);
-var UpdatePlanPlanItemFilterResponse$inboundSchema = z115.pipe(
+var UpdatePlanVariantDetailsPlanItemFilter$inboundSchema = z115.pipe(
   z115.object({
     feature_id: optional3(string5()),
     billing_method: optional3(
-      UpdatePlanRemoveItemBillingMethodResponse$inboundSchema
+      UpdatePlanVariantDetailsRemoveItemBillingMethod$inboundSchema
     ),
     interval: optional3(
       smartUnion([
@@ -52668,7 +53877,7 @@ var UpdatePlanVariantDetailsBillingControls$inboundSchema = z115.pipe(
   })
 );
 var UpdatePlanPriceVariantDetailsUpsertLicenseInterval$inboundSchema = inboundSchema(UpdatePlanPriceVariantDetailsUpsertLicenseInterval);
-var UpdatePlanUpsertLicenseAdditionalCurrencyResponse$inboundSchema = z115.object({
+var UpdatePlanVariantDetailsUpsertLicenseAdditionalCurrency$inboundSchema = z115.object({
   currency: string5(),
   amount: number2()
 });
@@ -52678,7 +53887,7 @@ var UpdatePlanUpsertLicenseBasePriceResponse$inboundSchema = z115.pipe(
     interval: UpdatePlanPriceVariantDetailsUpsertLicenseInterval$inboundSchema,
     interval_count: z115._default(number2(), 1),
     additional_currencies: optional3(z115.array(z115.lazy(
-      () => UpdatePlanUpsertLicenseAdditionalCurrencyResponse$inboundSchema
+      () => UpdatePlanVariantDetailsUpsertLicenseAdditionalCurrency$inboundSchema
     )))
   }),
   z115.transform((v) => {
@@ -52688,7 +53897,7 @@ var UpdatePlanUpsertLicenseBasePriceResponse$inboundSchema = z115.pipe(
     });
   })
 );
-var UpdatePlanUpsertLicenseThresholdBillingResponse$inboundSchema = z115.object({
+var UpdatePlanVariantDetailsUpsertLicenseThresholdBilling$inboundSchema = z115.object({
   threshold: number2()
 });
 var UpdatePlanVariantDetailsUpsertLicenseResetInterval$inboundSchema = inboundSchema(UpdatePlanVariantDetailsUpsertLicenseResetInterval);
@@ -52703,12 +53912,12 @@ var UpdatePlanVariantDetailsUpsertLicenseReset$inboundSchema = z115.pipe(
     });
   })
 );
-var UpdatePlanUpsertLicenseAddItemAdditionalCurrencyResponse$inboundSchema = z115.object({
+var UpdatePlanVariantDetailsUpsertLicenseAddItemAdditionalCurrency$inboundSchema = z115.object({
   currency: string5(),
   amount: number2()
 });
 var UpdatePlanVariantDetailsUpsertLicensePriceTo$inboundSchema = smartUnion([number2(), string5()]);
-var UpdatePlanUpsertLicenseTierAdditionalCurrencyResponse$inboundSchema = z115.pipe(
+var UpdatePlanVariantDetailsUpsertLicenseTierAdditionalCurrency$inboundSchema = z115.pipe(
   z115.object({
     currency: string5(),
     amount: optional3(number2()),
@@ -52726,7 +53935,7 @@ var UpdatePlanVariantDetailsUpsertLicensePriceTier$inboundSchema = z115.pipe(
     amount: number2(),
     flat_amount: optional3(number2()),
     additional_currencies: optional3(z115.array(z115.lazy(
-      () => UpdatePlanUpsertLicenseTierAdditionalCurrencyResponse$inboundSchema
+      () => UpdatePlanVariantDetailsUpsertLicenseTierAdditionalCurrency$inboundSchema
     )))
   }),
   z115.transform((v) => {
@@ -52740,14 +53949,14 @@ var UpdatePlanVariantDetailsUpsertLicenseTierBehavior$inboundSchema = inboundSch
 var UpdatePlanVariantDetailsUpsertLicenseAddItemPriceInterval$inboundSchema = inboundSchema(
   UpdatePlanVariantDetailsUpsertLicenseAddItemPriceInterval
 );
-var UpdatePlanUpsertLicenseAddItemBillingMethodResponse$inboundSchema = inboundSchema(
-  UpdatePlanUpsertLicenseAddItemBillingMethodResponse
+var UpdatePlanVariantDetailsUpsertLicenseAddItemBillingMethod$inboundSchema = inboundSchema(
+  UpdatePlanVariantDetailsUpsertLicenseAddItemBillingMethod
 );
 var UpdatePlanVariantDetailsUpsertLicensePrice$inboundSchema = z115.pipe(
   z115.object({
     amount: optional3(number2()),
     additional_currencies: optional3(z115.array(z115.lazy(
-      () => UpdatePlanUpsertLicenseAddItemAdditionalCurrencyResponse$inboundSchema
+      () => UpdatePlanVariantDetailsUpsertLicenseAddItemAdditionalCurrency$inboundSchema
     ))),
     tiers: optional3(z115.array(z115.lazy(
       () => UpdatePlanVariantDetailsUpsertLicensePriceTier$inboundSchema
@@ -52758,7 +53967,7 @@ var UpdatePlanVariantDetailsUpsertLicensePrice$inboundSchema = z115.pipe(
     interval: UpdatePlanVariantDetailsUpsertLicenseAddItemPriceInterval$inboundSchema,
     interval_count: z115._default(number2(), 1),
     billing_units: z115._default(number2(), 1),
-    billing_method: UpdatePlanUpsertLicenseAddItemBillingMethodResponse$inboundSchema,
+    billing_method: UpdatePlanVariantDetailsUpsertLicenseAddItemBillingMethod$inboundSchema,
     max_purchase: z115.optional(z115.nullable(number2()))
   }),
   z115.transform((v) => {
@@ -52786,12 +53995,14 @@ var UpdatePlanUpsertLicenseProrationResponse$inboundSchema = z115.pipe(
     });
   })
 );
-var UpdatePlanUpsertLicenseExpiryDurationTypeResponse$inboundSchema = inboundSchema(UpdatePlanUpsertLicenseExpiryDurationTypeResponse);
+var UpdatePlanVariantDetailsUpsertLicenseExpiryDurationType$inboundSchema = inboundSchema(
+  UpdatePlanVariantDetailsUpsertLicenseExpiryDurationType
+);
 var UpdatePlanVariantDetailsUpsertLicenseRollover$inboundSchema = z115.pipe(
   z115.object({
     max: optional3(number2()),
     max_percentage: optional3(number2()),
-    expiry_duration_type: UpdatePlanUpsertLicenseExpiryDurationTypeResponse$inboundSchema,
+    expiry_duration_type: UpdatePlanVariantDetailsUpsertLicenseExpiryDurationType$inboundSchema,
     expiry_duration_length: optional3(number2())
   }),
   z115.transform((v) => {
@@ -52831,7 +54042,7 @@ var UpdatePlanDimensionsToVariantDetailsUpsertLicenseEnum1 = {
 var UpdatePlanToVariantDetailsUpsertLicenseEnum = {
   Inf: "inf"
 };
-var UpdatePlanUpsertLicenseRemoveItemBillingMethodResponse = {
+var UpdatePlanVariantDetailsUpsertLicenseRemoveItemBillingMethod = {
   Prepaid: "prepaid",
   UsageBased: "usage_based"
 };
@@ -52854,6 +54065,96 @@ var UpdatePlanIntervalVariantDetailsUpsertLicenseRemoveItemEnum1 = {
   SemiAnnual: "semi_annual",
   Year: "year"
 };
+var UpdatePlanPriceLicenseIntervalResponse = {
+  OneOff: "one_off",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var UpdatePlanLicenseResetIntervalResponse = {
+  OneOff: "one_off",
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var UpdatePlanLicenseTierBehaviorResponse = {
+  Graduated: "graduated",
+  Volume: "volume"
+};
+var UpdatePlanLicenseAddItemPriceIntervalResponse = {
+  OneOff: "one_off",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var UpdatePlanLicenseAddItemBillingMethodResponse = {
+  Prepaid: "prepaid",
+  UsageBased: "usage_based"
+};
+var UpdatePlanLicenseOnIncreaseResponse = {
+  BillImmediately: "bill_immediately",
+  ProrateImmediately: "prorate_immediately",
+  ProrateNextCycle: "prorate_next_cycle",
+  BillNextCycle: "bill_next_cycle"
+};
+var UpdatePlanLicenseOnDecreaseResponse = {
+  Prorate: "prorate",
+  ProrateImmediately: "prorate_immediately",
+  ProrateNextCycle: "prorate_next_cycle",
+  None: "none",
+  NoProrations: "no_prorations"
+};
+var UpdatePlanLicenseExpiryDurationTypeResponse = {
+  Month: "month",
+  Forever: "forever"
+};
+var UpdatePlanLicenseDurationResponse = {
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Year: "year"
+};
+var UpdatePlanDimensionsToLicenseResponseEnum2 = {
+  Inf: "inf"
+};
+var UpdatePlanDimensionsToLicenseResponseEnum1 = {
+  Inf: "inf"
+};
+var UpdatePlanToLicenseResponseEnum = {
+  Inf: "inf"
+};
+var UpdatePlanLicenseRemoveItemBillingMethodResponse = {
+  Prepaid: "prepaid",
+  UsageBased: "usage_based"
+};
+var UpdatePlanIntervalLicenseRemoveItemResponseEnum2 = {
+  OneOff: "one_off",
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
+var UpdatePlanIntervalLicenseRemoveItemResponseEnum1 = {
+  OneOff: "one_off",
+  Week: "week",
+  Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
+  Year: "year"
+};
 var UpdatePlanDimensionsToVariantDetailsUpsertLicenseEnum2$inboundSchema = z116.enum(UpdatePlanDimensionsToVariantDetailsUpsertLicenseEnum2);
 var UpdatePlanDimensionsVariantDetailsUpsertLicenseToUnion2$inboundSchema = smartUnion([
   number2(),
@@ -53066,7 +54367,7 @@ var UpdatePlanVariantDetailsUpsertLicenseModelMarkups$inboundSchema = z116.pipe(
     });
   })
 );
-var UpdatePlanUpsertLicenseMarkupsResponse$inboundSchema = z116.pipe(
+var UpdatePlanVariantDetailsUpsertLicenseMarkups$inboundSchema = z116.pipe(
   z116.object({
     default_markup: optional3(number2()),
     provider_markups: z116.optional(z116.nullable(z116.record(
@@ -53090,7 +54391,7 @@ var UpdatePlanUpsertLicenseMarkupsResponse$inboundSchema = z116.pipe(
     });
   })
 );
-var UpdatePlanUpsertLicenseFeatureOverrideResponse$inboundSchema = z116.pipe(
+var UpdatePlanVariantDetailsUpsertLicenseFeatureOverride$inboundSchema = z116.pipe(
   z116.object({
     credit_schema: optional3(z116.array(smartUnion([
       z116.lazy(
@@ -53101,7 +54402,7 @@ var UpdatePlanUpsertLicenseFeatureOverrideResponse$inboundSchema = z116.pipe(
       )
     ]))),
     markups: optional3(z116.lazy(
-      () => UpdatePlanUpsertLicenseMarkupsResponse$inboundSchema
+      () => UpdatePlanVariantDetailsUpsertLicenseMarkups$inboundSchema
     ))
   }),
   z116.transform((v) => {
@@ -53114,7 +54415,7 @@ var UpdatePlanUpsertLicensePlanItemResponse$inboundSchema = z116.pipe(
   z116.object({
     threshold_billing: z116.optional(
       z116.nullable(
-        UpdatePlanUpsertLicenseThresholdBillingResponse$inboundSchema
+        UpdatePlanVariantDetailsUpsertLicenseThresholdBilling$inboundSchema
       )
     ),
     feature_id: string5(),
@@ -53136,11 +54437,9 @@ var UpdatePlanUpsertLicensePlanItemResponse$inboundSchema = z116.pipe(
     expiry: optional3(
       UpdatePlanVariantDetailsUpsertLicenseExpiry$inboundSchema
     ),
-    feature_override: optional3(
-      z116.lazy(
-        () => UpdatePlanUpsertLicenseFeatureOverrideResponse$inboundSchema
-      )
-    )
+    feature_override: optional3(z116.lazy(
+      () => UpdatePlanVariantDetailsUpsertLicenseFeatureOverride$inboundSchema
+    ))
   }),
   z116.transform((v) => {
     return remap(v, {
@@ -53150,8 +54449,8 @@ var UpdatePlanUpsertLicensePlanItemResponse$inboundSchema = z116.pipe(
     });
   })
 );
-var UpdatePlanUpsertLicenseRemoveItemBillingMethodResponse$inboundSchema = inboundSchema(
-  UpdatePlanUpsertLicenseRemoveItemBillingMethodResponse
+var UpdatePlanVariantDetailsUpsertLicenseRemoveItemBillingMethod$inboundSchema = inboundSchema(
+  UpdatePlanVariantDetailsUpsertLicenseRemoveItemBillingMethod
 );
 var UpdatePlanIntervalVariantDetailsUpsertLicenseRemoveItemEnum2$inboundSchema = inboundSchema(
   UpdatePlanIntervalVariantDetailsUpsertLicenseRemoveItemEnum2
@@ -53167,7 +54466,7 @@ var UpdatePlanUpsertLicensePlanItemFilterResponse$inboundSchema = z116.pipe(
   z116.object({
     feature_id: optional3(string5()),
     billing_method: optional3(
-      UpdatePlanUpsertLicenseRemoveItemBillingMethodResponse$inboundSchema
+      UpdatePlanVariantDetailsUpsertLicenseRemoveItemBillingMethod$inboundSchema
     ),
     interval: optional3(
       smartUnion([
@@ -53234,14 +54533,16 @@ var UpdatePlanRemoveLicenseResponse$inboundSchema = z116.pipe(
     });
   })
 );
-var UpdatePlanCustomizeResponse$inboundSchema = z116.pipe(
+var UpdatePlanVariantDetailsCustomize$inboundSchema = z116.pipe(
   z116.object({
-    price: z116.optional(z116.nullable(UpdatePlanBasePriceResponse$inboundSchema)),
+    price: z116.optional(
+      z116.nullable(UpdatePlanVariantDetailsBasePrice$inboundSchema)
+    ),
     add_items: optional3(
-      z116.array(UpdatePlanPlanItemResponse$inboundSchema)
+      z116.array(UpdatePlanVariantDetailsPlanItem$inboundSchema)
     ),
     remove_items: optional3(
-      z116.array(UpdatePlanPlanItemFilterResponse$inboundSchema)
+      z116.array(UpdatePlanVariantDetailsPlanItemFilter$inboundSchema)
     ),
     free_trial: z116.optional(
       z116.nullable(UpdatePlanFreeTrialParamsResponse$inboundSchema)
@@ -53271,7 +54572,7 @@ var UpdatePlanVariantDetails$inboundSchema = z116.pipe(
   z116.object({
     base_plan_id: string5(),
     customize: optional3(
-      z116.lazy(() => UpdatePlanCustomizeResponse$inboundSchema)
+      z116.lazy(() => UpdatePlanVariantDetailsCustomize$inboundSchema)
     )
   }),
   z116.transform((v) => {
@@ -53280,6 +54581,493 @@ var UpdatePlanVariantDetails$inboundSchema = z116.pipe(
     });
   })
 );
+var UpdatePlanPriceLicenseIntervalResponse$inboundSchema = inboundSchema(UpdatePlanPriceLicenseIntervalResponse);
+var UpdatePlanLicenseAdditionalCurrencyResponse$inboundSchema = z116.object({
+  currency: string5(),
+  amount: number2()
+});
+var UpdatePlanLicenseBasePriceResponse$inboundSchema = z116.pipe(
+  z116.object({
+    amount: number2(),
+    interval: UpdatePlanPriceLicenseIntervalResponse$inboundSchema,
+    interval_count: z116._default(number2(), 1),
+    additional_currencies: optional3(z116.array(z116.lazy(
+      () => UpdatePlanLicenseAdditionalCurrencyResponse$inboundSchema
+    )))
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount",
+      "additional_currencies": "additionalCurrencies"
+    });
+  })
+);
+var UpdatePlanLicenseThresholdBillingResponse$inboundSchema = z116.object({
+  threshold: number2()
+});
+var UpdatePlanLicenseResetIntervalResponse$inboundSchema = inboundSchema(UpdatePlanLicenseResetIntervalResponse);
+var UpdatePlanLicenseResetResponse$inboundSchema = z116.pipe(
+  z116.object({
+    interval: UpdatePlanLicenseResetIntervalResponse$inboundSchema,
+    interval_count: z116._default(number2(), 1)
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var UpdatePlanLicenseAddItemAdditionalCurrencyResponse$inboundSchema = z116.object({
+  currency: string5(),
+  amount: number2()
+});
+var UpdatePlanLicensePriceToResponse$inboundSchema = smartUnion([number2(), string5()]);
+var UpdatePlanLicenseTierAdditionalCurrencyResponse$inboundSchema = z116.pipe(
+  z116.object({
+    currency: string5(),
+    amount: optional3(number2()),
+    flat_amount: optional3(number2())
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "flat_amount": "flatAmount"
+    });
+  })
+);
+var UpdatePlanLicensePriceTierResponse$inboundSchema = z116.pipe(
+  z116.object({
+    to: smartUnion([number2(), string5()]),
+    amount: number2(),
+    flat_amount: optional3(number2()),
+    additional_currencies: optional3(z116.array(z116.lazy(
+      () => UpdatePlanLicenseTierAdditionalCurrencyResponse$inboundSchema
+    )))
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "flat_amount": "flatAmount",
+      "additional_currencies": "additionalCurrencies"
+    });
+  })
+);
+var UpdatePlanLicenseTierBehaviorResponse$inboundSchema = inboundSchema(UpdatePlanLicenseTierBehaviorResponse);
+var UpdatePlanLicenseAddItemPriceIntervalResponse$inboundSchema = inboundSchema(UpdatePlanLicenseAddItemPriceIntervalResponse);
+var UpdatePlanLicenseAddItemBillingMethodResponse$inboundSchema = inboundSchema(UpdatePlanLicenseAddItemBillingMethodResponse);
+var UpdatePlanLicensePriceResponse$inboundSchema = z116.pipe(
+  z116.object({
+    amount: optional3(number2()),
+    additional_currencies: optional3(z116.array(z116.lazy(
+      () => UpdatePlanLicenseAddItemAdditionalCurrencyResponse$inboundSchema
+    ))),
+    tiers: optional3(z116.array(z116.lazy(
+      () => UpdatePlanLicensePriceTierResponse$inboundSchema
+    ))),
+    tier_behavior: optional3(
+      UpdatePlanLicenseTierBehaviorResponse$inboundSchema
+    ),
+    interval: UpdatePlanLicenseAddItemPriceIntervalResponse$inboundSchema,
+    interval_count: z116._default(number2(), 1),
+    billing_units: z116._default(number2(), 1),
+    billing_method: UpdatePlanLicenseAddItemBillingMethodResponse$inboundSchema,
+    max_purchase: z116.optional(z116.nullable(number2()))
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "additional_currencies": "additionalCurrencies",
+      "tier_behavior": "tierBehavior",
+      "interval_count": "intervalCount",
+      "billing_units": "billingUnits",
+      "billing_method": "billingMethod",
+      "max_purchase": "maxPurchase"
+    });
+  })
+);
+var UpdatePlanLicenseOnIncreaseResponse$inboundSchema = inboundSchema(UpdatePlanLicenseOnIncreaseResponse);
+var UpdatePlanLicenseOnDecreaseResponse$inboundSchema = inboundSchema(UpdatePlanLicenseOnDecreaseResponse);
+var UpdatePlanLicenseProrationResponse$inboundSchema = z116.pipe(
+  z116.object({
+    on_increase: UpdatePlanLicenseOnIncreaseResponse$inboundSchema,
+    on_decrease: UpdatePlanLicenseOnDecreaseResponse$inboundSchema
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "on_increase": "onIncrease",
+      "on_decrease": "onDecrease"
+    });
+  })
+);
+var UpdatePlanLicenseExpiryDurationTypeResponse$inboundSchema = inboundSchema(UpdatePlanLicenseExpiryDurationTypeResponse);
+var UpdatePlanLicenseRolloverResponse$inboundSchema = z116.pipe(
+  z116.object({
+    max: optional3(number2()),
+    max_percentage: optional3(number2()),
+    expiry_duration_type: UpdatePlanLicenseExpiryDurationTypeResponse$inboundSchema,
+    expiry_duration_length: optional3(number2())
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "max_percentage": "maxPercentage",
+      "expiry_duration_type": "expiryDurationType",
+      "expiry_duration_length": "expiryDurationLength"
+    });
+  })
+);
+var UpdatePlanLicenseDurationResponse$inboundSchema = inboundSchema(UpdatePlanLicenseDurationResponse);
+var UpdatePlanLicenseExpiryResponse$inboundSchema = z116.object({
+  duration: UpdatePlanLicenseDurationResponse$inboundSchema,
+  length: number2()
+});
+var UpdatePlanDimensionsLicenseResponse4$inboundSchema = z116.pipe(
+  z116.object({
+    match: z116.record(z116.string(), string5()),
+    priority: optional3(number2()),
+    credit_cost: number2()
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var UpdatePlanDimensionsToLicenseResponseEnum2$inboundSchema = z116.enum(
+  UpdatePlanDimensionsToLicenseResponseEnum2
+);
+var UpdatePlanDimensionsLicenseToResponseUnion2$inboundSchema = smartUnion([
+  number2(),
+  UpdatePlanDimensionsToLicenseResponseEnum2$inboundSchema
+]);
+var UpdatePlanDimensionsLicenseTierResponse2$inboundSchema = z116.pipe(
+  z116.object({
+    to: smartUnion([
+      number2(),
+      UpdatePlanDimensionsToLicenseResponseEnum2$inboundSchema
+    ]),
+    credit_cost: number2()
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var UpdatePlanDimensionsLicenseResponse3$inboundSchema = z116.pipe(
+  z116.object({
+    match: z116.record(z116.string(), string5()),
+    priority: optional3(number2()),
+    tier_behavior: literal3("graduated"),
+    tiers: z116.array(
+      z116.lazy(() => UpdatePlanDimensionsLicenseTierResponse2$inboundSchema)
+    )
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "tier_behavior": "tierBehavior"
+    });
+  })
+);
+var UpdatePlanLicenseDimensionsResponseUnion2$inboundSchema = smartUnion([
+  z116.lazy(() => UpdatePlanDimensionsLicenseResponse3$inboundSchema),
+  z116.lazy(() => UpdatePlanDimensionsLicenseResponse4$inboundSchema)
+]);
+var UpdatePlanLicenseMultipliersResponse2$inboundSchema = z116.object({
+  match: z116.record(z116.string(), string5()),
+  factor: optional3(number2()),
+  add: optional3(number2())
+});
+var UpdatePlanCreditSchemaLicenseResponse2$inboundSchema = z116.pipe(
+  z116.object({
+    metered_feature_id: string5(),
+    billing_units: optional3(number2()),
+    dimensions: optional3(z116.record(
+      z116.string(),
+      smartUnion([
+        z116.lazy(() => UpdatePlanDimensionsLicenseResponse3$inboundSchema),
+        z116.lazy(() => UpdatePlanDimensionsLicenseResponse4$inboundSchema)
+      ])
+    )),
+    multipliers: optional3(z116.record(
+      z116.string(),
+      z116.lazy(() => UpdatePlanLicenseMultipliersResponse2$inboundSchema)
+    )),
+    credit_cost: number2()
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "metered_feature_id": "meteredFeatureId",
+      "billing_units": "billingUnits",
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var UpdatePlanDimensionsLicenseResponse2$inboundSchema = z116.pipe(
+  z116.object({
+    match: z116.record(z116.string(), string5()),
+    priority: optional3(number2()),
+    credit_cost: number2()
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var UpdatePlanDimensionsToLicenseResponseEnum1$inboundSchema = z116.enum(
+  UpdatePlanDimensionsToLicenseResponseEnum1
+);
+var UpdatePlanDimensionsLicenseToResponseUnion1$inboundSchema = smartUnion([
+  number2(),
+  UpdatePlanDimensionsToLicenseResponseEnum1$inboundSchema
+]);
+var UpdatePlanDimensionsLicenseTierResponse1$inboundSchema = z116.pipe(
+  z116.object({
+    to: smartUnion([
+      number2(),
+      UpdatePlanDimensionsToLicenseResponseEnum1$inboundSchema
+    ]),
+    credit_cost: number2()
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var UpdatePlanDimensionsLicenseResponse1$inboundSchema = z116.pipe(
+  z116.object({
+    match: z116.record(z116.string(), string5()),
+    priority: optional3(number2()),
+    tier_behavior: literal3("graduated"),
+    tiers: z116.array(
+      z116.lazy(() => UpdatePlanDimensionsLicenseTierResponse1$inboundSchema)
+    )
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "tier_behavior": "tierBehavior"
+    });
+  })
+);
+var UpdatePlanLicenseDimensionsResponseUnion1$inboundSchema = smartUnion([
+  z116.lazy(() => UpdatePlanDimensionsLicenseResponse1$inboundSchema),
+  z116.lazy(() => UpdatePlanDimensionsLicenseResponse2$inboundSchema)
+]);
+var UpdatePlanLicenseMultipliersResponse1$inboundSchema = z116.object({
+  match: z116.record(z116.string(), string5()),
+  factor: optional3(number2()),
+  add: optional3(number2())
+});
+var UpdatePlanToLicenseResponseEnum$inboundSchema = z116.enum(UpdatePlanToLicenseResponseEnum);
+var UpdatePlanLicenseFeatureOverrideToResponseUnion$inboundSchema = smartUnion([number2(), UpdatePlanToLicenseResponseEnum$inboundSchema]);
+var UpdatePlanLicenseFeatureOverrideTierResponse$inboundSchema = z116.pipe(
+  z116.object({
+    to: smartUnion([
+      number2(),
+      UpdatePlanToLicenseResponseEnum$inboundSchema
+    ]),
+    credit_cost: number2()
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "credit_cost": "creditCost"
+    });
+  })
+);
+var UpdatePlanCreditSchemaLicenseResponse1$inboundSchema = z116.pipe(
+  z116.object({
+    metered_feature_id: string5(),
+    billing_units: optional3(number2()),
+    dimensions: optional3(z116.record(
+      z116.string(),
+      smartUnion([
+        z116.lazy(() => UpdatePlanDimensionsLicenseResponse1$inboundSchema),
+        z116.lazy(() => UpdatePlanDimensionsLicenseResponse2$inboundSchema)
+      ])
+    )),
+    multipliers: optional3(z116.record(
+      z116.string(),
+      z116.lazy(() => UpdatePlanLicenseMultipliersResponse1$inboundSchema)
+    )),
+    tier_behavior: literal3("graduated"),
+    tiers: z116.array(z116.lazy(
+      () => UpdatePlanLicenseFeatureOverrideTierResponse$inboundSchema
+    ))
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "metered_feature_id": "meteredFeatureId",
+      "billing_units": "billingUnits",
+      "tier_behavior": "tierBehavior"
+    });
+  })
+);
+var UpdatePlanLicenseCreditSchemaResponseUnion$inboundSchema = smartUnion([
+  z116.lazy(() => UpdatePlanCreditSchemaLicenseResponse1$inboundSchema),
+  z116.lazy(() => UpdatePlanCreditSchemaLicenseResponse2$inboundSchema)
+]);
+var UpdatePlanLicenseProviderMarkupsResponse$inboundSchema = z116.object({
+  markup: number2()
+});
+var UpdatePlanLicenseModelMarkupsResponse$inboundSchema = z116.pipe(
+  z116.object({
+    markup: optional3(number2()),
+    input_cost: optional3(number2()),
+    output_cost: optional3(number2())
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "input_cost": "inputCost",
+      "output_cost": "outputCost"
+    });
+  })
+);
+var UpdatePlanLicenseMarkupsResponse$inboundSchema = z116.pipe(
+  z116.object({
+    default_markup: optional3(number2()),
+    provider_markups: z116.optional(z116.nullable(z116.record(
+      z116.string(),
+      z116.lazy(() => UpdatePlanLicenseProviderMarkupsResponse$inboundSchema)
+    ))),
+    model_markups: z116.optional(z116.nullable(z116.record(
+      z116.string(),
+      z116.lazy(() => UpdatePlanLicenseModelMarkupsResponse$inboundSchema)
+    )))
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "default_markup": "defaultMarkup",
+      "provider_markups": "providerMarkups",
+      "model_markups": "modelMarkups"
+    });
+  })
+);
+var UpdatePlanLicenseFeatureOverrideResponse$inboundSchema = z116.pipe(
+  z116.object({
+    credit_schema: optional3(z116.array(smartUnion([
+      z116.lazy(() => UpdatePlanCreditSchemaLicenseResponse1$inboundSchema),
+      z116.lazy(
+        () => UpdatePlanCreditSchemaLicenseResponse2$inboundSchema
+      )
+    ]))),
+    markups: optional3(z116.lazy(
+      () => UpdatePlanLicenseMarkupsResponse$inboundSchema
+    ))
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "credit_schema": "creditSchema"
+    });
+  })
+);
+var UpdatePlanLicensePlanItemResponse$inboundSchema = z116.pipe(
+  z116.object({
+    threshold_billing: z116.optional(z116.nullable(z116.lazy(
+      () => UpdatePlanLicenseThresholdBillingResponse$inboundSchema
+    ))),
+    feature_id: string5(),
+    included: optional3(number2()),
+    unlimited: optional3(boolean2()),
+    pooled: z116._default(boolean2(), false),
+    reset: optional3(z116.lazy(
+      () => UpdatePlanLicenseResetResponse$inboundSchema
+    )),
+    price: optional3(z116.lazy(
+      () => UpdatePlanLicensePriceResponse$inboundSchema
+    )),
+    proration: optional3(z116.lazy(
+      () => UpdatePlanLicenseProrationResponse$inboundSchema
+    )),
+    rollover: optional3(z116.lazy(
+      () => UpdatePlanLicenseRolloverResponse$inboundSchema
+    )),
+    expiry: optional3(z116.lazy(
+      () => UpdatePlanLicenseExpiryResponse$inboundSchema
+    )),
+    feature_override: optional3(z116.lazy(
+      () => UpdatePlanLicenseFeatureOverrideResponse$inboundSchema
+    ))
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "threshold_billing": "thresholdBilling",
+      "feature_id": "featureId",
+      "feature_override": "featureOverride"
+    });
+  })
+);
+var UpdatePlanLicenseRemoveItemBillingMethodResponse$inboundSchema = inboundSchema(UpdatePlanLicenseRemoveItemBillingMethodResponse);
+var UpdatePlanIntervalLicenseRemoveItemResponseEnum2$inboundSchema = inboundSchema(UpdatePlanIntervalLicenseRemoveItemResponseEnum2);
+var UpdatePlanIntervalLicenseRemoveItemResponseEnum1$inboundSchema = inboundSchema(UpdatePlanIntervalLicenseRemoveItemResponseEnum1);
+var UpdatePlanLicenseIntervalResponseUnion$inboundSchema = smartUnion([
+  UpdatePlanIntervalLicenseRemoveItemResponseEnum1$inboundSchema,
+  UpdatePlanIntervalLicenseRemoveItemResponseEnum2$inboundSchema
+]);
+var UpdatePlanLicensePlanItemFilterResponse$inboundSchema = z116.pipe(
+  z116.object({
+    feature_id: optional3(string5()),
+    billing_method: optional3(
+      UpdatePlanLicenseRemoveItemBillingMethodResponse$inboundSchema
+    ),
+    interval: optional3(
+      smartUnion([
+        UpdatePlanIntervalLicenseRemoveItemResponseEnum1$inboundSchema,
+        UpdatePlanIntervalLicenseRemoveItemResponseEnum2$inboundSchema
+      ])
+    ),
+    interval_count: optional3(number2()),
+    included: optional3(number2())
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "feature_id": "featureId",
+      "billing_method": "billingMethod",
+      "interval_count": "intervalCount"
+    });
+  })
+);
+var UpdatePlanLicenseCustomizeResponse$inboundSchema = z116.pipe(
+  z116.object({
+    price: z116.optional(
+      z116.nullable(
+        z116.lazy(() => UpdatePlanLicenseBasePriceResponse$inboundSchema)
+      )
+    ),
+    add_items: optional3(
+      z116.array(z116.lazy(() => UpdatePlanLicensePlanItemResponse$inboundSchema))
+    ),
+    remove_items: optional3(
+      z116.array(
+        z116.lazy(() => UpdatePlanLicensePlanItemFilterResponse$inboundSchema)
+      )
+    )
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "add_items": "addItems",
+      "remove_items": "removeItems"
+    });
+  })
+);
+var UpdatePlanLicenseResponse$inboundSchema = z116.pipe(
+  z116.object({
+    license_plan_id: string5(),
+    version: number2(),
+    version_slug: optional3(string5()),
+    included: number2(),
+    prepaid_only: boolean2(),
+    customize: optional3(
+      z116.lazy(() => UpdatePlanLicenseCustomizeResponse$inboundSchema)
+    ),
+    metadata: optional3(z116.record(z116.string(), z116.any())),
+    plan: optional3(Plan$inboundSchema)
+  }),
+  z116.transform((v) => {
+    return remap(v, {
+      "license_plan_id": "licensePlanId",
+      "version_slug": "versionSlug",
+      "prepaid_only": "prepaidOnly"
+    });
+  })
+);
 var UpdatePlanResponse$inboundSchema = z116.pipe(
   z116.object({
     id: string5(),
@@ -53309,6 +55097,9 @@ var UpdatePlanResponse$inboundSchema = z116.pipe(
     base_variant_id: nullable(string5()),
     variant_details: optional3(
       z116.lazy(() => UpdatePlanVariantDetails$inboundSchema)
+    ),
+    licenses: optional3(
+      z116.array(z116.lazy(() => UpdatePlanLicenseResponse$inboundSchema))
     )
   }),
   z116.transform((v) => {
@@ -54463,7 +56254,10 @@ var APIPromise = class {
   [Symbol.toStringTag] = "APIPromise";
   constructor(p) {
     this.#promise = p instanceof Promise ? p : Promise.resolve(p);
-    this.#unwrapped = p instanceof Promise ? this.#promise.then(([value]) => value) : Promise.resolve(p[0]);
+    this.#unwrapped = p instanceof Promise ? null : Promise.resolve(p[0]);
+  }
+  #getUnwrapped() {
+    return this.#unwrapped ??= this.#promise.then(([value]) => value);
   }
   then(onfulfilled, onrejected) {
     return this.#promise.then(
@@ -54472,10 +56266,10 @@ var APIPromise = class {
     );
   }
   catch(onrejected) {
-    return this.#unwrapped.catch(onrejected);
+    return this.#getUnwrapped().catch(onrejected);
   }
   finally(onfinally) {
-    return this.#unwrapped.finally(onfinally);
+    return this.#getUnwrapped().finally(onfinally);
   }
   $inspect() {
     return this.#promise;