atmn 1.0.1 → 1.0.2

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

@@ -0,0 +1,83 @@
+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,
+ *   reset: { interval: 'month' },
+ *   price: {
+ *     tiers: [
+ *       { to: 10, amount: 10 },
+ *       { to: 'inf', amount: 8 }
+ *     ],
+ *     billing_method: 'usage_based',
+ *     billing_units: 1
+ *   }
+ * })
+ */
+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,228 @@
+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<"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<"month">, z.ZodLiteral<"forever">]>;
+        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<"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<"month">, z.ZodLiteral<"forever">]>;
+            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" | "hour" | "day" | "week" | "month" | "quarter" | "year";
+export type RolloverExpiryDurationType = "month" | "forever";
+export type BillingInterval = "month" | "quarter" | "semi_annual" | "year";
+export type BillingMethod = "prepaid" | "usage_based";
+export type OnIncrease = "prorate" | "charge_immediately";
+export type OnDecrease = "prorate" | "refund_immediately" | "no_action";
+type ResetConfig = {
+    /** How often usage resets (e.g., 'month', 'day') */
+    interval: ResetInterval;
+    /** Number of intervals between resets (default: 1) */
+    interval_count?: number;
+};
+type ProrationConfig = {
+    /** Behavior when quantity increases */
+    on_increase: OnIncrease;
+    /** Behavior when quantity decreases */
+    on_decrease: OnDecrease;
+};
+type RolloverConfig = {
+    /** Maximum amount that can roll over (null for unlimited) */
+    max: number | null;
+    /** How long rollover lasts before expiring */
+    expiry_duration_type: RolloverExpiryDurationType;
+    /** Duration length for rollover expiry */
+    expiry_duration_length?: number;
+};
+type PlanFeatureBaseFields = {
+    /** Reference to the feature being configured */
+    feature_id: string;
+    /** Amount of usage included in this plan */
+    included?: number;
+    /** Whether usage is unlimited */
+    unlimited?: boolean;
+    /** Proration rules for quantity changes */
+    proration?: ProrationConfig;
+    /** Rollover policy for unused usage */
+    rollover?: RolloverConfig;
+};
+type PriceWithoutInterval = {
+    /** Flat price per unit */
+    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 'usage_based' */
+    billing_method: BillingMethod;
+    /** Maximum purchasable quantity */
+    max_purchase?: number;
+    /** Cannot have price.interval when using top-level reset */
+    interval?: never;
+    interval_count?: never;
+};
+type PriceWithInterval = {
+    /** Flat price per unit */
+    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 'usage_based' */
+    billing_method: BillingMethod;
+    /** Maximum purchasable quantity */
+    max_purchase?: number;
+    /** Billing interval (e.g., 'month', 'day') */
+    interval: ResetInterval;
+    /** Number of intervals between billing cycles (default: 1) */
+    interval_count?: number;
+};
+/**
+ * Plan feature with top-level reset configuration.
+ * Use this for free allocations or features that reset but aren't priced per-use.
+ */
+export type PlanFeatureWithReset = PlanFeatureBaseFields & {
+    /** Reset configuration for usage limits */
+    reset: ResetConfig;
+    /** Optional pricing (cannot have price.interval when using top-level reset) */
+    price?: PriceWithoutInterval;
+};
+/**
+ * Plan feature with pricing that includes interval configuration.
+ * Use this for usage-based pricing where interval determines billing cycle.
+ */
+export type PlanFeatureWithPriceInterval = PlanFeatureBaseFields & {
+    /** Cannot have top-level reset when using price.interval */
+    reset?: never;
+    /** Pricing configuration with billing interval */
+    price: PriceWithInterval;
+};
+/**
+ * Plan feature without any reset configuration.
+ * Use this for continuous-use features (like seats) that don't reset.
+ */
+export type PlanFeatureNoReset = PlanFeatureBaseFields & {
+    /** No reset for continuous-use features */
+    reset?: never;
+    /** Optional pricing without interval */
+    price?: PriceWithoutInterval;
+};
+/**
+ * Plan feature configuration with mutually exclusive reset patterns:
+ * - PlanFeatureWithReset: Top-level reset (for free allocations)
+ * - PlanFeatureWithPriceInterval: price.interval (for usage-based pricing billing cycle)
+ * - PlanFeatureNoReset: No reset (for continuous-use features like seats)
+ */
+export type PlanFeature = PlanFeatureWithReset | PlanFeatureWithPriceInterval | PlanFeatureNoReset;
+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;
+};
+export {};

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
+};