@revstackhq/core 0.0.0-dev-20260227103607 → 0.0.0-dev-20260228060138

package/dist/index.d.ts

@@ -1,9 +1,5 @@
-/**
- * @file types.ts
- * @description Core type definitions for Revstack's Billing Engine.
- * These types map directly to the PostgreSQL database schema and
- * serve as the contract for "Billing as Code".
- */
+import { z } from 'zod';
+
 /**
  * The type of a feature/entitlement.
  * - 'boolean': On/Off flag (e.g., SSO Access).
@@ -19,7 +15,7 @@ type UnitType = "count" | "bytes" | "seconds" | "tokens" | "requests" | "custom"
 /**
  * How often a feature's usage counter resets.
  */
-type ResetPeriod = "monthly" | "yearly" | "never";
+type ResetPeriod = "daily" | "weekly" | "monthly" | "yearly" | "never";
 /**
  * Billing interval for a plan's price.
  */
@@ -28,7 +24,7 @@ type BillingInterval = "monthly" | "quarterly" | "yearly" | "one_time";
  * The commercial classification of a plan.
  * - 'free': No payment required (e.g., Default Guest Plan, Starter).
  * - 'paid': Requires active payment method.
- * - 'custom': Enterprise / negotiated pricing.
+ * - 'custom': Enterprise / B2B negotiated contracts where there is no strict price array and the checkout should redirect to a "Contact Sales" flow.
  */
 type PlanType = "paid" | "free" | "custom";
 /**
@@ -131,6 +127,8 @@ interface PriceDef {
         /** The quantity of units the overage_amount applies to. */
         overage_unit: number;
     }>;
+    /** Slugs of addons that can be attached to this specific price/interval. */
+    available_addons?: string[];
 }
 /**
  * Full plan definition. Maps to the `plans` table in the database.
@@ -157,8 +155,6 @@ interface PlanDef {
     prices?: PriceDef[];
     /** Feature entitlements included in this plan. */
     features: Record<string, PlanFeatureValue>;
-    /** Slugs of addons that can be attached to this plan. */
-    available_addons?: string[];
 }
 /**
  * Input type for `definePlan()`.
@@ -168,7 +164,6 @@ interface PlanDef {
 type PlanDefInput = Omit<PlanDef, "slug" | "status" | "features"> & {
     status?: PlanStatus;
     features: Record<string, PlanFeatureValue>;
-    available_addons?: string[];
 };
 /**
  * An add-on is a product purchased on top of a subscription.
@@ -183,8 +178,12 @@ interface AddonDef {
     description?: string;
     /** Billing type. */
     type: "recurring" | "one_time";
-    /** Add-on pricing configurations (1:N). */
-    prices?: PriceDef[];
+    /** Price amount in the smallest currency unit (e.g., cents). */
+    amount: number;
+    /** ISO 4217 currency code. */
+    currency: string;
+    /** Billing interval (Required if type === 'recurring'). */
+    billing_interval?: Exclude<BillingInterval, "one_time">;
     /** Feature entitlements this add-on modifies or grants. */
     features: Record<string, AddonFeatureValue>;
 }
@@ -249,49 +248,6 @@ interface RevstackConfig {
     coupons?: DiscountDef[];
 }
 
-/**
- * @file define.ts
- * @description Identity helpers for "Billing as Code" config authoring.
- *
- * These functions return their input unchanged — their sole purpose is to
- * provide autocompletion, type narrowing, and compile-time validation
- * when developers write their `revstack.config.ts`.
- *
- * @example
- * ```typescript
- * import { defineConfig, defineFeature, definePlan } from "@revstackhq/core";
- *
- * const features = {
- *   seats: defineFeature({ name: "Seats", type: "static", unit_type: "count" }),
- *   sso:   defineFeature({ name: "SSO",   type: "boolean", unit_type: "count" }),
- * };
- *
- * export default defineConfig({
- *   features,
- *   plans: {
- *     default: definePlan<typeof features>({
- *       name: "Default",
- *       is_default: true,
- *       is_public: false,
- *       type: "free",
- *       features: {},
- *     }),
- *     pro: definePlan<typeof features>({
- *       name: "Pro",
- *       is_default: false,
- *       is_public: true,
- *       type: "paid",
- *       prices: [{ amount: 2900, currency: "USD", billing_interval: "monthly" }],
- *       features: {
- *         seats: { value_limit: 5, is_hard_limit: true },
- *         sso:   { value_bool: true },
- *       },
- *     }),
- *   },
- * });
- * ```
- */
-
 /**
  * Define a feature with full type inference.
  * Identity function — returns the input as-is.
@@ -332,17 +288,8 @@ declare function definePlan<F extends Record<string, FeatureDefInput> = Record<s
  *
  * @typeParam F - Feature dictionary type for key restriction.
  */
