atmn 0.0.21 → 0.0.23

package/dist/commands/init.d.ts

@@ -1 +1,3 @@
-export default function Init(): Promise<void>;
+export default function Init({ config }: {
+    config: any;
+}): Promise<void>;

package/dist/commands/pull.d.ts

@@ -1,3 +1,3 @@
-export default function Pull(options?: {
-    archived?: boolean;
+export default function Pull({ config }: {
+    config: any;
 }): Promise<void>;

package/dist/commands/push.d.ts

@@ -1,10 +1,5 @@
-import type { Feature, Product } from '../compose/index.js';
 export default function Push({ config, yes, prod, }: {
-    config: {
-        features: Feature[];
-        products: Product[];
-        env: string;
-    };
+    config: any;
     yes: boolean;
     prod: boolean;
 }): Promise<void>;

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

@@ -1,5 +1,5 @@
-import type { Feature, Product } from "../models/composeModels.js";
-import type { ProductItem, ProductItemInterval, UsageModel } from "../models/productItemModels.js";
+import { Product, Feature } from '../models/composeModels.js';
+import { ProductItem, ProductItemInterval, UsageModel } from '../models/productItemModels.js';
 export declare const product: (p: Product) => {
     id: string;
     name: string;
@@ -35,7 +35,6 @@ export declare const feature: (f: Feature) => {
         metered_feature_id: string;
         credit_cost: number;
     }[] | undefined;
-    archived?: boolean | null | undefined;
 };
 export declare const featureItem: ({ feature_id, included_usage, interval, reset_usage_when_enabled, entity_feature_id, }: {
     feature_id: string;

package/dist/compose/index.d.ts

@@ -1,9 +1,9 @@
-import { feature, featureItem, pricedFeatureItem, priceItem, product } from "./builders/builderFunctions.js";
-import type { Feature, Product } from "./models/composeModels.js";
-import type { ProductItem } from "./models/productItemModels.js";
+import { product, priceItem, feature, featureItem, pricedFeatureItem } from './builders/builderFunctions.js';
+import { Feature, Product } from './models/composeModels.js';
+import { ProductItem } from './models/productItemModels.js';
 export { product, priceItem, feature, featureItem, pricedFeatureItem };
 export type { Feature, Product, ProductItem };
-export type Infinity = "infinity";
+export type Infinity = 'infinity';
 export type AutumnConfig = {
     products: Product[];
     features: Feature[];

package/dist/compose/models/composeModels.d.ts

@@ -68,7 +68,6 @@ export declare const FeatureSchema: z.ZodObject<{
         metered_feature_id: z.ZodString;
         credit_cost: z.ZodNumber;
     }, z.core.$strip>>>;
-    archived: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
 }, z.core.$strip>;
 export type Feature = z.infer<typeof FeatureSchema>;
 export type Product = z.infer<typeof ProductSchema>;

package/dist/constants.d.ts

@@ -1,3 +1,3 @@
-export declare const FRONTEND_URL = "http://app.useautumn.com";
-export declare const BACKEND_URL = "https://api.useautumn.com";
+export declare const FRONTEND_URL = "http://localhost:3000";
+export declare const BACKEND_URL = "http://localhost:8080";
 export declare const DEFAULT_CONFIG = "import {\n\tfeature,\n\tproduct,\n\tpriceItem,\n\tfeatureItem,\n\tpricedFeatureItem,\n} from 'atmn';\n\nexport const seats = feature({\n\tid: 'seats',\n\tname: 'Seats',\n\ttype: 'continuous_use',\n});\n\nexport const messages = feature({\n\tid: 'messages',\n\tname: 'Messages',\n\ttype: 'single_use',\n});\n\nexport const pro = product({\n\tid: 'pro',\n\tname: 'Pro',\n\titems: [\n\t\t// 500 messages per month\n\t\tfeatureItem({\n\t\t\tfeature_id: messages.id,\n\t\t\tincluded_usage: 500,\n\t\t\tinterval: 'month',\n\t\t}),\n\n\t\t// $10 per seat per month\n\t\tpricedFeatureItem({\n\t\t\tfeature_id: seats.id,\n\t\t\tprice: 10,\n\t\t\tinterval: 'month',\n\t\t}),\n\n\t\t// $50 / month\n\t\tpriceItem({\n\t\t\tprice: 50,\n\t\t\tinterval: 'month',\n\t\t}),\n\t],\n});\n";

package/dist/core/api.d.ts

@@ -1,37 +1,30 @@
-export declare function request({ method, base, path, data, headers, customAuth, throwOnError, secretKey, queryParams, }: {
+export declare function request({ method, base, path, data, headers, customAuth, throwOnError, secretKey, }: {
     method: string;
     base: string;
     path: string;
-    data?: Record<string, unknown>;
-    headers?: Record<string, string>;
+    data?: any;
+    headers?: any;
     customAuth?: string;
     throwOnError?: boolean;
     secretKey?: string;
-    queryParams?: Record<string, string>;
 }): Promise<any>;
 export declare function internalRequest({ method, path, data, headers, customAuth, }: {
     method: string;
     path: string;
-    data?: Record<string, unknown>;
-    headers?: Record<string, string>;
+    data?: any;
+    headers?: any;
     customAuth?: string;
 }): Promise<any>;
-export declare function externalRequest({ method, path, data, headers, customAuth, throwOnError, queryParams, }: {
+export declare function externalRequest({ method, path, data, headers, customAuth, throwOnError, }: {
     method: string;
     path: string;
-    data?: Record<string, unknown>;
-    headers?: Record<string, string>;
+    data?: any;
+    headers?: any;
     customAuth?: string;
     throwOnError?: boolean;
-    queryParams?: Record<string, any>;
-}): Promise<any>;
-export declare function deleteFeature({ id }: {
-    id: string;
-}): Promise<any>;
-export declare function deleteProduct({ id, allVersions, }: {
-    id: string;
-    allVersions?: boolean;
 }): Promise<any>;
+export declare function deleteFeature(id: string): Promise<any>;
+export declare function deleteProduct(id: string): Promise<any>;
 export declare function updateCLIStripeKeys({ stripeSecretKey, autumnSecretKey, }: {
     stripeSecretKey: string;
     autumnSecretKey: string;

package/dist/core/builders/features.d.ts

@@ -0,0 +1,2 @@
+import { Feature } from '../../compose/index.js';
+export declare function featureBuilder(feature: Feature): string;

package/dist/core/builders/productBuilder.d.ts

@@ -5,10 +5,6 @@ export declare function productBuilder({ product, features, }: {
     product: Product;
     features: Feature[];
 }): string;
-export declare const getFeatureIdStr: ({ featureId, features, }: {
-    featureId: string;
-    features: Feature[];
-}) => string;
 export declare function pricedFeatureItemBuilder({ item, features, }: {
     item: ProductItem;
     features: Feature[];

package/dist/core/builders/products.d.ts

@@ -0,0 +1,18 @@
+import { ProductItem, Product, Feature } from '../../compose/index.js';
+export declare function importBuilder(): string;
+export declare function exportBuilder(productIds: string[], featureIds: string[]): string;
+export declare function productBuilder({ product, features, }: {
+    product: Product;
+    features: Feature[];
+}): string;
+export declare function pricedFeatureItemBuilder({ item, features, }: {
+    item: ProductItem;
+    features: Feature[];
+}): string;
+export declare function featureItemBuilder({ item, features, }: {
+    item: ProductItem;
+    features: Feature[];
+}): string;
+export declare function priceItemBuilder({ item }: {
+    item: ProductItem;
+}): string;

package/dist/core/config.d.ts

@@ -34,7 +34,6 @@ export declare function loadAutumnConfigFile(): Promise<{
             metered_feature_id: string;
             credit_cost: number;
         }[] | undefined;
-        archived?: boolean | null | undefined;
     }[];
     env: string;
 }>;

package/dist/core/pull.d.ts

@@ -1,13 +1,29 @@
-import type { Product } from '../compose/models/composeModels.js';
-export declare function getProducts(ids: string[]): Promise<Product[]>;
-export declare function getAllProducts(params?: {
-    archived?: boolean;
-}): Promise<Product[]>;
-export declare function getAllProductVariants(): Promise<any[]>;
-export declare function getFeatures(params?: {
-    includeArchived?: boolean;
-}): Promise<any>;
-export declare function getCustomers(limit?: number, offset?: number): Promise<{
+export declare function getProducts(ids: string[]): Promise<{
     id: string;
-    text: string;
+    name: string;
+    items: {
+        type?: "feature" | "priced_feature" | null | undefined;
+        feature_id?: string | null | undefined;
+        included_usage?: number | "inf" | null | undefined;
+        interval?: "minute" | "hour" | "day" | "week" | "month" | "quarter" | "semi_annual" | "year" | null | undefined;
+        usage_model?: "prepaid" | "pay_per_use" | null | undefined;
+        price?: number | null | undefined;
+        tiers?: {
+            amount: number;
+            to: number | "inf";
+        }[] | null | undefined;
+        billing_units?: number | null | undefined;
+        reset_usage_when_enabled?: boolean | undefined;
+        entity_feature_id?: string | undefined;
+    }[];
+    is_add_on?: boolean | undefined;
+    is_default?: boolean | undefined;
+    free_trial?: {
+        duration: "day" | "month" | "year";
+        length: number;
+        unique_fingerprint: boolean;
+        card_required: boolean;
+    } | undefined;
 }[]>;
+export declare function getAllProducts(): Promise<any>;
+export declare function getFeatures(): Promise<any>;

package/dist/core/push.d.ts

@@ -1,50 +1,18 @@
-import type { Spinner } from 'yocto-spinner';
-import type { Feature, Product } from '../compose/index.js';
+import type { Spinner } from "yocto-spinner";
+import type { Feature, Product } from "../compose/index.js";
 export declare function checkForDeletables(currentFeatures: Feature[], currentProducts: Product[]): Promise<{
-    allFeatures: any;
     curFeatures: any;
-    curProducts: {
-        id: string;
-        name: string;
-        items: {
-            type?: "feature" | "priced_feature" | null | undefined;
-            feature_id?: string | null | undefined;
-            included_usage?: number | "inf" | null | undefined;
-            interval?: "minute" | "hour" | "day" | "week" | "month" | "quarter" | "semi_annual" | "year" | null | undefined;
-            usage_model?: "prepaid" | "pay_per_use" | null | undefined;
-            price?: number | null | undefined;
-            tiers?: {
-                amount: number;
-                to: number | "inf";
-            }[] | null | undefined;
-            billing_units?: number | null | undefined;
-            reset_usage_when_enabled?: boolean | undefined;
-            entity_feature_id?: string | undefined;
-        }[];
-        is_add_on?: boolean | undefined;
-        is_default?: boolean | undefined;
-        free_trial?: {
-            duration: "day" | "month" | "year";
-            length: number;
-            unique_fingerprint: boolean;
-            card_required: boolean;
-        } | undefined;
-    }[];
+    curProducts: any;
     featuresToDelete: any;
-    productsToDelete: string[];
+    productsToDelete: any;
 }>;
 export declare function upsertFeature(feature: Feature, s: Spinner): Promise<any>;
 export declare function checkProductForConfirmation({ curProducts, product, }: {
     curProducts: Product[];
     product: Product;
 }): Promise<{
-    id: string;
-    will_version: boolean;
-    archived?: undefined;
-} | {
     id: string;
     will_version: any;
-    archived: any;
 }>;
 export declare function upsertProduct({ curProducts, product, spinner, shouldUpdate, }: {
     curProducts: Product[];

package/dist/core/utils.d.ts

@@ -1,5 +1,5 @@
-export declare const notNullish: (value: unknown) => value is {};
-export declare const nullish: (value: unknown) => value is null | undefined;
+export declare const notNullish: (value: any) => boolean;
+export declare const nullish: (value: any) => boolean;
 export declare const isProdFlag: () => boolean;
 export declare function snakeCaseToCamelCase(value: string): string;
 export declare function idToVar({ id, prefix, }: {
@@ -9,4 +9,3 @@ export declare function idToVar({ id, prefix, }: {
 export declare function storeToEnv(prodKey: string, sandboxKey: string): Promise<void>;
 export declare function readFromEnv(): string;
 export declare function initSpinner(message: string): import("yocto-spinner").Spinner;
-export declare function isSandboxKey(apiKey: string): Promise<boolean>;

package/dist/index.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+// source/compose/builders/builderFunctions.ts
+var product = (p) => p;
+var feature = (f) => f;
+var featureItem = ({
+  feature_id,
+  included_usage,
+  interval,
+  reset_usage_when_enabled,
+  entity_feature_id
+}) => {
+  return {
+    included_usage,
+    feature_id,
+    interval,
+    reset_usage_when_enabled,
+    entity_feature_id
+  };
+};
+var pricedFeatureItem = ({
+  feature_id,
+  price,
+  tiers,
+  interval,
+  included_usage = void 0,
+  billing_units = 1,
+  usage_model = "pay_per_use",
+  reset_usage_when_enabled,
+  entity_feature_id
+}) => {
+  return {
+    price,
+    tiers,
+    interval,
+    billing_units,
+    feature_id,
+    usage_model,
+    included_usage,
+    reset_usage_when_enabled,
+    entity_feature_id
+  };
+};
+var priceItem = ({
+  price,
+  interval
+}) => {
+  return {
+    price,
+    interval
+  };
+};
+
+exports.feature = feature;
+exports.featureItem = featureItem;
+exports.priceItem = priceItem;
+exports.pricedFeatureItem = pricedFeatureItem;
+exports.product = product;

package/dist/index.d.cts

@@ -0,0 +1,184 @@
+import { z } from 'zod/v4';
+
+declare const ProductSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    is_add_on: z.ZodOptional<z.ZodPrefault<z.ZodBoolean>>;
+    is_default: z.ZodOptional<z.ZodPrefault<z.ZodBoolean>>;
+    items: z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            feature: "feature";
+            priced_feature: "priced_feature";
+        }>>>;
+        feature_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        included_usage: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>>>;
+        interval: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            minute: "minute";
+            hour: "hour";
+            day: "day";
+            week: "week";
+            month: "month";
+            quarter: "quarter";
+            semi_annual: "semi_annual";
+            year: "year";
+        }>>>;
+        usage_model: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            prepaid: "prepaid";
+            pay_per_use: "pay_per_use";
+        }>>>;
+        price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        tiers: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            amount: z.ZodNumber;
+            to: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>;
+        }, z.core.$strip>>>>;
+        billing_units: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        reset_usage_when_enabled: z.ZodOptional<z.ZodBoolean>;
+        entity_feature_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    free_trial: z.ZodOptional<z.ZodObject<{
+        duration: z.ZodEnum<{
+            day: "day";
+            month: "month";
+            year: "year";
+        }>;
+        length: z.ZodNumber;
+        unique_fingerprint: z.ZodBoolean;
+        card_required: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const FeatureSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        boolean: "boolean";
+        single_use: "single_use";
+        continuous_use: "continuous_use";
+        credit_system: "credit_system";
+    }>;
+    credit_schema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        metered_feature_id: z.ZodString;
+        credit_cost: z.ZodNumber;
+    }, z.core.$strip>>>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type Feature = z.infer<typeof FeatureSchema>;
+type Product = z.infer<typeof ProductSchema>;
+
+declare const ProductItemIntervalEnum: z.ZodEnum<{
+    minute: "minute";
+    hour: "hour";
+    day: "day";
+    week: "week";
+    month: "month";
+    quarter: "quarter";
+    semi_annual: "semi_annual";
+    year: "year";
+}>;
+declare const UsageModelEnum: z.ZodEnum<{
+    prepaid: "prepaid";
+    pay_per_use: "pay_per_use";
+}>;
+type ProductItemInterval = z.infer<typeof ProductItemIntervalEnum>;
+type UsageModel = z.infer<typeof UsageModelEnum>;
+declare const ProductItemSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        feature: "feature";
+        priced_feature: "priced_feature";
+    }>>>;
+    feature_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    included_usage: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>>>;
+    interval: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        minute: "minute";
+        hour: "hour";
+        day: "day";
+        week: "week";
+        month: "month";
+        quarter: "quarter";
+        semi_annual: "semi_annual";
+        year: "year";
+    }>>>;
+    usage_model: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        prepaid: "prepaid";
+        pay_per_use: "pay_per_use";
+    }>>>;
+    price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    tiers: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        amount: z.ZodNumber;
+        to: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>;
+    }, z.core.$strip>>>>;
+    billing_units: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    reset_usage_when_enabled: z.ZodOptional<z.ZodBoolean>;
+    entity_feature_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ProductItem = z.infer<typeof ProductItemSchema>;
+
+declare const product: (p: Product) => {
+    id: string;
+    name: string;
+    items: {
+        type?: "feature" | "priced_feature" | null | undefined;
+        feature_id?: string | null | undefined;
+        included_usage?: number | "inf" | null | undefined;
+        interval?: "minute" | "hour" | "day" | "week" | "month" | "quarter" | "semi_annual" | "year" | null | undefined;
+        usage_model?: "prepaid" | "pay_per_use" | null | undefined;
+        price?: number | null | undefined;
+        tiers?: {
+            amount: number;
+            to: number | "inf";
+        }[] | null | undefined;
+        billing_units?: number | null | undefined;
+        reset_usage_when_enabled?: boolean | undefined;
+        entity_feature_id?: string | undefined;
+    }[];
+    is_add_on?: boolean | undefined;
+    is_default?: boolean | undefined;
+    free_trial?: {
+        duration: "day" | "month" | "year";
+        length: number;
+        unique_fingerprint: boolean;
+        card_required: boolean;
+    } | undefined;
+};
+declare const feature: (f: Feature) => {
+    id: string;
+    type: "boolean" | "single_use" | "continuous_use" | "credit_system";
+    name?: string | undefined;
+    credit_schema?: {
+        metered_feature_id: string;
+        credit_cost: number;
+    }[] | undefined;
+    archived?: boolean | undefined;
+};
+declare const featureItem: ({ feature_id, included_usage, interval, reset_usage_when_enabled, entity_feature_id, }: {
+    feature_id: string;
+    included_usage?: number | "inf";
+    interval?: ProductItemInterval;
+    reset_usage_when_enabled?: boolean;
+    entity_feature_id?: string;
+}) => ProductItem;
+declare const pricedFeatureItem: ({ feature_id, price, tiers, interval, included_usage, billing_units, usage_model, reset_usage_when_enabled, entity_feature_id, }: {
+    feature_id: string;
+    price?: number;
+    tiers?: {
+        to: number | "inf";
+        amount: number;
+    }[];
+    interval?: ProductItemInterval;
+    included_usage?: number;
+    billing_units?: number;
+    usage_model?: UsageModel;
+    reset_usage_when_enabled?: boolean;
+    entity_feature_id?: string;
+}) => ProductItem;
+declare const priceItem: ({ price, interval, }: {
+    price: number;
+    interval?: ProductItemInterval;
+}) => ProductItem;
+
+type Infinity = "infinity";
+type AutumnConfig = {
+    products: Product[];
+    features: Feature[];
+};
+
+export { type AutumnConfig, type Feature, type Infinity, type Product, type ProductItem, feature, featureItem, priceItem, pricedFeatureItem, product };