autumn-js 1.2.13 → 1.2.14

package/dist/backend/{routeTypes-DVwngaBn.d.mts → routeTypes-B-X-zb1q.d.mts}

@@ -1629,7 +1629,7 @@ type CheckParams = {
 /**
  * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools.
  */
-declare const FlagType: {
+declare const FlagType2: {
     readonly Boolean: "boolean";
     readonly Metered: "metered";
     readonly CreditSystem: "credit_system";
@@ -1637,8 +1637,8 @@ declare const FlagType: {
 /**
  * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools.
  */
-type FlagType = OpenEnum<typeof FlagType>;
-type CheckCreditSchema = {
+type FlagType2 = OpenEnum<typeof FlagType2>;
+type CheckCreditSchema2 = {
     /**
      * ID of the metered feature that draws from this credit system.
      */
@@ -1651,7 +1651,7 @@ type CheckCreditSchema = {
 /**
  * Display names for the feature in billing UI and customer-facing components.
  */
-type FlagDisplay = {
+type FlagDisplay2 = {
     /**
      * Singular form for UI display (e.g., 'API call', 'seat').
      */
@@ -1664,7 +1664,7 @@ type FlagDisplay = {
 /**
  * The full feature object if expanded.
  */
-type CheckFeature = {
+type CheckFeature2 = {
     /**
      * The unique identifier for this feature, used in /check and /track calls.
      */
@@ -1676,7 +1676,7 @@ type CheckFeature = {
     /**
      * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools.
      */
-    type: FlagType;
+    type: FlagType2;
     /**
      * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
      */
@@ -1688,17 +1688,17 @@ type CheckFeature = {
     /**
      * For credit_system features: maps metered features to their credit costs.
      */
-    creditSchema?: Array<CheckCreditSchema> | undefined;
+    creditSchema?: Array<CheckCreditSchema2> | undefined;
     /**
      * Display names for the feature in billing UI and customer-facing components.
      */
-    display?: FlagDisplay | undefined;
+    display?: FlagDisplay2 | undefined;
     /**
      * Whether the feature is archived and hidden from the dashboard.
      */
     archived: boolean;
 };
-type Flag = {
+type Flag2 = {
     /**
      * The unique identifier for this flag.
      */
@@ -1718,44 +1718,44 @@ type Flag = {
     /**
      * The full feature object if expanded.
      */
-    feature?: CheckFeature | undefined;
+    feature?: CheckFeature2 | undefined;
 };
 /**
  * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
  */
-declare const Scenario: {
+declare const Scenario2: {
     readonly UsageLimit: "usage_limit";
     readonly FeatureFlag: "feature_flag";
 };
 /**
  * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
  */
-type Scenario = OpenEnum<typeof Scenario>;
+type Scenario2 = OpenEnum<typeof Scenario2>;
 /**
  * The environment of the product
  */
-declare const CheckEnv: {
+declare const CheckEnv2: {
     readonly Sandbox: "sandbox";
     readonly Live: "live";
 };
 /**
  * The environment of the product
  */
-type CheckEnv = OpenEnum<typeof CheckEnv>;
-declare const ProductType: {
+type CheckEnv2 = OpenEnum<typeof CheckEnv2>;
+declare const ProductType2: {
     readonly Feature: "feature";
     readonly PricedFeature: "priced_feature";
     readonly Price: "price";
 };
-type ProductType = OpenEnum<typeof ProductType>;
-declare const FeatureType: {
+type ProductType2 = OpenEnum<typeof ProductType2>;
+declare const FeatureType2: {
     readonly SingleUse: "single_use";
     readonly ContinuousUse: "continuous_use";
     readonly Boolean: "boolean";
     readonly Static: "static";
 };
-type FeatureType = OpenEnum<typeof FeatureType>;
-declare const CheckInterval: {
+type FeatureType2 = OpenEnum<typeof FeatureType2>;
+declare const CheckInterval2: {
     readonly Minute: "minute";
     readonly Hour: "hour";
     readonly Day: "day";
@@ -1765,60 +1765,60 @@ declare const CheckInterval: {
     readonly SemiAnnual: "semi_annual";
     readonly Year: "year";
 };
-type CheckInterval = OpenEnum<typeof CheckInterval>;
-declare const CheckTierBehavior: {
+type CheckInterval2 = OpenEnum<typeof CheckInterval2>;
+declare const CheckTierBehavior2: {
     readonly Graduated: "graduated";
     readonly Volume: "volume";
 };
-type CheckTierBehavior = OpenEnum<typeof CheckTierBehavior>;
-declare const UsageModel: {
+type CheckTierBehavior2 = OpenEnum<typeof CheckTierBehavior2>;
+declare const UsageModel2: {
     readonly Prepaid: "prepaid";
     readonly PayPerUse: "pay_per_use";
 };
-type UsageModel = OpenEnum<typeof UsageModel>;
-type ProductDisplay = {
+type UsageModel2 = OpenEnum<typeof UsageModel2>;
+type ProductDisplay2 = {
     primaryText: string;
     secondaryText?: string | null | undefined;
 };
-declare const ConfigDuration: {
+declare const ConfigDuration2: {
     readonly Month: "month";
     readonly Forever: "forever";
 };
-type ConfigDuration = OpenEnum<typeof ConfigDuration>;
-type CheckRollover = {
+type ConfigDuration2 = OpenEnum<typeof ConfigDuration2>;
+type CheckRollover2 = {
     max?: number | null | undefined;
     maxPercentage?: number | null | undefined;
-    duration: ConfigDuration;
+    duration: ConfigDuration2;
     length: number;
 };
-declare const CheckOnIncrease: {
+declare const CheckOnIncrease2: {
     readonly BillImmediately: "bill_immediately";
     readonly ProrateImmediately: "prorate_immediately";
     readonly ProrateNextCycle: "prorate_next_cycle";
     readonly BillNextCycle: "bill_next_cycle";
 };
-type CheckOnIncrease = OpenEnum<typeof CheckOnIncrease>;
-declare const CheckOnDecrease: {
+type CheckOnIncrease2 = OpenEnum<typeof CheckOnIncrease2>;
+declare const CheckOnDecrease2: {
     readonly Prorate: "prorate";
     readonly ProrateImmediately: "prorate_immediately";
     readonly ProrateNextCycle: "prorate_next_cycle";
     readonly None: "none";
     readonly NoProrations: "no_prorations";
 };
-type CheckOnDecrease = OpenEnum<typeof CheckOnDecrease>;
-type CheckConfig = {
-    rollover?: CheckRollover | null | undefined;
-    onIncrease?: CheckOnIncrease | null | undefined;
-    onDecrease?: CheckOnDecrease | null | undefined;
+type CheckOnDecrease2 = OpenEnum<typeof CheckOnDecrease2>;
+type CheckConfig2 = {
+    rollover?: CheckRollover2 | null | undefined;
+    onIncrease?: CheckOnIncrease2 | null | undefined;
+    onDecrease?: CheckOnDecrease2 | null | undefined;
 };
 /**
  * Product item defining features and pricing within a product
  */
-type CheckItem = {
+type CheckItem2 = {
     /**
      * The type of the product item
      */
-    type?: ProductType | null | undefined;
+    type?: ProductType2 | null | undefined;
     /**
      * The feature ID of the product item. If the item is a fixed price, should be `null`
      */
@@ -1826,7 +1826,7 @@ type CheckItem = {
     /**
      * Single use features are used once and then depleted, like API calls or credits. Continuous use features are those being used on an ongoing-basis, like storage or seats.
      */
-    featureType?: FeatureType | null | undefined;
+    featureType?: FeatureType2 | null | undefined;
     /**
      * The amount of usage included for this feature.
      */
@@ -1834,7 +1834,7 @@ type CheckItem = {
     /**
      * The reset or billing interval of the product item. If null, feature will have no reset date, and if there's a price, it will be billed one-off.
      */
-    interval?: CheckInterval | null | undefined;
+    interval?: CheckInterval2 | null | undefined;
     /**
      * The interval count of the product item.
      */
@@ -1850,11 +1850,11 @@ type CheckItem = {
     /**
      * How tiers are applied: graduated (split across bands) or volume (flat rate for the matched tier). Defaults to graduated.
      */
-    tierBehavior?: CheckTierBehavior | null | undefined;
+    tierBehavior?: CheckTierBehavior2 | null | undefined;
     /**
      * Whether the feature should be prepaid upfront or billed for how much they use end of billing period.
      */
-    usageModel?: UsageModel | null | undefined;
+    usageModel?: UsageModel2 | null | undefined;
     /**
      * The amount per billing unit (eg. $9 / 250 units)
      */
@@ -1870,7 +1870,7 @@ type CheckItem = {
     /**
      * The display of the product item.
      */
-    display?: ProductDisplay | null | undefined;
+    display?: ProductDisplay2 | null | undefined;
     /**
      * Used in customer context. Quantity of the feature the customer has prepaid for.
      */
@@ -1882,12 +1882,12 @@ type CheckItem = {
     /**
      * Configuration for rollover and proration behavior of the feature.
      */
-    config?: CheckConfig | null | undefined;
+    config?: CheckConfig2 | null | undefined;
 };
 /**
  * The duration type of the free trial
  */
-declare const FreeTrialDuration: {
+declare const FreeTrialDuration2: {
     readonly Day: "day";
     readonly Month: "month";
     readonly Year: "year";
@@ -1895,12 +1895,12 @@ declare const FreeTrialDuration: {
 /**
  * The duration type of the free trial
  */
-type FreeTrialDuration = OpenEnum<typeof FreeTrialDuration>;
-type CheckFreeTrial = {
+type FreeTrialDuration2 = OpenEnum<typeof FreeTrialDuration2>;
+type CheckFreeTrial2 = {
     /**
      * The duration type of the free trial
      */
-    duration: FreeTrialDuration;
+    duration: FreeTrialDuration2;
     /**
      * The length of the duration type specified
      */
@@ -1921,7 +1921,7 @@ type CheckFreeTrial = {
 /**
  * Scenario for when this product is used in attach flows
  */
-declare const ProductScenario: {
+declare const ProductScenario2: {
     readonly Scheduled: "scheduled";
     readonly Active: "active";
     readonly New: "new";
@@ -1936,8 +1936,8 @@ declare const ProductScenario: {
 /**
  * Scenario for when this product is used in attach flows
  */
-type ProductScenario = OpenEnum<typeof ProductScenario>;
-type Properties = {
+type ProductScenario2 = OpenEnum<typeof ProductScenario2>;
+type Properties2 = {
     /**
      * True if the product has no base price or usage prices
      */
@@ -1959,7 +1959,7 @@ type Properties = {
      */
     updateable?: boolean | null | undefined;
 };
-type Product = {
+type Product2 = {
     /**
      * The ID of the product you set when creating the product
      */
@@ -1975,7 +1975,7 @@ type Product = {
     /**
      * The environment of the product
      */
-    env: CheckEnv;
+    env: CheckEnv2;
     /**
      * Whether the product is an add-on and can be purchased alongside other products
      */
@@ -1999,11 +1999,11 @@ type Product = {
     /**
      * Array of product items that define the product's features and pricing
      */
-    items: Array<CheckItem>;
+    items: Array<CheckItem2>;
     /**
      * Free trial configuration for this product, if available
      */
-    freeTrial: CheckFreeTrial | null;
+    freeTrial: CheckFreeTrial2 | null;
     /**
      * ID of the base variant this product is derived from
      */
@@ -2011,17 +2011,17 @@ type Product = {
     /**
      * Scenario for when this product is used in attach flows
      */
-    scenario?: ProductScenario | undefined;
-    properties?: Properties | undefined;
+    scenario?: ProductScenario2 | undefined;
+    properties?: Properties2 | undefined;
 };
 /**
  * Upgrade/upsell information when access is denied. Only present if with_preview was true and allowed is false.
  */
-type Preview = {
+type Preview2 = {
     /**
      * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
      */
-    scenario: Scenario;
+    scenario: Scenario2;
     /**
      * A title suitable for displaying in a paywall or upgrade modal.
      */
@@ -2041,12 +2041,462 @@ type Preview = {
     /**
      * Products that would grant access to this feature. Use to display upgrade options.
      */
-    products: Array<Product>;
+    products: Array<Product2>;
+};
+/**
+ * Accepted. Autumn is experiencing degraded service from a downstream provider, so access was allowed fail-open.
+ */
+type CheckResponseBody2 = {
+    /**
+     * Whether the customer is allowed to use the feature. True if they have sufficient balance or the feature is unlimited/boolean.
+     */
+    allowed: boolean;
+    /**
+     * The ID of the customer that was checked.
+     */
+    customerId: string;
+    /**
+     * The ID of the entity, if an entity-scoped check was performed.
+     */
+    entityId?: string | null | undefined;
+    /**
+     * The required balance that was checked against.
+     */
+    requiredBalance?: number | undefined;
+    /**
+     * The customer's balance for this feature. Null if the customer has no balance for this feature.
+     */
+    balance: Balance | null;
+    /**
+     * The flag associated with this check, if any.
+     */
+    flag: Flag2 | null;
+    /**
+     * Upgrade/upsell information when access is denied. Only present if with_preview was true and allowed is false.
+     */
+    preview?: Preview2 | undefined;
+};
+/**
+ * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools.
+ */
+declare const FlagType1: {
+    readonly Boolean: "boolean";
+    readonly Metered: "metered";
+    readonly CreditSystem: "credit_system";
+};
+/**
+ * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools.
+ */
+type FlagType1 = OpenEnum<typeof FlagType1>;
+type CheckCreditSchema1 = {
+    /**
+     * ID of the metered feature that draws from this credit system.
+     */
+    meteredFeatureId: string;
+    /**
+     * Credits consumed per unit of the metered feature.
+     */
+    creditCost: number;
+};
+/**
+ * Display names for the feature in billing UI and customer-facing components.
+ */
+type FlagDisplay1 = {
+    /**
+     * Singular form for UI display (e.g., 'API call', 'seat').
+     */
+    singular?: string | null | undefined;
+    /**
+     * Plural form for UI display (e.g., 'API calls', 'seats').
+     */
+    plural?: string | null | undefined;
+};
+/**
+ * The full feature object if expanded.
+ */
+type CheckFeature1 = {
+    /**
+     * The unique identifier for this feature, used in /check and /track calls.
+     */
+    id: string;
+    /**
+     * Human-readable name displayed in the dashboard and billing UI.
+     */
+    name: string;
+    /**
+     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools.
+     */
+    type: FlagType1;
+    /**
+     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
+     */
+    consumable: boolean;
+    /**
+     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
+     */
+    eventNames?: Array<string> | undefined;
+    /**
+     * For credit_system features: maps metered features to their credit costs.
+     */
+    creditSchema?: Array<CheckCreditSchema1> | undefined;
+    /**
+     * Display names for the feature in billing UI and customer-facing components.
+     */
+    display?: FlagDisplay1 | undefined;
+    /**
+     * Whether the feature is archived and hidden from the dashboard.
+     */
+    archived: boolean;
+};
+type Flag1 = {
+    /**
+     * The unique identifier for this flag.
+     */
+    id: string;
+    /**
+     * The plan ID this flag originates from, or null for standalone flags.
+     */
+    planId: string | null;
+    /**
+     * Timestamp when this flag expires, or null for no expiration.
+     */
+    expiresAt: number | null;
+    /**
+     * The feature ID this flag is for.
+     */
+    featureId: string;
+    /**
+     * The full feature object if expanded.
+     */
+    feature?: CheckFeature1 | undefined;
+};
+/**
+ * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
+ */
+declare const Scenario1: {
+    readonly UsageLimit: "usage_limit";
+    readonly FeatureFlag: "feature_flag";
+};
+/**
+ * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
+ */
+type Scenario1 = OpenEnum<typeof Scenario1>;
+/**
+ * The environment of the product
+ */
+declare const CheckEnv1: {
+    readonly Sandbox: "sandbox";
+    readonly Live: "live";
+};
+/**
+ * The environment of the product
+ */
+type CheckEnv1 = OpenEnum<typeof CheckEnv1>;
+declare const ProductType1: {
+    readonly Feature: "feature";
+    readonly PricedFeature: "priced_feature";
+    readonly Price: "price";
+};
+type ProductType1 = OpenEnum<typeof ProductType1>;
+declare const FeatureType1: {
+    readonly SingleUse: "single_use";
+    readonly ContinuousUse: "continuous_use";
+    readonly Boolean: "boolean";
+    readonly Static: "static";
+};
+type FeatureType1 = OpenEnum<typeof FeatureType1>;
+declare const CheckInterval1: {
+    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 CheckInterval1 = OpenEnum<typeof CheckInterval1>;
+declare const CheckTierBehavior1: {
+    readonly Graduated: "graduated";
+    readonly Volume: "volume";
+};
+type CheckTierBehavior1 = OpenEnum<typeof CheckTierBehavior1>;
+declare const UsageModel1: {
+    readonly Prepaid: "prepaid";
+    readonly PayPerUse: "pay_per_use";
+};
+type UsageModel1 = OpenEnum<typeof UsageModel1>;
+type ProductDisplay1 = {
+    primaryText: string;
+    secondaryText?: string | null | undefined;
+};
+declare const ConfigDuration1: {
+    readonly Month: "month";
+    readonly Forever: "forever";
+};
+type ConfigDuration1 = OpenEnum<typeof ConfigDuration1>;
+type CheckRollover1 = {
+    max?: number | null | undefined;
+    maxPercentage?: number | null | undefined;
+    duration: ConfigDuration1;
+    length: number;
+};
+declare const CheckOnIncrease1: {
+    readonly BillImmediately: "bill_immediately";
+    readonly ProrateImmediately: "prorate_immediately";
+    readonly ProrateNextCycle: "prorate_next_cycle";
+    readonly BillNextCycle: "bill_next_cycle";
+};
+type CheckOnIncrease1 = OpenEnum<typeof CheckOnIncrease1>;
+declare const CheckOnDecrease1: {
+    readonly Prorate: "prorate";
+    readonly ProrateImmediately: "prorate_immediately";
+    readonly ProrateNextCycle: "prorate_next_cycle";
+    readonly None: "none";
+    readonly NoProrations: "no_prorations";
+};
+type CheckOnDecrease1 = OpenEnum<typeof CheckOnDecrease1>;
+type CheckConfig1 = {
+    rollover?: CheckRollover1 | null | undefined;
+    onIncrease?: CheckOnIncrease1 | null | undefined;
+    onDecrease?: CheckOnDecrease1 | null | undefined;
+};
+/**
+ * Product item defining features and pricing within a product
+ */
+type CheckItem1 = {
+    /**
+     * The type of the product item
+     */
+    type?: ProductType1 | null | undefined;
+    /**
+     * The feature ID of the product item. If the item is a fixed price, should be `null`
+     */
+    featureId?: string | null | undefined;
+    /**
+     * Single use features are used once and then depleted, like API calls or credits. Continuous use features are those being used on an ongoing-basis, like storage or seats.
+     */
+    featureType?: FeatureType1 | null | undefined;
+    /**
+     * The amount of usage included for this feature.
+     */
+    includedUsage?: number | string | null | undefined;
+    /**
+     * The reset or billing interval of the product item. If null, feature will have no reset date, and if there's a price, it will be billed one-off.
+     */
+    interval?: CheckInterval1 | null | undefined;
+    /**
+     * The interval count of the product item.
+     */
+    intervalCount?: number | null | undefined;
+    /**
+     * The price of the product item. Should be `null` if tiered pricing is set.
+     */
+    price?: number | null | undefined;
+    /**
+     * Tiered pricing for the product item. Not applicable for fixed price items.
+     */
+    tiers?: Array<any | null> | null | undefined;
+    /**
+     * How tiers are applied: graduated (split across bands) or volume (flat rate for the matched tier). Defaults to graduated.
+     */
+    tierBehavior?: CheckTierBehavior1 | null | undefined;
+    /**
+     * Whether the feature should be prepaid upfront or billed for how much they use end of billing period.
+     */
+    usageModel?: UsageModel1 | null | undefined;
+    /**
+     * The amount per billing unit (eg. $9 / 250 units)
+     */
+    billingUnits?: number | null | undefined;
+    /**
+     * Whether the usage should be reset when the product is enabled.
+     */
+    resetUsageWhenEnabled?: boolean | null | undefined;
+    /**
+     * The entity feature ID of the product item if applicable.
+     */
+    entityFeatureId?: string | null | undefined;
+    /**
+     * The display of the product item.
+     */
+    display?: ProductDisplay1 | null | undefined;
+    /**
+     * Used in customer context. Quantity of the feature the customer has prepaid for.
+     */
+    quantity?: number | null | undefined;
+    /**
+     * Used in customer context. Quantity of the feature the customer will prepay for in the next cycle.
+     */
+    nextCycleQuantity?: number | null | undefined;
+    /**
+     * Configuration for rollover and proration behavior of the feature.
+     */
+    config?: CheckConfig1 | null | undefined;
+};
+/**
+ * The duration type of the free trial
+ */
+declare const FreeTrialDuration1: {
+    readonly Day: "day";
+    readonly Month: "month";
+    readonly Year: "year";
+};
+/**
+ * The duration type of the free trial
+ */
+type FreeTrialDuration1 = OpenEnum<typeof FreeTrialDuration1>;
+type CheckFreeTrial1 = {
+    /**
+     * The duration type of the free trial
+     */
+    duration: FreeTrialDuration1;
+    /**
+     * The length of the duration type specified
+     */
+    length: number;
+    /**
+     * Whether the free trial is limited to one per customer fingerprint
+     */
+    uniqueFingerprint: boolean;
+    /**
+     * Whether the free trial requires a card. If false, the customer can attach the product without going through a checkout flow or having a card on file.
+     */
+    cardRequired: boolean;
+    /**
+     * Used in customer context. Whether the free trial is available for the customer if they were to attach the product.
+     */
+    trialAvailable: boolean | null;
+};
+/**
+ * Scenario for when this product is used in attach flows
+ */
+declare const ProductScenario1: {
+    readonly Scheduled: "scheduled";
+    readonly Active: "active";
+    readonly New: "new";
+    readonly Renew: "renew";
+    readonly Upgrade: "upgrade";
+    readonly UpdatePrepaidQuantity: "update_prepaid_quantity";
+    readonly Downgrade: "downgrade";
+    readonly Cancel: "cancel";
+    readonly Expired: "expired";
+    readonly PastDue: "past_due";
+};
+/**
+ * Scenario for when this product is used in attach flows
+ */
+type ProductScenario1 = OpenEnum<typeof ProductScenario1>;
+type Properties1 = {
+    /**
+     * True if the product has no base price or usage prices
+     */
+    isFree: boolean;
+    /**
+     * True if the product only contains a one-time price
+     */
+    isOneOff: boolean;
+    /**
+     * The billing interval group for recurring products (e.g., 'monthly', 'yearly')
+     */
+    intervalGroup?: string | null | undefined;
+    /**
+     * True if the product includes a free trial
+     */
+    hasTrial?: boolean | null | undefined;
+    /**
+     * True if the product can be updated after creation (only applicable if there are prepaid recurring prices)
+     */
+    updateable?: boolean | null | undefined;
+};
+type Product1 = {
+    /**
+     * The ID of the product you set when creating the product
+     */
+    id: string;
+    /**
+     * The name of the product
+     */
+    name: string;
+    /**
+     * Product group which this product belongs to
+     */
+    group: string | null;
+    /**
+     * The environment of the product
+     */
+    env: CheckEnv1;
+    /**
+     * Whether the product is an add-on and can be purchased alongside other products
+     */
+    isAddOn: boolean;
+    /**
+     * Whether the product is the default product
+     */
+    isDefault: boolean;
+    /**
+     * Whether this product has been archived and is no longer available
+     */
+    archived: boolean;
+    /**
+     * The current version of the product
+     */
+    version: number;
+    /**
+     * The timestamp of when the product was created in milliseconds since epoch
+     */
+    createdAt: number;
+    /**
+     * Array of product items that define the product's features and pricing
+     */
+    items: Array<CheckItem1>;
+    /**
+     * Free trial configuration for this product, if available
+     */
+    freeTrial: CheckFreeTrial1 | null;
+    /**
+     * ID of the base variant this product is derived from
+     */
+    baseVariantId: string | null;
+    /**
+     * Scenario for when this product is used in attach flows
+     */
+    scenario?: ProductScenario1 | undefined;
+    properties?: Properties1 | undefined;
+};
+/**
+ * Upgrade/upsell information when access is denied. Only present if with_preview was true and allowed is false.
+ */
+type Preview1 = {
+    /**
+     * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
+     */
+    scenario: Scenario1;
+    /**
+     * A title suitable for displaying in a paywall or upgrade modal.
+     */
+    title: string;
+    /**
+     * A message explaining why access was denied.
+     */
+    message: string;
+    /**
+     * The ID of the feature that was checked.
+     */
+    featureId: string;
+    /**
+     * The display name of the feature.
+     */
+    featureName: string;
+    /**
+     * Products that would grant access to this feature. Use to display upgrade options.
+     */
+    products: Array<Product1>;
 };
 /**
  * OK
  */
-type CheckResponse = {
+type CheckResponseBody1 = {
     /**
      * Whether the customer is allowed to use the feature. True if they have sufficient balance or the feature is unlimited/boolean.
      */
@@ -2070,12 +2520,13 @@ type CheckResponse = {
     /**
      * The flag associated with this check, if any.
      */
-    flag: Flag | null;
+    flag: Flag1 | null;
     /**
      * Upgrade/upsell information when access is denied. Only present if with_preview was true and allowed is false.
      */
-    preview?: Preview | undefined;
+    preview?: Preview1 | undefined;
 };
+type CheckResponse = CheckResponseBody1 | CheckResponseBody2;
 
 /**
  * The interval at which the balance resets (e.g., 'month', 'day', 'year').
@@ -4886,12 +5337,19 @@ type FinalizeBalanceParams = {
         [k: string]: any;
     } | undefined;
 };
+/**
+ * Accepted. Autumn is experiencing degraded service from a downstream provider, so the finalize request was allowed fail-open.
+ */
+type FinalizeLockResponseBody2 = {
+    success: boolean;
+};
 /**
  * OK
  */
-type FinalizeLockResponse = {
+type FinalizeLockResponseBody1 = {
     success: boolean;
 };
+type FinalizeLockResponse = FinalizeLockResponseBody1 | FinalizeLockResponseBody2;
 
 type GetEntityParams = {
     /**
@@ -10362,10 +10820,41 @@ type TrackParams = {
     } | undefined;
     lock?: TrackLock | undefined;
 };
+/**
+ * Accepted. Autumn is experiencing degraded service from a downstream provider, so the event was accepted for replay and will be tracked as soon as the service is restored.
+ */
+type TrackResponseBody2 = {
+    /**
+     * The ID of the customer whose usage was tracked.
+     */
+    customerId: string;
+    /**
+     * The ID of the entity, if entity-scoped tracking was performed.
+     */
+    entityId?: string | undefined;
+    /**
+     * The event name that was tracked, if event_name was used instead of feature_id.
+     */
+    eventName?: string | undefined;
+    /**
+     * The amount of usage that was recorded.
+     */
+    value: number;
+    /**
+     * The updated balance for the tracked feature. Null if tracking by event_name that affects multiple features.
+     */
+    balance: Balance | null;
+    /**
+     * Map of feature_id to updated balance when tracking by event_name affects multiple features.
+     */
+    balances?: {
+        [k: string]: Balance;
+    } | undefined;
+};
 /**
  * OK
  */
-type TrackResponse = {
+type TrackResponseBody1 = {
     /**
      * The ID of the customer whose usage was tracked.
      */
@@ -10393,6 +10882,7 @@ type TrackResponse = {
         [k: string]: Balance;
     } | undefined;
 };
+type TrackResponse = TrackResponseBody1 | TrackResponseBody2;
 
 /**
  * Target a specific balance by its reset interval. Use when the customer has multiple balances for the same feature with different reset intervals.
@@ -13307,7 +13797,7 @@ declare class Autumn extends ClientSDK {
      * @param lock - Reserve units of a feature upfront by passing a lock_id, then call balances.finalize to confirm or release the hold. (optional)
      * @param withPreview - If true, includes upgrade/upsell information in the response when access is denied. Useful for displaying paywalls. (optional)
      *
-     * @returns Whether access is allowed, plus the current balance for that feature.
+     * @returns Whether access is allowed, plus the current balance for that feature. If Autumn is experiencing degraded service from a downstream provider, the API may return 202 and allow access fail-open.
      */
     check(request: CheckParams, options?: RequestOptions): Promise<CheckResponse>;
     /**
@@ -13334,7 +13824,7 @@ declare class Autumn extends ClientSDK {
      * @param value - The amount of usage to record. Defaults to 1. Use negative values to credit balance (e.g., when removing a seat). (optional)
      * @param properties - Additional properties to attach to this usage event. (optional)
      *
-     * @returns The usage value recorded, with either a single updated balance or a map of updated balances.
+     * @returns The usage value recorded, with either a single updated balance or a map of updated balances. If Autumn is experiencing degraded service from a downstream provider, the API may return 202 after accepting the event for replay so it can be tracked as soon as the service is restored.
      */
     track(request: TrackParams, options?: RequestOptions): Promise<TrackResponse>;
 }