-declare function defineAddon<F extends Record<string, FeatureDefInput> = Record<string, FeatureDefInput>>(config: Omit<AddonDefInput, "features" | "prices"> & {
+declare function defineAddon<F extends Record<string, FeatureDefInput> = Record<string, FeatureDefInput>>(config: Omit<AddonDefInput, "features"> & {
     features: F extends Record<string, FeatureDefInput> ? Partial<Record<keyof F, AddonFeatureValue>> : Record<string, AddonFeatureValue>;
-    prices?: Array<Omit<PriceDef, "overage_configuration"> & {
-        overage_configuration?: F extends Record<string, FeatureDefInput> ? Partial<Record<keyof F, {
-            overage_amount: number;
-            overage_unit: number;
-        }>> : Record<string, {
-            overage_amount: number;
-            overage_unit: number;
-        }>;
-    }>;
 }): AddonDefInput;
 /**
  * Define a discount/coupon with full type inference.
@@ -355,28 +302,6 @@ declare function defineDiscount<T extends DiscountDef>(config: T): T;
  */
 declare function defineConfig<T extends RevstackConfig>(config: T): T;
 
-/**
- * @file engine.ts
- * @description The Entitlement Engine — the logic core of Revstack.
- *
- * Determines if a user can access a feature based on their active Plan,
- * purchased Add-ons, and subscription payment status. All decisions are
- * pure, stateless computations with no side effects.
- *
- * @example
- * ```typescript
- * import { EntitlementEngine } from "@revstackhq/core";
- *
- * const engine = new EntitlementEngine(plan, addons, "active");
- *
- * // Single check
- * const result = engine.check("seats", 4);
- *
- * // Batch check
- * const results = engine.checkBatch({ seats: 4, ai_tokens: 12000 });
- * ```
- */
-
 /**
  * The Entitlement Engine — evaluates feature access for a single customer.
  *
@@ -420,24 +345,6 @@ declare class EntitlementEngine {
     checkBatch(usages: Record<string, number>): Record<string, CheckResult>;
 }
 
-/**
- * @file validator.ts
- * @description Runtime validation for Revstack billing configurations.
- *
- * Validates the business logic invariants of a `RevstackConfig` object
- * before it is synced to the backend. Catches misconfigurations early
- * that TypeScript's type system cannot enforce (e.g., referencing
- * undefined features, negative prices, duplicate slugs).
- *
- * @example
- * ```typescript
- * import { validateConfig, defineConfig } from "@revstackhq/core";
- *
- * const config = defineConfig({ features: {}, plans: {} });
- * validateConfig(config); // throws RevstackValidationError if invalid
- * ```
- */
-
 /**
  * Thrown when `validateConfig()` detects one or more invalid business
  * logic rules in a billing configuration.
@@ -457,12 +364,366 @@ declare class RevstackValidationError extends Error {
  * Checks the following invariants:
  * 1. **Default plan** — Exactly one plan has `is_default: true`.
  * 2. **Feature references** — Plans/addons only reference features defined in `config.features`.
- * 3. **Non-negative pricing** — All price amounts and limits are ≥ 0.
- * 4. **Discount bounds** — Percentage discounts have values in [0, 100].
  *
  * @param config - The billing configuration to validate.
  * @throws {RevstackValidationError} If any violations are found.
  */
 declare function validateConfig(config: RevstackConfig): void;
 
-export { type AddonDef, type AddonDefInput, type AddonFeatureValue, type BillingInterval, type CheckResult, type DiscountDef, type DiscountDuration, type DiscountType, EntitlementEngine, type FeatureDef, type FeatureDefInput, type FeatureType, type PlanDef, type PlanDefInput, type PlanFeatureValue, type PlanStatus, type PlanType, type PriceDef, type ResetPeriod, type RevstackConfig, RevstackValidationError, type SubscriptionStatus, type UnitType, defineAddon, defineConfig, defineDiscount, defineFeature, definePlan, validateConfig };
+declare const FeatureTypeSchema: z.ZodEnum<{
+    boolean: "boolean";
+    static: "static";
+    metered: "metered";
+}>;
+declare const UnitTypeSchema: z.ZodEnum<{
+    count: "count";
+    bytes: "bytes";
+    seconds: "seconds";
+    tokens: "tokens";
+    requests: "requests";
+    custom: "custom";
+}>;
+declare const ResetPeriodSchema: z.ZodEnum<{
+    daily: "daily";
+    weekly: "weekly";
+    monthly: "monthly";
+    yearly: "yearly";
+    never: "never";
+}>;
+declare const BillingIntervalSchema: z.ZodEnum<{
+    monthly: "monthly";
+    yearly: "yearly";
+    quarterly: "quarterly";
+    one_time: "one_time";
+}>;
+declare const PlanTypeSchema: z.ZodEnum<{
+    custom: "custom";
+    paid: "paid";
+    free: "free";
+}>;
+declare const PlanStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    active: "active";
+    archived: "archived";
+}>;
+declare const SubscriptionStatusSchema: z.ZodEnum<{
+    active: "active";
+    trialing: "trialing";
+    past_due: "past_due";
+    canceled: "canceled";
+    paused: "paused";
+}>;
+declare const FeatureDefInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        boolean: "boolean";
+        static: "static";
+        metered: "metered";
+    }>;
+    unit_type: z.ZodEnum<{
+        count: "count";
+        bytes: "bytes";
+        seconds: "seconds";
+        tokens: "tokens";
+        requests: "requests";
+        custom: "custom";
+    }>;
+}, z.core.$strip>;
+declare const PlanFeatureValueSchema: z.ZodObject<{
+    value_limit: z.ZodOptional<z.ZodNumber>;
+    value_bool: z.ZodOptional<z.ZodBoolean>;
+    value_text: z.ZodOptional<z.ZodString>;
+    is_hard_limit: z.ZodOptional<z.ZodBoolean>;
+    reset_period: z.ZodOptional<z.ZodEnum<{
+        daily: "daily";
+        weekly: "weekly";
+        monthly: "monthly";
+        yearly: "yearly";
+        never: "never";
+    }>>;
+}, z.core.$strip>;
+declare const AddonFeatureValueSchema: z.ZodObject<{
+    value_limit: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodEnum<{
+        increment: "increment";
+        set: "set";
+    }>>;
+    has_access: z.ZodOptional<z.ZodBoolean>;
+    is_hard_limit: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const OverageConfigurationSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    overage_amount: z.ZodNumber;
+    overage_unit: z.ZodNumber;
+}, z.core.$strip>>;
+declare const PriceDefSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    billing_interval: z.ZodEnum<{
+        monthly: "monthly";
+        yearly: "yearly";
+        quarterly: "quarterly";
+        one_time: "one_time";
+    }>;
+    trial_period_days: z.ZodOptional<z.ZodNumber>;
+    is_active: z.ZodOptional<z.ZodBoolean>;
+    overage_configuration: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        overage_amount: z.ZodNumber;
+        overage_unit: z.ZodNumber;
+    }, z.core.$strip>>>;
+    available_addons: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const PlanDefInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    is_default: z.ZodBoolean;
+    is_public: z.ZodBoolean;
+    type: z.ZodEnum<{
+        custom: "custom";
+        paid: "paid";
+        free: "free";
+    }>;
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        active: "active";
+        archived: "archived";
+    }>>>;
+    prices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        billing_interval: z.ZodEnum<{
+            monthly: "monthly";
+            yearly: "yearly";
+            quarterly: "quarterly";
+            one_time: "one_time";
+        }>;
+        trial_period_days: z.ZodOptional<z.ZodNumber>;
+        is_active: z.ZodOptional<z.ZodBoolean>;
+        overage_configuration: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            overage_amount: z.ZodNumber;
+            overage_unit: z.ZodNumber;
+        }, z.core.$strip>>>;
+        available_addons: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    features: z.ZodRecord<z.ZodString, z.ZodObject<{
+        value_limit: z.ZodOptional<z.ZodNumber>;
+        value_bool: z.ZodOptional<z.ZodBoolean>;
+        value_text: z.ZodOptional<z.ZodString>;
+        is_hard_limit: z.ZodOptional<z.ZodBoolean>;
+        reset_period: z.ZodOptional<z.ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            yearly: "yearly";
+            never: "never";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const AddonDefInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    features: z.ZodRecord<z.ZodString, z.ZodObject<{
+        value_limit: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodOptional<z.ZodEnum<{
+            increment: "increment";
+            set: "set";
+        }>>;
+        has_access: z.ZodOptional<z.ZodBoolean>;
+        is_hard_limit: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"recurring">;
+    billing_interval: z.ZodEnum<{
+        monthly: "monthly";
+        yearly: "yearly";
+        quarterly: "quarterly";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    features: z.ZodRecord<z.ZodString, z.ZodObject<{
+        value_limit: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodOptional<z.ZodEnum<{
+            increment: "increment";
+            set: "set";
+        }>>;
+        has_access: z.ZodOptional<z.ZodBoolean>;
+        is_hard_limit: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"one_time">;
+    billing_interval: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>], "type">;
+declare const DiscountTypeSchema: z.ZodEnum<{
+    amount: "amount";
+    percent: "percent";
+}>;
+declare const DiscountDurationSchema: z.ZodEnum<{
+    once: "once";
+    forever: "forever";
+    repeating: "repeating";
+}>;
+declare const DiscountDefSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    duration: z.ZodEnum<{
+        once: "once";
+        forever: "forever";
+        repeating: "repeating";
+    }>;
+    duration_in_months: z.ZodOptional<z.ZodNumber>;
+    applies_to_plans: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    max_redemptions: z.ZodOptional<z.ZodNumber>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"percent">;
+    value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    duration: z.ZodEnum<{
+        once: "once";
+        forever: "forever";
+        repeating: "repeating";
+    }>;
+    duration_in_months: z.ZodOptional<z.ZodNumber>;
+    applies_to_plans: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    max_redemptions: z.ZodOptional<z.ZodNumber>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"amount">;
+    value: z.ZodNumber;
+}, z.core.$strip>], "type">;
+declare const RevstackConfigSchema: z.ZodObject<{
+    features: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            boolean: "boolean";
+            static: "static";
+            metered: "metered";
+        }>;
+        unit_type: z.ZodEnum<{
+            count: "count";
+            bytes: "bytes";
+            seconds: "seconds";
+            tokens: "tokens";
+            requests: "requests";
+            custom: "custom";
+        }>;
+    }, z.core.$strip>>;
+    plans: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        is_default: z.ZodBoolean;
+        is_public: z.ZodBoolean;
+        type: z.ZodEnum<{
+            custom: "custom";
+            paid: "paid";
+            free: "free";
+        }>;
+        status: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            draft: "draft";
+            active: "active";
+            archived: "archived";
+        }>>>;
+        prices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            amount: z.ZodNumber;
+            currency: z.ZodString;
+            billing_interval: z.ZodEnum<{
+                monthly: "monthly";
+                yearly: "yearly";
+                quarterly: "quarterly";
+                one_time: "one_time";
+            }>;
+            trial_period_days: z.ZodOptional<z.ZodNumber>;
+            is_active: z.ZodOptional<z.ZodBoolean>;
+            overage_configuration: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                overage_amount: z.ZodNumber;
+                overage_unit: z.ZodNumber;
+            }, z.core.$strip>>>;
+            available_addons: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        features: z.ZodRecord<z.ZodString, z.ZodObject<{
+            value_limit: z.ZodOptional<z.ZodNumber>;
+            value_bool: z.ZodOptional<z.ZodBoolean>;
+            value_text: z.ZodOptional<z.ZodString>;
+            is_hard_limit: z.ZodOptional<z.ZodBoolean>;
+            reset_period: z.ZodOptional<z.ZodEnum<{
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                yearly: "yearly";
+                never: "never";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    addons: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        features: z.ZodRecord<z.ZodString, z.ZodObject<{
+            value_limit: z.ZodOptional<z.ZodNumber>;
+            type: z.ZodOptional<z.ZodEnum<{
+                increment: "increment";
+                set: "set";
+            }>>;
+            has_access: z.ZodOptional<z.ZodBoolean>;
+            is_hard_limit: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"recurring">;
+        billing_interval: z.ZodEnum<{
+            monthly: "monthly";
+            yearly: "yearly";
+            quarterly: "quarterly";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        features: z.ZodRecord<z.ZodString, z.ZodObject<{
+            value_limit: z.ZodOptional<z.ZodNumber>;
+            type: z.ZodOptional<z.ZodEnum<{
+                increment: "increment";
+                set: "set";
+            }>>;
+            has_access: z.ZodOptional<z.ZodBoolean>;
+            is_hard_limit: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"one_time">;
+        billing_interval: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>], "type">>>;
+    coupons: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        code: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        duration: z.ZodEnum<{
+            once: "once";
+            forever: "forever";
+            repeating: "repeating";
+        }>;
+        duration_in_months: z.ZodOptional<z.ZodNumber>;
+        applies_to_plans: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        max_redemptions: z.ZodOptional<z.ZodNumber>;
+        expires_at: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"percent">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        duration: z.ZodEnum<{
+            once: "once";
+            forever: "forever";
+            repeating: "repeating";
+        }>;
+        duration_in_months: z.ZodOptional<z.ZodNumber>;
+        applies_to_plans: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        max_redemptions: z.ZodOptional<z.ZodNumber>;
+        expires_at: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"amount">;
+        value: z.ZodNumber;
+    }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+
+export { type AddonDef, type AddonDefInput, AddonDefInputSchema, type AddonFeatureValue, AddonFeatureValueSchema, type BillingInterval, BillingIntervalSchema, type CheckResult, type DiscountDef, DiscountDefSchema, type DiscountDuration, DiscountDurationSchema, type DiscountType, DiscountTypeSchema, EntitlementEngine, type FeatureDef, type FeatureDefInput, FeatureDefInputSchema, type FeatureType, FeatureTypeSchema, OverageConfigurationSchema, type PlanDef, type PlanDefInput, PlanDefInputSchema, type PlanFeatureValue, PlanFeatureValueSchema, type PlanStatus, PlanStatusSchema, type PlanType, PlanTypeSchema, type PriceDef, PriceDefSchema, type ResetPeriod, ResetPeriodSchema, type RevstackConfig, RevstackConfigSchema, RevstackValidationError, type SubscriptionStatus, SubscriptionStatusSchema, type UnitType, UnitTypeSchema, defineAddon, defineConfig, defineDiscount, defineFeature, definePlan, validateConfig };

package/dist/index.js

@@ -171,50 +171,43 @@ function validateFeatureReferences(productType, productSlug, features, knownFeat
     }
   }
 }
-function validatePricing(productType, slug, prices, configFeatures, errors) {
+function validatePriceAddonIntervals(planSlug, priceIndex, price, configAddons, errors) {
+  if (!price.available_addons) return;
+  for (const addonSlug of price.available_addons) {
+    const addon = configAddons?.[addonSlug];
+    if (!addon) {
+      errors.push(
+        `Plan "${planSlug}" price references undefined addon "${addonSlug}".`
+      );
+      continue;
+    }
+    if (addon.type === "recurring" && addon.billing_interval !== price.billing_interval) {
+      errors.push(
+        `Interval Mismatch: Plan '${planSlug}' price is '${price.billing_interval}', but Addon '${addonSlug}' is '${addon.billing_interval}'. Recurring addons must match the price's billing interval.`
+      );
+    }
+  }
+}
+function validatePlanPricing(slug, prices, config, errors) {
+  const configFeatures = config.features;
   if (prices) {
-    for (const price of prices) {
-      if (price.amount < 0) {
-        errors.push(
-          `${productType} "${slug}" has a negative price amount (${price.amount}).`
-        );
-      }
+    prices.forEach((price, index) => {
       if (price.overage_configuration) {
-        for (const [featureSlug, overage] of Object.entries(
-          price.overage_configuration
-        )) {
+        for (const featureSlug of Object.keys(price.overage_configuration)) {
           const feature = configFeatures[featureSlug];
           if (!feature) {
             errors.push(
-              `${productType} "${slug}" overage_configuration references undefined feature "${featureSlug}".`
+              `Plan "${slug}" overage_configuration references undefined feature "${featureSlug}".`
             );
           } else if (feature.type !== "metered") {
             errors.push(
-              `${productType} "${slug}" configures overage for feature "${featureSlug}", which is not of type 'metered'.`
-            );
-          }
-          if (overage.overage_amount < 0) {
-            errors.push(
-              `${productType} "${slug}" overage_amount for feature "${featureSlug}" must be >= 0.`
-            );
-          }
-          if (overage.overage_unit <= 0) {
-            errors.push(
-              `${productType} "${slug}" overage_unit for feature "${featureSlug}" must be > 0.`
+              `Plan "${slug}" configures overage for feature "${featureSlug}", which is not of type 'metered'.`
             );
           }
         }
       }
-    }
-  }
-}
-function validateFeatureLimits(productType, slug, features, errors) {
-  for (const [featureSlug, value] of Object.entries(features)) {
-    if (value.value_limit !== void 0 && value.value_limit < 0) {
-      errors.push(
-        `${productType} "${slug}" \u2192 feature "${featureSlug}" has a negative value_limit (${value.value_limit}).`
-      );
-    }
+      validatePriceAddonIntervals(slug, index, price, config.addons, errors);
+    });
   }
 }
 function validateDefaultPlan(config, errors) {
@@ -232,21 +225,6 @@ function validateDefaultPlan(config, errors) {
     );
   }
 }
-function validateDiscounts(config, errors) {
-  if (!config.coupons) return;
-  for (const coupon of config.coupons) {
-    if (coupon.type === "percent" && (coupon.value < 0 || coupon.value > 100)) {
-      errors.push(
-        `Discount "${coupon.code}" has an invalid percentage value (${coupon.value}). Must be 0\u2013100.`
-      );
-    }
-    if (coupon.type === "amount" && coupon.value < 0) {
-      errors.push(
-        `Discount "${coupon.code}" has a negative amount value (${coupon.value}).`
-      );
-    }
-  }
-}
 function validateConfig(config) {
   const errors = [];
   const knownFeatureSlugs = new Set(Object.keys(config.features));
@@ -259,8 +237,7 @@ function validateConfig(config) {
       knownFeatureSlugs,
       errors
     );
-    validatePricing("Plan", slug, plan.prices, config.features, errors);
-    validateFeatureLimits("Plan", slug, plan.features, errors);
+    validatePlanPricing(slug, plan.prices, config, errors);
   }
   if (config.addons) {
     for (const [slug, addon] of Object.entries(config.addons)) {
@@ -271,18 +248,161 @@ function validateConfig(config) {
         knownFeatureSlugs,
         errors
       );
-      validatePricing("Addon", slug, addon.prices, config.features, errors);
-      validateFeatureLimits("Addon", slug, addon.features, errors);
     }
   }
-  validateDiscounts(config, errors);
   if (errors.length > 0) {
     throw new RevstackValidationError(errors);
   }
 }
+
+// src/schema.ts
+import { z } from "zod";
+var FeatureTypeSchema = z.enum(["boolean", "static", "metered"]);
+var UnitTypeSchema = z.enum([
+  "count",
+  "bytes",
+  "seconds",
+  "tokens",
+  "requests",
+  "custom"
+]);
+var ResetPeriodSchema = z.enum([
+  "daily",
+  "weekly",
+  "monthly",
+  "yearly",
+  "never"
+]);
+var BillingIntervalSchema = z.enum([
+  "monthly",
+  "quarterly",
+  "yearly",
+  "one_time"
+]);
+var PlanTypeSchema = z.enum(["paid", "free", "custom"]);
+var PlanStatusSchema = z.enum(["draft", "active", "archived"]);
+var SubscriptionStatusSchema = z.enum([
+  "active",
+  "trialing",
+  "past_due",
+  "canceled",
+  "paused"
+]);
+var FeatureDefInputSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  type: FeatureTypeSchema,
+  unit_type: UnitTypeSchema
+});
+var PlanFeatureValueSchema = z.object({
+  value_limit: z.number().min(0).optional(),
+  value_bool: z.boolean().optional(),
+  value_text: z.string().optional(),
+  is_hard_limit: z.boolean().optional(),
+  reset_period: ResetPeriodSchema.optional()
+});
+var AddonFeatureValueSchema = z.object({
+  value_limit: z.number().min(0).optional(),
+  type: z.enum(["increment", "set"]).optional(),
+  has_access: z.boolean().optional(),
+  is_hard_limit: z.boolean().optional()
+});
+var OverageConfigurationSchema = z.record(
+  z.string(),
+  z.object({
+    overage_amount: z.number().min(0),
+    overage_unit: z.number().min(1)
+  })
+);
+var PriceDefSchema = z.object({
+  amount: z.number().min(0),
+  currency: z.string(),
+  billing_interval: BillingIntervalSchema,
+  trial_period_days: z.number().min(0).optional(),
+  is_active: z.boolean().optional(),
+  overage_configuration: OverageConfigurationSchema.optional(),
+  available_addons: z.array(z.string()).optional()
+});
+var PlanDefInputSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  is_default: z.boolean(),
+  is_public: z.boolean(),
+  type: PlanTypeSchema,
+  status: PlanStatusSchema.optional().default("active"),
+  prices: z.array(PriceDefSchema).optional(),
+  features: z.record(z.string(), PlanFeatureValueSchema)
+});
+var BaseAddonDefInput = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  amount: z.number().min(0),
+  currency: z.string(),
+  features: z.record(z.string(), AddonFeatureValueSchema)
+});
+var RecurringAddonSchema = BaseAddonDefInput.extend({
+  type: z.literal("recurring"),
+  billing_interval: z.enum(["monthly", "quarterly", "yearly"])
+});
+var OneTimeAddonSchema = BaseAddonDefInput.extend({
+  type: z.literal("one_time"),
+  // omitted/ignored for one_time
+  billing_interval: z.any().optional()
+});
+var AddonDefInputSchema = z.discriminatedUnion("type", [
+  RecurringAddonSchema,
+  OneTimeAddonSchema
+]);
+var DiscountTypeSchema = z.enum(["percent", "amount"]);
+var DiscountDurationSchema = z.enum(["once", "forever", "repeating"]);
+var BaseDiscountDef = z.object({
+  code: z.string(),
+  name: z.string().optional(),
+  duration: DiscountDurationSchema,
+  duration_in_months: z.number().min(1).optional(),
+  applies_to_plans: z.array(z.string()).optional(),
+  max_redemptions: z.number().min(1).optional(),
+  expires_at: z.string().datetime().optional()
+});
+var PercentDiscountSchema = BaseDiscountDef.extend({
+  type: z.literal("percent"),
+  value: z.number().min(0).max(100)
+});
+var AmountDiscountSchema = BaseDiscountDef.extend({
+  type: z.literal("amount"),
+  value: z.number().min(0)
+});
+var DiscountDefSchema = z.discriminatedUnion("type", [
+  PercentDiscountSchema,
+  AmountDiscountSchema
+]);
+var RevstackConfigSchema = z.object({
+  features: z.record(z.string(), FeatureDefInputSchema),
+  plans: z.record(z.string(), PlanDefInputSchema),
+  addons: z.record(z.string(), AddonDefInputSchema).optional(),
+  coupons: z.array(DiscountDefSchema).optional()
+});
 export {
+  AddonDefInputSchema,
+  AddonFeatureValueSchema,
+  BillingIntervalSchema,
+  DiscountDefSchema,
+  DiscountDurationSchema,
+  DiscountTypeSchema,
   EntitlementEngine,
+  FeatureDefInputSchema,
+  FeatureTypeSchema,
+  OverageConfigurationSchema,
+  PlanDefInputSchema,
+  PlanFeatureValueSchema,
+  PlanStatusSchema,
+  PlanTypeSchema,
+  PriceDefSchema,
+  ResetPeriodSchema,
+  RevstackConfigSchema,
   RevstackValidationError,
+  SubscriptionStatusSchema,
+  UnitTypeSchema,
   defineAddon,
   defineConfig,
   defineDiscount,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revstackhq/core",
-  "version": "0.0.0-dev-20260227103607",
+  "version": "0.0.0-dev-20260228060138",
   "private": false,
   "license": "FSL-1.1-MIT",
   "type": "module",
@@ -31,6 +31,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",