autumn-js 1.2.53 → 1.2.55

package/dist/react/{plan-DEGPMYmh.d.ts → plan-C96AilzT.d.ts}

@@ -19,16 +19,57 @@ declare const BalanceType: {
  * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
  */
 type BalanceType = OpenEnum<typeof BalanceType>;
-type BalanceCreditSchema = {
+type BalanceCreditSchema3 = {
+    meteredFeatureId: "";
+    /**
+     * Number of metered-feature units priced together. Defaults to one when omitted.
+     */
+    billingUnits?: number | undefined;
+    /**
+     * Credits consumed per billing-unit group.
+     */
+    creditCost: number;
+};
+type BalanceCreditSchema2 = {
     /**
      * ID of the metered feature that draws from this credit system.
      */
     meteredFeatureId: string;
     /**
-     * Credits consumed per unit of the metered feature.
+     * Number of metered-feature units priced together. Defaults to one when omitted.
+     */
+    billingUnits?: number | undefined;
+    /**
+     * Credits consumed per billing-unit group.
      */
     creditCost: number;
 };
+declare const BalanceToEnum: {
+    readonly Inf: "inf";
+};
+type BalanceToEnum = ClosedEnum<typeof BalanceToEnum>;
+type BalanceFeatureTier = {
+    /**
+     * Inclusive upper usage boundary for this graduated tier. The final tier must be 'inf'.
+     */
+    to: number | BalanceToEnum;
+    /**
+     * Credits consumed per billing-unit group within this tier.
+     */
+    creditCost: number;
+};
+type BalanceCreditSchema1 = {
+    /**
+     * ID of the metered feature that draws from this credit system.
+     */
+    meteredFeatureId: string;
+    /**
+     * Number of metered-feature units priced together. Defaults to one when omitted.
+     */
+    billingUnits?: number | undefined;
+    tierBehavior: "graduated";
+    tiers: Array<BalanceFeatureTier>;
+};
 type BalanceModelMarkups = {
     markup?: number | undefined;
     inputCost?: number | undefined;
@@ -50,6 +91,22 @@ type BalanceDisplay = {
      */
     plural?: string | null | undefined;
 };
+type BalanceStripe = {
+    /**
+     * Stripe product ID this feature's usage prices bill under.
+     */
+    productId?: string | undefined;
+    /**
+     * Stripe meter ID used to create this feature's metered price.
+     */
+    meterId?: string | undefined;
+};
+/**
+ * Processor mappings for this feature. Present when a Stripe product or meter is set.
+ */
+type BalanceProcessors = {
+    stripe?: BalanceStripe | undefined;
+};
 /**
  * The full feature object if expanded.
  */
@@ -75,9 +132,13 @@ type BalanceFeature = {
      */
     eventNames?: Array<string> | undefined;
     /**
-     * For credit_system features: maps metered features to their credit costs.
+     * For classic credit systems: maps metered features to flat or graduated credit costs.
+     */
+    creditSchema?: Array<BalanceCreditSchema1 | BalanceCreditSchema2 | BalanceCreditSchema3> | undefined;
+    /**
+     * Whether usage of this classic credit system should be itemized as invoice credits.
      */
-    creditSchema?: Array<BalanceCreditSchema> | undefined;
+    invoiceCredit?: boolean | undefined;
     /**
      * Per-model markup overrides for AI credit systems.
      */
@@ -102,6 +163,10 @@ type BalanceFeature = {
      * Whether the feature is archived and hidden from the dashboard.
      */
     archived: boolean;
+    /**
+     * Processor mappings for this feature. Present when a Stripe product or meter is set.
+     */
+    processors?: BalanceProcessors | undefined;
 };
 declare const BalanceIntervalEnum: {
     readonly OneOff: "one_off";
@@ -129,7 +194,7 @@ type BalanceReset = {
      */
     resetsAt: number | null;
 };
-type BalanceTier = {
+type BreakdownTier = {
     to: number | string;
     amount: number;
     flatAmount?: number | undefined;
@@ -164,7 +229,7 @@ type BalancePrice = {
     /**
      * Tiered pricing configuration if applicable.
      */
-    tiers?: Array<BalanceTier> | undefined;
+    tiers?: Array<BreakdownTier> | undefined;
     /**
      * How tiers are applied: graduated (split across bands) or volume (flat rate for the matched tier).
      */
@@ -325,7 +390,7 @@ type PlanPriceDisplay = {
 };
 type PlanPrice = {
     /**
-     * Base price amount for the plan.
+     * Base price amount for the plan, in major currency units (e.g. dollars).
      */
     amount: number;
     /**
@@ -666,206 +731,479 @@ declare const PlanEnv: {
  */
 type PlanEnv = OpenEnum<typeof PlanEnv>;
 /**
- * Billing interval (e.g. 'month', 'year').
+ * Miscellaneous plan-level configuration flags.
  */
-declare const PlanPriceVariantDetailsInterval: {
-    readonly OneOff: "one_off";
+type PlanConfig1 = {
+    /**
+     * If true, entitlements attached to this plan will still reset on schedule even when the customer's product is in a past_due state.
+     */
+    ignorePastDue: boolean;
+};
+/**
+ * The time interval for the purchase limit window.
+ */
+declare const PlanPurchaseLimitInterval: {
+    readonly Hour: "hour";
+    readonly Day: "day";
     readonly Week: "week";
     readonly Month: "month";
-    readonly Quarter: "quarter";
-    readonly SemiAnnual: "semi_annual";
-    readonly Year: "year";
 };
 /**
- * Billing interval (e.g. 'month', 'year').
+ * The time interval for the purchase limit window.
  */
-type PlanPriceVariantDetailsInterval = OpenEnum<typeof PlanPriceVariantDetailsInterval>;
-type VariantDetailsAdditionalCurrency = {
+type PlanPurchaseLimitInterval = OpenEnum<typeof PlanPurchaseLimitInterval>;
+/**
+ * Optional rate limit to cap how often auto top-ups occur.
+ */
+type PlanPurchaseLimit = {
     /**
-     * Three-letter Stripe-supported currency code (e.g. 'eur', 'gbp').
+     * The time interval for the purchase limit window.
      */
-    currency: string;
+    interval: PlanPurchaseLimitInterval;
     /**
-     * Price amount in this currency. Set explicitly per currency, not converted from the base amount.
+     * Number of intervals in the purchase limit window.
      */
-    amount: number;
+    intervalCount: number;
+    /**
+     * Maximum number of auto top-ups allowed within the interval.
+     */
+    limit: number;
 };
-/**
- * Base price configuration for a plan.
- */
-type BasePrice = {
+type PlanAutoTopup = {
     /**
-     * Base price amount for the plan.
+     * The ID of the feature (credit balance) to auto top-up.
      */
-    amount: number;
+    featureId: string;
     /**
-     * Billing interval (e.g. 'month', 'year').
+     * Whether auto top-up is enabled.
      */
-    interval: PlanPriceVariantDetailsInterval;
+    enabled: boolean;
     /**
-     * Number of intervals per billing cycle. Defaults to 1.
+     * When the balance drops below this threshold, an auto top-up will be purchased.
      */
-    intervalCount?: number | undefined;
+    threshold: number;
     /**
-     * Base price amounts in additional currencies. The base 'amount' is in the org's default currency.
+     * Amount of credits to add per auto top-up.
      */
-    additionalCurrencies?: Array<VariantDetailsAdditionalCurrency> | undefined;
+    quantity: number;
+    /**
+     * Optional rate limit to cap how often auto top-ups occur.
+     */
+    purchaseLimit?: PlanPurchaseLimit | undefined;
+    /**
+     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
+     */
+    invoiceMode?: boolean | undefined;
 };
 /**
- * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
+ * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
  */
-declare const PlanAddItemResetInterval: {
-    readonly OneOff: "one_off";
-    readonly Minute: "minute";
-    readonly Hour: "hour";
-    readonly Day: "day";
-    readonly Week: "week";
-    readonly Month: "month";
-    readonly Quarter: "quarter";
-    readonly SemiAnnual: "semi_annual";
-    readonly Year: "year";
+declare const PlanLimitType: {
+    readonly Absolute: "absolute";
+    readonly UsagePercentage: "usage_percentage";
 };
 /**
- * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
- */
-type PlanAddItemResetInterval = OpenEnum<typeof PlanAddItemResetInterval>;
-/**
- * Reset configuration for consumable features. Omit for non-consumable features like seats.
+ * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
  */
-type PlanVariantDetailsReset = {
-    /**
-     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
-     */
-    interval: PlanAddItemResetInterval;
-    /**
-     * Number of intervals between resets. Defaults to 1.
-     */
-    intervalCount?: number | undefined;
-};
-type AddItemAdditionalCurrency = {
+type PlanLimitType = OpenEnum<typeof PlanLimitType>;
+type PlanSpendLimit = {
     /**
-     * Three-letter Stripe-supported currency code (e.g. 'eur', 'gbp').
+     * Optional feature ID this spend limit applies to.
      */
-    currency: string;
+    featureId?: string | undefined;
     /**
-     * Price amount in this currency. Set explicitly per currency, not converted from the base amount.
+     * Whether the overage spend limit is enabled.
      */
-    amount: number;
-};
-type VariantDetailsTierAdditionalCurrency = {
+    enabled: boolean;
     /**
-     * Three-letter Stripe-supported currency code (e.g. 'eur', 'gbp').
+     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
      */
-    currency: string;
+    limitType?: PlanLimitType | undefined;
     /**
-     * Per-unit amount for this tier in this currency.
+     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
      */
-    amount?: number | undefined;
+    overageLimit?: number | undefined;
     /**
-     * Flat amount for this tier in this currency, if the tier uses one.
+     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
      */
-    flatAmount?: number | undefined;
-};
-type PlanVariantDetailsTier = {
-    to: number | string;
-    amount: number;
-    flatAmount?: number | undefined;
-    additionalCurrencies?: Array<VariantDetailsTierAdditionalCurrency> | undefined;
-};
-declare const PlanVariantDetailsTierBehavior: {
-    readonly Graduated: "graduated";
-    readonly Volume: "volume";
+    skipOverageBilling?: boolean | undefined;
 };
-type PlanVariantDetailsTierBehavior = OpenEnum<typeof PlanVariantDetailsTierBehavior>;
 /**
- * Billing interval. For consumable features, should match reset.interval.
+ * Interval for the cap, aligned to the customer's billing cycle.
  */
-declare const PlanAddItemPriceInterval: {
-    readonly OneOff: "one_off";
+declare const PlanUsageLimitInterval: {
+    readonly Day: "day";
     readonly Week: "week";
     readonly Month: "month";
-    readonly Quarter: "quarter";
-    readonly SemiAnnual: "semi_annual";
     readonly Year: "year";
 };
 /**
- * Billing interval. For consumable features, should match reset.interval.
+ * Interval for the cap, aligned to the customer's billing cycle.
  */
-type PlanAddItemPriceInterval = OpenEnum<typeof PlanAddItemPriceInterval>;
+type PlanUsageLimitInterval = OpenEnum<typeof PlanUsageLimitInterval>;
 /**
- * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
+ * Window alignment. 'billing_cycle' phases the interval to the customer's renewal time; 'utc' aligns to the UTC calendar.
  */
-declare const PlanAddItemBillingMethod: {
-    readonly Prepaid: "prepaid";
-    readonly UsageBased: "usage_based";
+declare const PlanAnchor: {
+    readonly BillingCycle: "billing_cycle";
+    readonly Utc: "utc";
 };
 /**
- * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
+ * Window alignment. 'billing_cycle' phases the interval to the customer's renewal time; 'utc' aligns to the UTC calendar.
  */
-type PlanAddItemBillingMethod = OpenEnum<typeof PlanAddItemBillingMethod>;
+type PlanAnchor = OpenEnum<typeof PlanAnchor>;
 /**
- * Pricing for usage beyond included units. Omit for free features.
+ * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
  */
-type PlanVariantDetailsPrice = {
-    /**
-     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
-     */
-    amount?: number | undefined;
-    /**
-     * Amounts in additional currencies for this flat price. The base 'amount' is in the org's default currency. Only valid with 'amount', not 'tiers'.
-     */
-    additionalCurrencies?: Array<AddItemAdditionalCurrency> | undefined;
+type PlanFilter = {
+    properties: {
+        [k: string]: string;
+    };
+};
+type PlanUsageLimit = {
     /**
-     * Tiered pricing.  Either 'amount' or 'tiers' is required.
+     * The feature this usage limit applies to.
      */
-    tiers?: Array<PlanVariantDetailsTier> | undefined;
-    tierBehavior?: PlanVariantDetailsTierBehavior | undefined;
+    featureId: string;
     /**
-     * Billing interval. For consumable features, should match reset.interval.
+     * Whether this usage limit is enabled.
      */
-    interval: PlanAddItemPriceInterval;
+    enabled: boolean;
     /**
-     * Number of intervals per billing cycle. Defaults to 1.
+     * Maximum units allowed per interval.
      */
-    intervalCount: number;
+    limit: number;
     /**
-     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
+     * Interval for the cap, aligned to the customer's billing cycle.
      */
-    billingUnits: number;
+    interval: PlanUsageLimitInterval;
     /**
-     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
+     * Window alignment. 'billing_cycle' phases the interval to the customer's renewal time; 'utc' aligns to the UTC calendar.
      */
-    billingMethod: PlanAddItemBillingMethod;
+    anchor?: PlanAnchor | undefined;
     /**
-     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
+     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
      */
-    maxPurchase?: number | null | undefined;
-};
-/**
- * Billing behavior when quantity increases mid-cycle.
- */
-declare const OnIncrease: {
-    readonly BillImmediately: "bill_immediately";
-    readonly ProrateImmediately: "prorate_immediately";
-    readonly ProrateNextCycle: "prorate_next_cycle";
-    readonly BillNextCycle: "bill_next_cycle";
+    filter?: PlanFilter | undefined;
 };
 /**
- * Billing behavior when quantity increases mid-cycle.
- */
-type OnIncrease = OpenEnum<typeof OnIncrease>;
-/**
- * Credit behavior when quantity decreases mid-cycle.
+ * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
  */
-declare const OnDecrease: {
-    readonly Prorate: "prorate";
-    readonly ProrateImmediately: "prorate_immediately";
-    readonly ProrateNextCycle: "prorate_next_cycle";
-    readonly None: "none";
-    readonly NoProrations: "no_prorations";
+declare const PlanThresholdType: {
+    readonly Usage: "usage";
+    readonly UsagePercentage: "usage_percentage";
+    readonly Remaining: "remaining";
+    readonly RemainingPercentage: "remaining_percentage";
 };
 /**
- * Credit behavior when quantity decreases mid-cycle.
+ * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
+ */
+type PlanThresholdType = OpenEnum<typeof PlanThresholdType>;
+type PlanUsageAlert = {
+    /**
+     * The feature ID this alert applies to.
+     */
+    featureId?: string | undefined;
+    /**
+     * Whether this usage alert is enabled.
+     */
+    enabled: boolean;
+    /**
+     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
+     */
+    threshold: number;
+    /**
+     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
+     */
+    thresholdType: PlanThresholdType;
+    /**
+     * Optional user-defined label to distinguish multiple alerts on the same feature.
+     */
+    name?: string | undefined;
+};
+type PlanOverageAllowed = {
+    /**
+     * The feature ID this overage allowed control applies to.
+     */
+    featureId: string;
+    /**
+     * Whether overage is allowed for this feature.
+     */
+    enabled: boolean;
+};
+/**
+ * Plan-level billing controls used as customer defaults.
+ */
+type PlanBillingControls = {
+    /**
+     * List of auto top-up configurations per feature.
+     */
+    autoTopups?: Array<PlanAutoTopup> | undefined;
+    /**
+     * List of overage spend limits per feature (caps overage spend).
+     */
+    spendLimits?: Array<PlanSpendLimit> | undefined;
+    /**
+     * List of hard usage caps per feature (max units per interval).
+     */
+    usageLimits?: Array<PlanUsageLimit> | undefined;
+    /**
+     * List of usage alert configurations per feature.
+     */
+    usageAlerts?: Array<PlanUsageAlert> | undefined;
+    /**
+     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
+     */
+    overageAllowed?: Array<PlanOverageAllowed> | undefined;
+};
+/**
+ * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
+ */
+declare const PlanStatus: {
+    readonly Active: "active";
+    readonly Scheduled: "scheduled";
+};
+/**
+ * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
+ */
+type PlanStatus = OpenEnum<typeof PlanStatus>;
+/**
+ * The action that would occur if this plan were attached to the customer.
+ */
+declare const AttachAction: {
+    readonly Activate: "activate";
+    readonly Upgrade: "upgrade";
+    readonly Downgrade: "downgrade";
+    readonly None: "none";
+    readonly Purchase: "purchase";
+};
+/**
+ * The action that would occur if this plan were attached to the customer.
+ */
+type AttachAction = OpenEnum<typeof AttachAction>;
+type CustomerEligibility = {
+    /**
+     * Whether the trial on this plan is available to this customer. For example, if the customer used the trial in the past, this will be false.
+     */
+    trialAvailable?: boolean | undefined;
+    /**
+     * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
+     */
+    status?: PlanStatus | undefined;
+    /**
+     * Whether the customer's active instance of this plan is set to cancel.
+     */
+    canceling?: boolean | undefined;
+    /**
+     * Whether the customer is currently on a free trial of this plan.
+     */
+    trialing?: boolean | undefined;
+    /**
+     * The action that would occur if this plan were attached to the customer.
+     */
+    attachAction: AttachAction;
+};
+/**
+ * Billing interval (e.g. 'month', 'year').
+ */
+declare const PlanPriceVariantDetailsInterval: {
+    readonly OneOff: "one_off";
+    readonly Week: "week";
+    readonly Month: "month";
+    readonly Quarter: "quarter";
+    readonly SemiAnnual: "semi_annual";
+    readonly Year: "year";
+};
+/**
+ * Billing interval (e.g. 'month', 'year').
+ */
+type PlanPriceVariantDetailsInterval = OpenEnum<typeof PlanPriceVariantDetailsInterval>;
+type VariantDetailsAdditionalCurrency = {
+    /**
+     * Three-letter Stripe-supported currency code (e.g. 'eur', 'gbp').
+     */
+    currency: string;
+    /**
+     * Price amount in this currency. Set explicitly per currency, not converted from the base amount.
+     */
+    amount: number;
+};
+/**
+ * Base price configuration for a plan.
+ */
+type BasePrice = {
+    /**
+     * Base price amount for the plan, in major currency units (e.g. dollars).
+     */
+    amount: number;
+    /**
+     * Billing interval (e.g. 'month', 'year').
+     */
+    interval: PlanPriceVariantDetailsInterval;
+    /**
+     * Number of intervals per billing cycle. Defaults to 1.
+     */
+    intervalCount?: number | undefined;
+    /**
+     * Base price amounts in additional currencies. The base 'amount' is in the org's default currency.
+     */
+    additionalCurrencies?: Array<VariantDetailsAdditionalCurrency> | undefined;
+};
+/**
+ * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
+ */
+declare const PlanAddItemResetInterval: {
+    readonly OneOff: "one_off";
+    readonly Minute: "minute";
+    readonly Hour: "hour";
+    readonly Day: "day";
+    readonly Week: "week";
+    readonly Month: "month";
+    readonly Quarter: "quarter";
+    readonly SemiAnnual: "semi_annual";
+    readonly Year: "year";
+};
+/**
+ * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
+ */
+type PlanAddItemResetInterval = OpenEnum<typeof PlanAddItemResetInterval>;
+/**
+ * Reset configuration for consumable features. Omit for non-consumable features like seats.
+ */
+type PlanVariantDetailsReset1 = {
+    /**
+     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
+     */
+    interval: PlanAddItemResetInterval;
+    /**
+     * Number of intervals between resets. Defaults to 1.
+     */
+    intervalCount?: number | undefined;
+};
+type AddItemAdditionalCurrency = {
+    /**
+     * Three-letter Stripe-supported currency code (e.g. 'eur', 'gbp').
+     */
+    currency: string;
+    /**
+     * Price amount in this currency. Set explicitly per currency, not converted from the base amount.
+     */
+    amount: number;
+};
+type VariantDetailsTierAdditionalCurrency = {
+    /**
+     * Three-letter Stripe-supported currency code (e.g. 'eur', 'gbp').
+     */
+    currency: string;
+    /**
+     * Per-unit amount for this tier in this currency.
+     */
+    amount?: number | undefined;
+    /**
+     * Flat amount for this tier in this currency, if the tier uses one.
+     */
+    flatAmount?: number | undefined;
+};
+type PlanVariantDetailsTier1 = {
+    to: number | string;
+    amount: number;
+    flatAmount?: number | undefined;
+    additionalCurrencies?: Array<VariantDetailsTierAdditionalCurrency> | undefined;
+};
+declare const PlanVariantDetailsTierBehavior1: {
+    readonly Graduated: "graduated";
+    readonly Volume: "volume";
+};
+type PlanVariantDetailsTierBehavior1 = OpenEnum<typeof PlanVariantDetailsTierBehavior1>;
+/**
+ * Billing interval. For consumable features, should match reset.interval.
+ */
+declare const PlanAddItemPriceInterval: {
+    readonly OneOff: "one_off";
+    readonly Week: "week";
+    readonly Month: "month";
+    readonly Quarter: "quarter";
+    readonly SemiAnnual: "semi_annual";
+    readonly Year: "year";
+};
+/**
+ * Billing interval. For consumable features, should match reset.interval.
+ */
+type PlanAddItemPriceInterval = OpenEnum<typeof PlanAddItemPriceInterval>;
+/**
+ * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
+ */
+declare const PlanAddItemBillingMethod: {
+    readonly Prepaid: "prepaid";
+    readonly UsageBased: "usage_based";
+};
+/**
+ * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
+ */
+type PlanAddItemBillingMethod = OpenEnum<typeof PlanAddItemBillingMethod>;
+/**
+ * Pricing for usage beyond included units. Omit for free features.
+ */
+type PlanVariantDetailsPrice1 = {
+    /**
+     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
+     */
+    amount?: number | undefined;
+    /**
+     * Amounts in additional currencies for this flat price. The base 'amount' is in the org's default currency. Only valid with 'amount', not 'tiers'.
+     */
+    additionalCurrencies?: Array<AddItemAdditionalCurrency> | undefined;
+    /**
+     * Tiered pricing.  Either 'amount' or 'tiers' is required.
+     */
+    tiers?: Array<PlanVariantDetailsTier1> | undefined;
+    tierBehavior?: PlanVariantDetailsTierBehavior1 | undefined;
+    /**
+     * Billing interval. For consumable features, should match reset.interval.
+     */
+    interval: PlanAddItemPriceInterval;
+    /**
+     * Number of intervals per billing cycle. Defaults to 1.
+     */
+    intervalCount: number;
+    /**
+     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
+     */
+    billingUnits: number;
+    /**
+     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
+     */
+    billingMethod: PlanAddItemBillingMethod;
+    /**
+     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
+     */
+    maxPurchase?: number | null | undefined;
+};
+/**
+ * Billing behavior when quantity increases mid-cycle.
+ */
+declare const OnIncrease: {
+    readonly BillImmediately: "bill_immediately";
+    readonly ProrateImmediately: "prorate_immediately";
+    readonly ProrateNextCycle: "prorate_next_cycle";
+    readonly BillNextCycle: "bill_next_cycle";
+};
+/**
+ * Billing behavior when quantity increases mid-cycle.
+ */
+type OnIncrease = OpenEnum<typeof OnIncrease>;
+/**
+ * Credit behavior when quantity decreases mid-cycle.
+ */
+declare const OnDecrease: {
+    readonly Prorate: "prorate";
+    readonly ProrateImmediately: "prorate_immediately";
+    readonly ProrateNextCycle: "prorate_next_cycle";
+    readonly None: "none";
+    readonly NoProrations: "no_prorations";
+};
+/**
+ * Credit behavior when quantity decreases mid-cycle.
  */
 type OnDecrease = OpenEnum<typeof OnDecrease>;
 /**
@@ -895,7 +1233,7 @@ type VariantDetailsExpiryDurationType = OpenEnum<typeof VariantDetailsExpiryDura
 /**
  * Rollover config for unused units. If set, unused included units carry over.
  */
-type PlanVariantDetailsRollover = {
+type PlanVariantDetailsRollover1 = {
     /**
      * Max rollover units. Omit for unlimited rollover.
      */
@@ -936,11 +1274,11 @@ type PlanPlanItem = {
     /**
      * Reset configuration for consumable features. Omit for non-consumable features like seats.
      */
-    reset?: PlanVariantDetailsReset | undefined;
+    reset?: PlanVariantDetailsReset1 | undefined;
     /**
      * Pricing for usage beyond included units. Omit for free features.
      */
-    price?: PlanVariantDetailsPrice | undefined;
+    price?: PlanVariantDetailsPrice1 | undefined;
     /**
      * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
      */
@@ -948,7 +1286,7 @@ type PlanPlanItem = {
     /**
      * Rollover config for unused units. If set, unused included units carry over.
      */
-    rollover?: PlanVariantDetailsRollover | undefined;
+    rollover?: PlanVariantDetailsRollover1 | undefined;
 };
 /**
  * Match items with this billing method (prepaid or usage_based).
@@ -1002,6 +1340,10 @@ type PlanItemFilter = {
      * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
      */
     intervalCount?: number | undefined;
+    /**
+     * Match items whose grant equals this included usage. Omitted is a wildcard.
+     */
+    included?: number | undefined;
 };
 /**
  * Unit of time for the trial ('day', 'month', 'year').
@@ -1039,7 +1381,7 @@ type FreeTrialParams = {
      */
     durationType: PlanVariantDetailsDurationType1;
     /**
-     * If true, payment method required to start trial. Customer is charged after trial ends.
+     * If true, a payment method is required to start the trial and the customer is charged when it ends. Defaults to false.
      */
     cardRequired: boolean;
     /**
@@ -1050,7 +1392,7 @@ type FreeTrialParams = {
 /**
  * The time interval for the purchase limit window.
  */
-declare const PlanVariantDetailsPurchaseLimitInterval: {
+declare const PlanVariantDetailsPurchaseLimitInterval1: {
     readonly Hour: "hour";
     readonly Day: "day";
     readonly Week: "week";
@@ -1059,15 +1401,15 @@ declare const PlanVariantDetailsPurchaseLimitInterval: {
 /**
  * The time interval for the purchase limit window.
  */
-type PlanVariantDetailsPurchaseLimitInterval = OpenEnum<typeof PlanVariantDetailsPurchaseLimitInterval>;
+type PlanVariantDetailsPurchaseLimitInterval1 = OpenEnum<typeof PlanVariantDetailsPurchaseLimitInterval1>;
 /**
  * Optional rate limit to cap how often auto top-ups occur. Pass count to set the current window's consumed top-ups.
  */
-type PlanVariantDetailsPurchaseLimit = {
+type PlanVariantDetailsPurchaseLimit1 = {
     /**
      * The time interval for the purchase limit window.
      */
-    interval: PlanVariantDetailsPurchaseLimitInterval;
+    interval: PlanVariantDetailsPurchaseLimitInterval1;
     /**
      * Number of intervals in the purchase limit window.
      */
@@ -1081,7 +1423,7 @@ type PlanVariantDetailsPurchaseLimit = {
      */
     count?: number | undefined;
 };
-type PlanVariantDetailsAutoTopup = {
+type PlanVariantDetailsAutoTopup1 = {
     /**
      * The ID of the feature (credit balance) to auto top-up.
      */
@@ -1101,7 +1443,7 @@ type PlanVariantDetailsAutoTopup = {
     /**
      * Optional rate limit to cap how often auto top-ups occur. Pass count to set the current window's consumed top-ups.
      */
-    purchaseLimit?: PlanVariantDetailsPurchaseLimit | undefined;
+    purchaseLimit?: PlanVariantDetailsPurchaseLimit1 | undefined;
     /**
      * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
      */
@@ -1110,15 +1452,15 @@ type PlanVariantDetailsAutoTopup = {
 /**
  * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
  */
-declare const PlanVariantDetailsLimitType: {
+declare const PlanVariantDetailsLimitType1: {
     readonly Absolute: "absolute";
     readonly UsagePercentage: "usage_percentage";
 };
 /**
  * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
  */
-type PlanVariantDetailsLimitType = OpenEnum<typeof PlanVariantDetailsLimitType>;
-type PlanVariantDetailsSpendLimit = {
+type PlanVariantDetailsLimitType1 = OpenEnum<typeof PlanVariantDetailsLimitType1>;
+type PlanVariantDetailsSpendLimit1 = {
     /**
      * Optional feature ID this spend limit applies to.
      */
@@ -1130,7 +1472,7 @@ type PlanVariantDetailsSpendLimit = {
     /**
      * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
      */
-    limitType?: PlanVariantDetailsLimitType | undefined;
+    limitType?: PlanVariantDetailsLimitType1 | undefined;
     /**
      * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
      */
@@ -1143,7 +1485,7 @@ type PlanVariantDetailsSpendLimit = {
 /**
  * Interval for the cap, aligned to the customer's billing cycle.
  */
-declare const PlanVariantDetailsUsageLimitInterval: {
+declare const PlanVariantDetailsUsageLimitInterval1: {
     readonly Day: "day";
     readonly Week: "week";
     readonly Month: "month";
@@ -1152,27 +1494,27 @@ declare const PlanVariantDetailsUsageLimitInterval: {
 /**
  * Interval for the cap, aligned to the customer's billing cycle.
  */
-type PlanVariantDetailsUsageLimitInterval = OpenEnum<typeof PlanVariantDetailsUsageLimitInterval>;
+type PlanVariantDetailsUsageLimitInterval1 = OpenEnum<typeof PlanVariantDetailsUsageLimitInterval1>;
 /**
  * Window alignment. 'billing_cycle' phases the interval to the customer's renewal time; 'utc' aligns to the UTC calendar.
  */
-declare const PlanVariantDetailsAnchor: {
+declare const PlanVariantDetailsAnchor1: {
     readonly BillingCycle: "billing_cycle";
     readonly Utc: "utc";
 };
 /**
  * Window alignment. 'billing_cycle' phases the interval to the customer's renewal time; 'utc' aligns to the UTC calendar.
  */
-type PlanVariantDetailsAnchor = OpenEnum<typeof PlanVariantDetailsAnchor>;
+type PlanVariantDetailsAnchor1 = OpenEnum<typeof PlanVariantDetailsAnchor1>;
 /**
  * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
  */
-type PlanVariantDetailsFilter = {
+type PlanVariantDetailsFilter1 = {
     properties: {
         [k: string]: string;
     };
 };
-type PlanVariantDetailsUsageLimit = {
+type PlanVariantDetailsUsageLimit1 = {
     /**
      * The feature this usage limit applies to.
      */
@@ -1188,20 +1530,20 @@ type PlanVariantDetailsUsageLimit = {
     /**
      * Interval for the cap, aligned to the customer's billing cycle.
      */
-    interval: PlanVariantDetailsUsageLimitInterval;
+    interval: PlanVariantDetailsUsageLimitInterval1;
     /**
      * Window alignment. 'billing_cycle' phases the interval to the customer's renewal time; 'utc' aligns to the UTC calendar.
      */
-    anchor?: PlanVariantDetailsAnchor | undefined;
+    anchor?: PlanVariantDetailsAnchor1 | undefined;
     /**
      * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
      */
-    filter?: PlanVariantDetailsFilter | undefined;
+    filter?: PlanVariantDetailsFilter1 | undefined;
 };
 /**
  * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
  */
-declare const PlanVariantDetailsThresholdType: {
+declare const PlanVariantDetailsThresholdType1: {
     readonly Usage: "usage";
     readonly UsagePercentage: "usage_percentage";
     readonly Remaining: "remaining";
@@ -1210,8 +1552,8 @@ declare const PlanVariantDetailsThresholdType: {
 /**
  * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
  */
-type PlanVariantDetailsThresholdType = OpenEnum<typeof PlanVariantDetailsThresholdType>;
-type PlanVariantDetailsUsageAlert = {
+type PlanVariantDetailsThresholdType1 = OpenEnum<typeof PlanVariantDetailsThresholdType1>;
+type PlanVariantDetailsUsageAlert1 = {
     /**
      * The feature ID this alert applies to.
      */
@@ -1227,13 +1569,13 @@ type PlanVariantDetailsUsageAlert = {
     /**
      * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
      */
-    thresholdType: PlanVariantDetailsThresholdType;
+    thresholdType: PlanVariantDetailsThresholdType1;
     /**
      * Optional user-defined label to distinguish multiple alerts on the same feature.
      */
     name?: string | undefined;
 };
-type PlanVariantDetailsOverageAllowed = {
+type PlanVariantDetailsOverageAllowed1 = {
     /**
      * The feature ID this overage allowed control applies to.
      */
@@ -1246,338 +1588,412 @@ type PlanVariantDetailsOverageAllowed = {
 /**
  * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
  */
-type PlanVariantDetailsBillingControls = {
+type PlanVariantDetailsBillingControls1 = {
     /**
      * List of auto top-up configurations per feature.
      */
-    autoTopups?: Array<PlanVariantDetailsAutoTopup> | undefined;
+    autoTopups?: Array<PlanVariantDetailsAutoTopup1> | undefined;
     /**
      * List of overage spend limits per feature (caps overage spend).
      */
-    spendLimits?: Array<PlanVariantDetailsSpendLimit> | undefined;
+    spendLimits?: Array<PlanVariantDetailsSpendLimit1> | undefined;
     /**
      * List of hard usage caps per feature (max units per interval).
      */
-    usageLimits?: Array<PlanVariantDetailsUsageLimit> | undefined;
+    usageLimits?: Array<PlanVariantDetailsUsageLimit1> | undefined;
     /**
      * List of usage alert configurations per feature.
      */
-    usageAlerts?: Array<PlanVariantDetailsUsageAlert> | undefined;
+    usageAlerts?: Array<PlanVariantDetailsUsageAlert1> | undefined;
     /**
      * List of overage allowed controls per feature. When enabled, usage can exceed balance.
      */
-    overageAllowed?: Array<PlanVariantDetailsOverageAllowed> | undefined;
+    overageAllowed?: Array<PlanVariantDetailsOverageAllowed1> | undefined;
 };
 /**
- * The customization that transforms the base plan into this variant.
+ * Billing interval (e.g. 'month', 'year').
  */
-type Customize1 = {
-    /**
-     * Override the base price of the plan. Pass null to remove the base price.
-     */
-    price?: BasePrice | null | undefined;
-    /**
-     * Items to add to the plan.
-     */
-    addItems?: Array<PlanPlanItem> | undefined;
-    /**
-     * Filters selecting items to remove from the plan.
-     */
-    removeItems?: Array<PlanItemFilter> | undefined;
+declare const PlanPriceUpsertLicenseInterval: {
+    readonly OneOff: "one_off";
+    readonly Week: "week";
+    readonly Month: "month";
+    readonly Quarter: "quarter";
+    readonly SemiAnnual: "semi_annual";
+    readonly Year: "year";
+};
+/**
+ * Billing interval (e.g. 'month', 'year').
+ */
+type PlanPriceUpsertLicenseInterval = OpenEnum<typeof PlanPriceUpsertLicenseInterval>;
+type UpsertLicenseAdditionalCurrency = {
     /**
-     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
+     * Three-letter Stripe-supported currency code (e.g. 'eur', 'gbp').
      */
-    freeTrial?: FreeTrialParams | null | undefined;
+    currency: string;
     /**
-     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
+     * Price amount in this currency. Set explicitly per currency, not converted from the base amount.
      */
-    billingControls?: PlanVariantDetailsBillingControls | undefined;
+    amount: number;
 };
 /**
- * Details about how this variant relates to its latest base plan.
+ * Base price configuration for a plan.
  */
-type VariantDetails = {
+type UpsertLicenseBasePrice = {
     /**
-     * The ID of the base plan this variant was derived from.
+     * Base price amount for the plan, in major currency units (e.g. dollars).
      */
-    basePlanId: string;
+    amount: number;
     /**
-     * The customization that transforms the base plan into this variant.
+     * Billing interval (e.g. 'month', 'year').
      */
-    customize?: Customize1 | undefined;
-};
-/**
- * Miscellaneous plan-level configuration flags.
- */
-type PlanConfig1 = {
+    interval: PlanPriceUpsertLicenseInterval;
     /**
-     * If true, entitlements attached to this plan will still reset on schedule even when the customer's product is in a past_due state.
+     * Number of intervals per billing cycle. Defaults to 1.
      */
-    ignorePastDue: boolean;
+    intervalCount?: number | undefined;
+    /**
+     * Base price amounts in additional currencies. The base 'amount' is in the org's default currency.
+     */
+    additionalCurrencies?: Array<UpsertLicenseAdditionalCurrency> | undefined;
 };
 /**
- * The time interval for the purchase limit window.
+ * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
  */
-declare const PlanPurchaseLimitInterval: {
+declare const PlanUpsertLicenseResetInterval1: {
+    readonly OneOff: "one_off";
+    readonly Minute: "minute";
     readonly Hour: "hour";
     readonly Day: "day";
     readonly Week: "week";
     readonly Month: "month";
+    readonly Quarter: "quarter";
+    readonly SemiAnnual: "semi_annual";
+    readonly Year: "year";
 };
 /**
- * The time interval for the purchase limit window.
+ * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
  */
-type PlanPurchaseLimitInterval = OpenEnum<typeof PlanPurchaseLimitInterval>;
+type PlanUpsertLicenseResetInterval1 = OpenEnum<typeof PlanUpsertLicenseResetInterval1>;
 /**
- * Optional rate limit to cap how often auto top-ups occur.
+ * Reset configuration for consumable features. Omit for non-consumable features like seats.
  */
-type PlanPurchaseLimit = {
-    /**
-     * The time interval for the purchase limit window.
-     */
-    interval: PlanPurchaseLimitInterval;
+type PlanUpsertLicenseReset1 = {
     /**
-     * Number of intervals in the purchase limit window.
+     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
      */
-    intervalCount: number;
+    interval: PlanUpsertLicenseResetInterval1;
     /**
-     * Maximum number of auto top-ups allowed within the interval.
+     * Number of intervals between resets. Defaults to 1.
      */
-    limit: number;
+    intervalCount?: number | undefined;
 };
-type PlanAutoTopup = {
-    /**
-     * The ID of the feature (credit balance) to auto top-up.
-     */
-    featureId: string;
-    /**
-     * Whether auto top-up is enabled.
-     */
-    enabled: boolean;
-    /**
-     * When the balance drops below this threshold, an auto top-up will be purchased.
-     */
-    threshold: number;
-    /**
-     * Amount of credits to add per auto top-up.
-     */
-    quantity: number;
-    /**
-     * Optional rate limit to cap how often auto top-ups occur.
-     */
-    purchaseLimit?: PlanPurchaseLimit | undefined;
-    /**
-     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
-     */
-    invoiceMode?: boolean | undefined;
+type UpsertLicenseAddItemAdditionalCurrency = {
+    currency?: any | undefined;
+    amount?: any | undefined;
+};
+type PlanUpsertLicenseTier1 = {
+    to?: any | undefined;
+    amount?: any | undefined;
+    flatAmount?: any | undefined;
+    additionalCurrencies?: any | undefined;
+};
+declare const PlanUpsertLicenseTierBehavior1: {
+    readonly Graduated: "graduated";
+    readonly Volume: "volume";
 };
+type PlanUpsertLicenseTierBehavior1 = OpenEnum<typeof PlanUpsertLicenseTierBehavior1>;
 /**
- * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
+ * Billing interval. For consumable features, should match reset.interval.
  */
-declare const PlanLimitType: {
-    readonly Absolute: "absolute";
-    readonly UsagePercentage: "usage_percentage";
+declare const PlanUpsertLicenseAddItemPriceInterval1: {
+    readonly OneOff: "one_off";
+    readonly Week: "week";
+    readonly Month: "month";
+    readonly Quarter: "quarter";
+    readonly SemiAnnual: "semi_annual";
+    readonly Year: "year";
 };
 /**
- * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
+ * Billing interval. For consumable features, should match reset.interval.
  */
-type PlanLimitType = OpenEnum<typeof PlanLimitType>;
-type PlanSpendLimit = {
+type PlanUpsertLicenseAddItemPriceInterval1 = OpenEnum<typeof PlanUpsertLicenseAddItemPriceInterval1>;
+/**
+ * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
+ */
+declare const PlanUpsertLicenseAddItemBillingMethod1: {
+    readonly Prepaid: "prepaid";
+    readonly UsageBased: "usage_based";
+};
+/**
+ * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
+ */
+type PlanUpsertLicenseAddItemBillingMethod1 = OpenEnum<typeof PlanUpsertLicenseAddItemBillingMethod1>;
+/**
+ * Pricing for usage beyond included units. Omit for free features.
+ */
+type PlanUpsertLicensePrice1 = {
     /**
-     * Optional feature ID this spend limit applies to.
+     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
      */
-    featureId?: string | undefined;
+    amount?: number | undefined;
+    /**
+     * Amounts in additional currencies for this flat price. The base 'amount' is in the org's default currency. Only valid with 'amount', not 'tiers'.
+     */
+    additionalCurrencies?: Array<UpsertLicenseAddItemAdditionalCurrency> | undefined;
+    /**
+     * Tiered pricing.  Either 'amount' or 'tiers' is required.
+     */
+    tiers?: Array<PlanUpsertLicenseTier1> | undefined;
+    tierBehavior?: PlanUpsertLicenseTierBehavior1 | undefined;
+    /**
+     * Billing interval. For consumable features, should match reset.interval.
+     */
+    interval: PlanUpsertLicenseAddItemPriceInterval1;
     /**
-     * Whether the overage spend limit is enabled.
+     * Number of intervals per billing cycle. Defaults to 1.
      */
-    enabled: boolean;
+    intervalCount: number;
     /**
-     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
+     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
      */
-    limitType?: PlanLimitType | undefined;
+    billingUnits: number;
     /**
-     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
+     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
      */
-    overageLimit?: number | undefined;
+    billingMethod: PlanUpsertLicenseAddItemBillingMethod1;
     /**
-     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
+     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
      */
-    skipOverageBilling?: boolean | undefined;
+    maxPurchase?: number | null | undefined;
 };
 /**
- * Interval for the cap, aligned to the customer's billing cycle.
+ * Billing behavior when quantity increases mid-cycle.
  */
-declare const PlanUsageLimitInterval: {
-    readonly Day: "day";
-    readonly Week: "week";
-    readonly Month: "month";
-    readonly Year: "year";
+declare const UpsertLicenseOnIncrease: {
+    readonly BillImmediately: "bill_immediately";
+    readonly ProrateImmediately: "prorate_immediately";
+    readonly ProrateNextCycle: "prorate_next_cycle";
+    readonly BillNextCycle: "bill_next_cycle";
 };
 /**
- * Interval for the cap, aligned to the customer's billing cycle.
+ * Billing behavior when quantity increases mid-cycle.
  */
-type PlanUsageLimitInterval = OpenEnum<typeof PlanUsageLimitInterval>;
+type UpsertLicenseOnIncrease = OpenEnum<typeof UpsertLicenseOnIncrease>;
 /**
- * Window alignment. 'billing_cycle' phases the interval to the customer's renewal time; 'utc' aligns to the UTC calendar.
+ * Credit behavior when quantity decreases mid-cycle.
  */
-declare const PlanAnchor: {
-    readonly BillingCycle: "billing_cycle";
-    readonly Utc: "utc";
+declare const UpsertLicenseOnDecrease: {
+    readonly Prorate: "prorate";
+    readonly ProrateImmediately: "prorate_immediately";
+    readonly ProrateNextCycle: "prorate_next_cycle";
+    readonly None: "none";
+    readonly NoProrations: "no_prorations";
 };
 /**
- * Window alignment. 'billing_cycle' phases the interval to the customer's renewal time; 'utc' aligns to the UTC calendar.
+ * Credit behavior when quantity decreases mid-cycle.
  */
-type PlanAnchor = OpenEnum<typeof PlanAnchor>;
+type UpsertLicenseOnDecrease = OpenEnum<typeof UpsertLicenseOnDecrease>;
 /**
- * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
+ * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
  */
-type PlanFilter = {
-    properties: {
-        [k: string]: string;
-    };
-};
-type PlanUsageLimit = {
+type UpsertLicenseProration = {
     /**
-     * The feature this usage limit applies to.
+     * Billing behavior when quantity increases mid-cycle.
      */
-    featureId: string;
+    onIncrease: UpsertLicenseOnIncrease;
     /**
-     * Whether this usage limit is enabled.
+     * Credit behavior when quantity decreases mid-cycle.
      */
-    enabled: boolean;
+    onDecrease: UpsertLicenseOnDecrease;
+};
+/**
+ * When rolled over units expire.
+ */
+declare const UpsertLicenseExpiryDurationType: {
+    readonly Month: "month";
+    readonly Forever: "forever";
+};
+/**
+ * When rolled over units expire.
+ */
+type UpsertLicenseExpiryDurationType = OpenEnum<typeof UpsertLicenseExpiryDurationType>;
+/**
+ * Rollover config for unused units. If set, unused included units carry over.
+ */
+type PlanUpsertLicenseRollover1 = {
     /**
-     * Maximum units allowed per interval.
+     * Max rollover units. Omit for unlimited rollover.
      */
-    limit: number;
+    max?: number | undefined;
     /**
-     * Interval for the cap, aligned to the customer's billing cycle.
+     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
      */
-    interval: PlanUsageLimitInterval;
+    maxPercentage?: number | undefined;
     /**
-     * Window alignment. 'billing_cycle' phases the interval to the customer's renewal time; 'utc' aligns to the UTC calendar.
+     * When rolled over units expire.
      */
-    anchor?: PlanAnchor | undefined;
+    expiryDurationType: UpsertLicenseExpiryDurationType;
     /**
-     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
+     * Number of periods before expiry.
      */
-    filter?: PlanFilter | undefined;
-};
-/**
- * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
- */
-declare const PlanThresholdType: {
-    readonly Usage: "usage";
-    readonly UsagePercentage: "usage_percentage";
-    readonly Remaining: "remaining";
-    readonly RemainingPercentage: "remaining_percentage";
+    expiryDurationLength?: number | undefined;
 };
 /**
- * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
+ * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
  */
-type PlanThresholdType = OpenEnum<typeof PlanThresholdType>;
-type PlanUsageAlert = {
+type UpsertLicensePlanItem = {
     /**
-     * The feature ID this alert applies to.
+     * The ID of the feature to configure.
      */
-    featureId?: string | undefined;
+    featureId: string;
     /**
-     * Whether this usage alert is enabled.
+     * Number of free units included. Balance resets to this each interval for consumable features.
      */
-    enabled: boolean;
+    included?: number | undefined;
     /**
-     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
+     * If true, customer has unlimited access to this feature.
      */
-    threshold: number;
+    unlimited?: boolean | undefined;
     /**
-     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
+     * Whether entity-level grants contribute to a shared customer balance.
      */
-    thresholdType: PlanThresholdType;
+    pooled: boolean;
     /**
-     * Optional user-defined label to distinguish multiple alerts on the same feature.
+     * Reset configuration for consumable features. Omit for non-consumable features like seats.
      */
-    name?: string | undefined;
-};
-type PlanOverageAllowed = {
+    reset?: PlanUpsertLicenseReset1 | undefined;
     /**
-     * The feature ID this overage allowed control applies to.
+     * Pricing for usage beyond included units. Omit for free features.
      */
-    featureId: string;
+    price?: PlanUpsertLicensePrice1 | undefined;
     /**
-     * Whether overage is allowed for this feature.
+     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
      */
-    enabled: boolean;
+    proration?: UpsertLicenseProration | undefined;
+    /**
+     * Rollover config for unused units. If set, unused included units carry over.
+     */
+    rollover?: PlanUpsertLicenseRollover1 | undefined;
 };
 /**
- * Plan-level billing controls used as customer defaults.
+ * Match items with this billing method (prepaid or usage_based).
  */
-type PlanBillingControls = {
+declare const PlanUpsertLicenseRemoveItemBillingMethod1: {
+    readonly Prepaid: "prepaid";
+    readonly UsageBased: "usage_based";
+};
+/**
+ * Match items with this billing method (prepaid or usage_based).
+ */
+type PlanUpsertLicenseRemoveItemBillingMethod1 = OpenEnum<typeof PlanUpsertLicenseRemoveItemBillingMethod1>;
+declare const PlanIntervalUpsertLicenseRemoveItemEnum2: {
+    readonly OneOff: "one_off";
+    readonly Minute: "minute";
+    readonly Hour: "hour";
+    readonly Day: "day";
+    readonly Week: "week";
+    readonly Month: "month";
+    readonly Quarter: "quarter";
+    readonly SemiAnnual: "semi_annual";
+    readonly Year: "year";
+};
+type PlanIntervalUpsertLicenseRemoveItemEnum2 = OpenEnum<typeof PlanIntervalUpsertLicenseRemoveItemEnum2>;
+declare const PlanIntervalUpsertLicenseRemoveItemEnum1: {
+    readonly OneOff: "one_off";
+    readonly Week: "week";
+    readonly Month: "month";
+    readonly Quarter: "quarter";
+    readonly SemiAnnual: "semi_annual";
+    readonly Year: "year";
+};
+type PlanIntervalUpsertLicenseRemoveItemEnum1 = OpenEnum<typeof PlanIntervalUpsertLicenseRemoveItemEnum1>;
+/**
+ * Filter for matching plan items. All provided fields must match (AND).
+ */
+type UpsertLicensePlanItemFilter = {
     /**
-     * List of auto top-up configurations per feature.
+     * Match items linked to this feature.
      */
-    autoTopups?: Array<PlanAutoTopup> | undefined;
+    featureId?: string | undefined;
     /**
-     * List of overage spend limits per feature (caps overage spend).
+     * Match items with this billing method (prepaid or usage_based).
      */
-    spendLimits?: Array<PlanSpendLimit> | undefined;
+    billingMethod?: PlanUpsertLicenseRemoveItemBillingMethod1 | undefined;
     /**
-     * List of hard usage caps per feature (max units per interval).
+     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
      */
-    usageLimits?: Array<PlanUsageLimit> | undefined;
+    interval?: PlanIntervalUpsertLicenseRemoveItemEnum1 | PlanIntervalUpsertLicenseRemoveItemEnum2 | undefined;
     /**
-     * List of usage alert configurations per feature.
+     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
      */
-    usageAlerts?: Array<PlanUsageAlert> | undefined;
+    intervalCount?: number | undefined;
     /**
-     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
+     * Match items whose grant equals this included usage. Omitted is a wildcard.
      */
-    overageAllowed?: Array<PlanOverageAllowed> | undefined;
+    included?: number | undefined;
 };
-/**
- * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
- */
-declare const PlanStatus: {
-    readonly Active: "active";
-    readonly Scheduled: "scheduled";
+type UpsertLicenseCustomize = {
+    price?: UpsertLicenseBasePrice | null | undefined;
+    addItems?: Array<UpsertLicensePlanItem> | undefined;
+    removeItems?: Array<UpsertLicensePlanItemFilter> | undefined;
 };
-/**
- * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
- */
-type PlanStatus = OpenEnum<typeof PlanStatus>;
-/**
- * The action that would occur if this plan were attached to the customer.
- */
-declare const AttachAction: {
-    readonly Activate: "activate";
-    readonly Upgrade: "upgrade";
-    readonly Downgrade: "downgrade";
-    readonly None: "none";
-    readonly Purchase: "purchase";
+type UpsertLicense = {
+    licensePlanId: string;
+    included?: number | undefined;
+    prepaidOnly?: boolean | undefined;
+    customize?: UpsertLicenseCustomize | null | undefined;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+};
+type RemoveLicense = {
+    licensePlanId: string;
 };
 /**
- * The action that would occur if this plan were attached to the customer.
+ * The customization that transforms the base plan into this variant.
  */
-type AttachAction = OpenEnum<typeof AttachAction>;
-type CustomerEligibility = {
+type Customize1 = {
     /**
-     * Whether the trial on this plan is available to this customer. For example, if the customer used the trial in the past, this will be false.
+     * Override the base price of the plan. Pass null to remove the base price.
      */
-    trialAvailable?: boolean | undefined;
+    price?: BasePrice | null | undefined;
     /**
-     * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
+     * Items to add to the plan.
      */
-    status?: PlanStatus | undefined;
+    addItems?: Array<PlanPlanItem> | undefined;
     /**
-     * Whether the customer's active instance of this plan is set to cancel.
+     * Filters selecting items to remove from the plan.
      */
-    canceling?: boolean | undefined;
+    removeItems?: Array<PlanItemFilter> | undefined;
     /**
-     * Whether the customer is currently on a free trial of this plan.
+     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
      */
-    trialing?: boolean | undefined;
+    freeTrial?: FreeTrialParams | null | undefined;
     /**
-     * The action that would occur if this plan were attached to the customer.
+     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
      */
-    attachAction: AttachAction;
+    billingControls?: PlanVariantDetailsBillingControls1 | undefined;
+    /**
+     * License links to add or override for this customer, keyed by license_plan_id. Omitted fields inherit the plan catalog link (included defaults to 1 when the license is not in the catalog). A bare entry restores the license to pure catalog inheritance.
+     */
+    upsertLicenses?: Array<UpsertLicense> | undefined;
+    /**
+     * License links to drop, keyed by license_plan_id. Parallel to remove_items.
+     */
+    removeLicenses?: Array<RemoveLicense> | undefined;
+};
+/**
+ * Details about how this variant relates to its latest base plan.
+ */
+type VariantDetails = {
+    /**
+     * The ID of the base plan this variant was derived from.
+     */
+    basePlanId: string;
+    /**
+     * The customization that transforms the base plan into this variant.
+     */
+    customize?: Customize1 | undefined;
 };
 type Plan = {
     /**
@@ -1600,6 +2016,14 @@ type Plan = {
      * Version number of the plan. Incremented when plan configuration changes.
      */
     version: number;
+    /**
+     * User-facing version identity. Defaults to v{n} when the version is minted.
+     */
+    versionSlug?: string | null | undefined;
+    /**
+     * Whether this is the active version of the plan. At most one version is active.
+     */
+    active?: boolean | undefined;
     /**
      * Whether this is an add-on plan that can be attached alongside a main plan.
      */
@@ -1632,14 +2056,6 @@ type Plan = {
      * Whether the plan is archived. Archived plans cannot be attached to new customers.
      */
     archived: boolean;
-    /**
-     * Deprecated. Use variant_details.base_plan_id instead. If this is a variant, the ID of the base plan it was created from.
-     */
-    baseVariantId: string | null;
-    /**
-     * Details about how this variant relates to its latest base plan.
-     */
-    variantDetails?: VariantDetails | undefined;
     /**
      * Miscellaneous plan-level configuration flags.
      */
@@ -1655,6 +2071,14 @@ type Plan = {
         [k: string]: any;
     };
     customerEligibility?: CustomerEligibility | undefined;
+    /**
+     * Deprecated. Use variant_details.base_plan_id instead. If this is a variant, the ID of the base plan it was created from.
+     */
+    baseVariantId: string | null;
+    /**
+     * Details about how this variant relates to its latest base plan.
+     */
+    variantDetails?: VariantDetails | undefined;
 };
 
 export type { BalanceFeature as B, ClosedEnum as C, OpenEnum as O, Plan as P, Balance as a };