atmn 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/source/compose/builders/builderFunctions.d.ts

@@ -0,0 +1,82 @@
+import type { Plan, PlanFeature } from "../models/planModels.js";
+import type { Feature } from "../models/featureModels.js";
+type PlanInput = Omit<Plan, 'description' | 'add_on' | 'auto_enable' | 'group'> & Partial<Pick<Plan, 'description' | 'add_on' | 'auto_enable' | 'group'>>;
+/**
+ * Define a pricing plan in your Autumn configuration
+ *
+ * @param p - Plan configuration
+ * @returns Plan object for use in autumn.config.ts
+ *
+ * @example
+ * export const pro = plan({
+ *   id: 'pro',
+ *   name: 'Pro Plan',
+ *   description: 'For growing teams',
+ *   features: [
+ *     planFeature({ feature_id: seats.id, included: 10 }),
+ *     planFeature({
+ *       feature_id: messages.id,
+ *       included: 1000,
+ *       reset: { interval: 'month' }
+ *     })
+ *   ],
+ *   price: { amount: 50, interval: 'month' }
+ * });
+ */
+export declare const plan: (params: PlanInput) => Plan;
+/**
+ * Define a feature that can be included in plans
+ *
+ * @param f - Feature configuration
+ * @returns Feature object for use in autumn.config.ts
+ *
+ * @example
+ * // Metered consumable feature (like API calls, tokens)
+ * export const apiCalls = feature({
+ *   id: 'api_calls',
+ *   name: 'API Calls',
+ *   type: 'metered',
+ *   consumable: true
+ * });
+ *
+ * @example
+ * // Metered non-consumable feature (like seats)
+ * export const seats = feature({
+ *   id: 'seats',
+ *   name: 'Team Seats',
+ *   type: 'metered',
+ *   consumable: false
+ * });
+ */
+export declare const feature: (params: Feature) => Feature;
+/**
+ * Include a feature in a plan with specific configuration
+ *
+ * @param config - Feature configuration for this plan
+ * @returns PlanFeature for use in plan's features array
+ *
+ * @example
+ * // Simple included usage
+ * planFeature({
+ *   feature_id: messages.id,
+ *   included: 1000,
+ *   reset: { interval: 'month' }
+ * })
+ *
+ * @example
+ * // Priced feature with tiers
+ * planFeature({
+ *   feature_id: seats.id,
+ *   included: 5,
+ *   price: {
+ *     tiers: [
+ *       { to: 10, amount: 10 },
+ *       { to: 'inf', amount: 8 }
+ *     ],
+ *     interval: 'month',
+ *     billing_method: 'pay_per_use'
+ *   }
+ * })
+ */
+export declare const planFeature: (params: PlanFeature) => PlanFeature;
+export {};

package/dist/source/compose/index.d.ts

@@ -0,0 +1,10 @@
+import { feature, plan, planFeature } from "./builders/builderFunctions.js";
+import type { Feature } from "./models/featureModels.js";
+import type { Plan, PlanFeature, FreeTrial } from "./models/planModels.js";
+export { plan, feature, planFeature };
+export type { Feature, Plan, PlanFeature, FreeTrial, };
+export type Infinity = "infinity";
+export type AutumnConfig = {
+    plans: Plan[];
+    features: Feature[];
+};

package/dist/source/compose/models/featureModels.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod/v4";
+export declare const FeatureSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    event_names: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    credit_schema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        metered_feature_id: z.ZodString;
+        credit_cost: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type FeatureBase = {
+    /** Unique identifier for the feature */
+    id: string;
+    /** Display name for the feature */
+    name: string;
+    /** Event names that trigger this feature */
+    event_names?: string[];
+    /** Credit schema for credit_system features */
+    credit_schema?: Array<{
+        metered_feature_id: string;
+        credit_cost: number;
+    }>;
+};
+/** Boolean feature - no consumable field allowed */
+export type BooleanFeature = FeatureBase & {
+    type: "boolean";
+    consumable?: never;
+};
+/** Metered feature - requires consumable field */
+export type MeteredFeature = FeatureBase & {
+    type: "metered";
+    /** Whether usage is consumed (true) or accumulated (false) */
+    consumable: boolean;
+};
+/** Credit system feature - always consumable */
+export type CreditSystemFeature = FeatureBase & {
+    type: "credit_system";
+    /** Credit systems are always consumable */
+    consumable?: true;
+    /** Required: defines how credits map to metered features */
+    credit_schema: Array<{
+        metered_feature_id: string;
+        credit_cost: number;
+    }>;
+};
+/**
+ * Feature definition with type-safe constraints:
+ * - Boolean features cannot have consumable
+ * - Metered features require consumable (true = single_use style, false = continuous_use style)
+ * - Credit system features are always consumable and require credit_schema
+ */
+export type Feature = BooleanFeature | MeteredFeature | CreditSystemFeature;
+export {};

package/dist/source/compose/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from './planModels.js';
+export * from './featureModels.js';

package/dist/source/compose/models/planModels.d.ts

@@ -0,0 +1,169 @@
+import { z } from "zod/v4";
+export declare const UsageTierSchema: z.ZodObject<{
+    to: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+export declare const PlanFeatureSchema: z.ZodObject<{
+    feature_id: z.ZodString;
+    granted_balance: z.ZodOptional<z.ZodNumber>;
+    unlimited: z.ZodOptional<z.ZodBoolean>;
+    reset: z.ZodOptional<z.ZodObject<{
+        interval: z.ZodUnion<readonly [z.ZodLiteral<"one_off">, z.ZodLiteral<"minute">, z.ZodLiteral<"hour">, z.ZodLiteral<"day">, z.ZodLiteral<"week">, z.ZodLiteral<"month">, z.ZodLiteral<"quarter">, z.ZodLiteral<"year">]>;
+        interval_count: z.ZodOptional<z.ZodNumber>;
+        reset_when_enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    price: z.ZodOptional<z.ZodObject<{
+        amount: z.ZodOptional<z.ZodNumber>;
+        tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            to: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>>;
+        interval: z.ZodUnion<readonly [z.ZodLiteral<"month">, z.ZodLiteral<"quarter">, z.ZodLiteral<"semi_annual">, z.ZodLiteral<"year">]>;
+        interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        usage_model: z.ZodUnion<readonly [z.ZodLiteral<"prepaid">, z.ZodLiteral<"pay_per_use">]>;
+        max_purchase: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    proration: z.ZodOptional<z.ZodObject<{
+        on_increase: z.ZodUnion<readonly [z.ZodLiteral<"prorate">, z.ZodLiteral<"charge_immediately">]>;
+        on_decrease: z.ZodUnion<readonly [z.ZodLiteral<"prorate">, z.ZodLiteral<"refund_immediately">, z.ZodLiteral<"no_action">]>;
+    }, z.core.$strip>>;
+    rollover: z.ZodOptional<z.ZodObject<{
+        max: z.ZodNumber;
+        expiry_duration_type: z.ZodUnion<readonly [z.ZodLiteral<"one_off">, z.ZodLiteral<"minute">, z.ZodLiteral<"hour">, z.ZodLiteral<"day">, z.ZodLiteral<"week">, z.ZodLiteral<"month">, z.ZodLiteral<"quarter">, z.ZodLiteral<"year">]>;
+        expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const FreeTrialSchema: z.ZodObject<{
+    duration_type: z.ZodUnion<readonly [z.ZodLiteral<"day">, z.ZodLiteral<"month">, z.ZodLiteral<"year">]>;
+    duration_length: z.ZodNumber;
+    card_required: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const PlanSchema: z.ZodObject<{
+    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    add_on: z.ZodDefault<z.ZodBoolean>;
+    default: z.ZodDefault<z.ZodBoolean>;
+    price: z.ZodOptional<z.ZodObject<{
+        amount: z.ZodNumber;
+        interval: z.ZodUnion<readonly [z.ZodLiteral<"month">, z.ZodLiteral<"quarter">, z.ZodLiteral<"semi_annual">, z.ZodLiteral<"year">]>;
+    }, z.core.$strip>>;
+    features: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feature_id: z.ZodString;
+        granted_balance: z.ZodOptional<z.ZodNumber>;
+        unlimited: z.ZodOptional<z.ZodBoolean>;
+        reset: z.ZodOptional<z.ZodObject<{
+            interval: z.ZodUnion<readonly [z.ZodLiteral<"one_off">, z.ZodLiteral<"minute">, z.ZodLiteral<"hour">, z.ZodLiteral<"day">, z.ZodLiteral<"week">, z.ZodLiteral<"month">, z.ZodLiteral<"quarter">, z.ZodLiteral<"year">]>;
+            interval_count: z.ZodOptional<z.ZodNumber>;
+            reset_when_enabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        price: z.ZodOptional<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodNumber>;
+            tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                to: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>;
+                amount: z.ZodNumber;
+            }, z.core.$strip>>>;
+            interval: z.ZodUnion<readonly [z.ZodLiteral<"month">, z.ZodLiteral<"quarter">, z.ZodLiteral<"semi_annual">, z.ZodLiteral<"year">]>;
+            interval_count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            billing_units: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            usage_model: z.ZodUnion<readonly [z.ZodLiteral<"prepaid">, z.ZodLiteral<"pay_per_use">]>;
+            max_purchase: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        proration: z.ZodOptional<z.ZodObject<{
+            on_increase: z.ZodUnion<readonly [z.ZodLiteral<"prorate">, z.ZodLiteral<"charge_immediately">]>;
+            on_decrease: z.ZodUnion<readonly [z.ZodLiteral<"prorate">, z.ZodLiteral<"refund_immediately">, z.ZodLiteral<"no_action">]>;
+        }, z.core.$strip>>;
+        rollover: z.ZodOptional<z.ZodObject<{
+            max: z.ZodNumber;
+            expiry_duration_type: z.ZodUnion<readonly [z.ZodLiteral<"one_off">, z.ZodLiteral<"minute">, z.ZodLiteral<"hour">, z.ZodLiteral<"day">, z.ZodLiteral<"week">, z.ZodLiteral<"month">, z.ZodLiteral<"quarter">, z.ZodLiteral<"year">]>;
+            expiry_duration_length: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    free_trial: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        duration_type: z.ZodUnion<readonly [z.ZodLiteral<"day">, z.ZodLiteral<"month">, z.ZodLiteral<"year">]>;
+        duration_length: z.ZodNumber;
+        card_required: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    group: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type ResetInterval = "one_off" | "minute" | "hour" | "day" | "week" | "month" | "quarter" | "year";
+export type BillingInterval = "month" | "quarter" | "semi_annual" | "year";
+export type BillingMethod = "prepaid" | "pay_per_use";
+export type OnIncrease = "prorate" | "charge_immediately";
+export type OnDecrease = "prorate" | "refund_immediately" | "no_action";
+/**
+ * Plan feature configuration with flattened reset fields. Use interval/interval_count at top level.
+ */
+export type PlanFeature = {
+    /** Reference to the feature being configured */
+    feature_id: string;
+    /** Amount of usage included in this plan */
+    included?: number;
+    /** Whether usage is unlimited */
+    unlimited?: boolean;
+    /** How often usage resets (e.g., 'month', 'day') */
+    interval?: ResetInterval;
+    /** Number of intervals between resets (default: 1) */
+    interval_count?: number;
+    /** Whether to carry over existing usage when feature is enabled (default: true) */
+    carry_over_usage?: boolean;
+    /** Pricing configuration for usage-based billing */
+    price?: {
+        /** Flat price per unit in cents */
+        amount?: number;
+        /** Tiered pricing structure based on usage ranges */
+        tiers?: Array<{
+            to: number | "inf";
+            amount: number;
+        }>;
+        /** Number of units per billing cycle */
+        billing_units: number;
+        /** Billing method: 'prepaid' or 'pay_per_use' */
+        billing_method: BillingMethod;
+        /** Maximum purchasable quantity */
+        max_purchase?: number;
+    };
+    /** Proration rules for quantity changes */
+    proration?: {
+        /** Behavior when quantity increases */
+        on_increase: OnIncrease;
+        /** Behavior when quantity decreases */
+        on_decrease: OnDecrease;
+    };
+    /** Rollover policy for unused usage */
+    rollover?: {
+        /** Maximum amount that can roll over (null for unlimited) */
+        max: number | null;
+        /** How long rollover lasts before expiring */
+        expiry_duration_type: ResetInterval;
+        /** Duration length for rollover expiry */
+        expiry_duration_length?: number;
+    };
+};
+export type FreeTrial = z.infer<typeof FreeTrialSchema>;
+export type Plan = {
+    /** Unique identifier for the plan */
+    id: string;
+    /** Display name for the plan */
+    name: string;
+    /** Optional description explaining what this plan offers */
+    description?: string | null;
+    /** Grouping identifier for organizing related plans */
+    group?: string;
+    /** Whether this plan can be purchased alongside other plans */
+    add_on?: boolean;
+    /** Whether to automatically enable this plan for new customers */
+    auto_enable?: boolean;
+    /** Base price for the plan */
+    price?: {
+        /** Price in your currency (e.g., 50 for $50.00) */
+        amount: number;
+        /** Billing frequency */
+        interval: BillingInterval | ResetInterval;
+    };
+    /** Features included with usage limits and pricing */
+    features?: PlanFeature[];
+    /** Free trial period before billing begins */
+    free_trial?: FreeTrial | null;
+};

package/dist/source/index.d.ts

@@ -0,0 +1 @@
+export * from './compose/index.js';

package/dist/source/index.js

@@ -0,0 +1,52 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __promiseAll = (args) => Promise.all(args);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// source/compose/builders/builderFunctions.ts
+var plan = (params) => {
+  return {
+    ...params,
+    description: params.description ?? null,
+    add_on: params.add_on ?? false,
+    auto_enable: params.auto_enable ?? false,
+    group: params.group ?? ""
+  };
+};
+var feature = (params) => {
+  return params;
+};
+var planFeature = (params) => {
+  return params;
+};
+export {
+  planFeature,
+  plan,
+  feature
+};