autumn-js 0.1.49 → 0.1.50

package/dist/libraries/react/index.js

@@ -35,10 +35,12 @@ __export(index_exports, {
   CheckoutDialog: () => CheckoutDialog,
   PaywallDialog: () => PaywallDialog,
   PricingTable: () => PricingTable,
+  useAggregateEvents: () => useAggregateEvents,
   useAnalytics: () => useAnalytics,
   useAutumn: () => useAutumn,
   useCustomer: () => useCustomer,
   useEntity: () => useEntity,
+  useListEvents: () => useListEvents,
   usePaywall: () => usePaywall,
   usePricingTable: () => usePricingTable
 });
@@ -513,6 +515,26 @@ var getFeature = async ({
   return instance.get(`/features/${id}`);
 };
 
+// src/sdk/events/eventMethods.ts
+var eventMethods = (instance) => {
+  return {
+    list: (params) => staticWrapper(handleEventList, instance, { params }),
+    aggregate: (params) => staticWrapper(handleEventAggregate, instance, { params })
+  };
+};
+var handleEventList = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/events/list", params);
+};
+var handleEventAggregate = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/events/aggregate", params);
+};
+
 // src/sdk/client.ts
 var LATEST_API_VERSION = "1.2";
 var Autumn = class {
@@ -573,11 +595,13 @@ var Autumn = class {
   static entities = entityMethods();
   static referrals = referralMethods();
   static features = featureMethods();
+  static events = eventMethods();
   customers = customerMethods(this);
   products = productMethods(this);
   entities = entityMethods(this);
   referrals = referralMethods(this);
   features = featureMethods(this);
+  events = eventMethods(this);
   /**
    * Initiates a checkout flow for a product purchase.
    * 
@@ -960,12 +984,6 @@ var CheckParamsSchema = import_v45.z.object({
   with_preview: import_v45.z.boolean().optional(),
   entity_data: EntityDataSchema.optional()
 });
-var QueryRangeEnum = import_v45.z.enum(["24h", "7d", "30d", "90d", "last_cycle"]);
-var QueryParamsSchema = import_v45.z.object({
-  customer_id: import_v45.z.string(),
-  feature_id: import_v45.z.string().or(import_v45.z.array(import_v45.z.string())),
-  range: QueryRangeEnum.optional()
-});
 
 // src/sdk/referrals/referralTypes.ts
 var import_v46 = require("zod/v4");
@@ -998,8 +1016,7 @@ var AttachParamsSchema = import_v47.z.object({
   entity_data: import_v47.z.any().optional(),
   checkout_session_params: import_v47.z.record(import_v47.z.string(), import_v47.z.any()).optional(),
   reward: import_v47.z.string().optional(),
-  invoice: import_v47.z.boolean().optional(),
-  new_billing_subscription: import_v47.z.boolean().optional()
+  invoice: import_v47.z.boolean().optional()
 });
 var AttachResultSchema = import_v47.z.object({
   checkout_url: import_v47.z.string().optional(),
@@ -1028,12 +1045,68 @@ var CheckoutParamsSchema = import_v47.z.object({
   customer_data: CustomerDataSchema.optional(),
   entity_data: import_v47.z.any().optional(),
   checkout_session_params: import_v47.z.record(import_v47.z.string(), import_v47.z.any()).optional(),
-  reward: import_v47.z.string().optional(),
-  new_billing_subscription: import_v47.z.boolean().optional()
+  reward: import_v47.z.string().optional()
 });
 
-// src/sdk/features/featureTypes.ts
+// src/sdk/general/cursorTypes.ts
 var import_v48 = require("zod/v4");
+var PaginationDefaults = {
+  Limit: 100,
+  MaxLimit: 1e3
+};
+var CursorPaginationQuerySchema = import_v48.z.object({
+  starting_after: import_v48.z.string().optional(),
+  limit: import_v48.z.coerce.number().int().min(1).max(PaginationDefaults.MaxLimit).default(PaginationDefaults.Limit).optional()
+});
+var createCursorPaginatedResponseSchema = (itemSchema) => import_v48.z.object({
+  list: import_v48.z.array(itemSchema),
+  has_more: import_v48.z.boolean(),
+  next_cursor: import_v48.z.string().nullable()
+});
+
+// src/sdk/events/eventTypes.ts
+var import_v49 = require("zod/v4");
+var QueryRangeEnum = import_v49.z.enum([
+  "24h",
+  "7d",
+  "30d",
+  "90d",
+  "last_cycle",
+  "1bc",
+  "3bc"
+]);
+var BinSizeEnum = import_v49.z.enum(["day", "hour"]);
+var QueryParamsSchema = import_v49.z.object({
+  customer_id: import_v49.z.string(),
+  feature_id: import_v49.z.string().or(import_v49.z.array(import_v49.z.string())),
+  range: QueryRangeEnum.optional(),
+  group_by: import_v49.z.string().startsWith("properties.").optional(),
+  bin_size: BinSizeEnum.optional(),
+  custom_range: import_v49.z.object({
+    start: import_v49.z.number(),
+    end: import_v49.z.number()
+  }).optional()
+});
+var LogParamsSchema = CursorPaginationQuerySchema.extend({
+  customer_id: import_v49.z.string(),
+  feature_id: import_v49.z.string().or(import_v49.z.array(import_v49.z.string())),
+  time_range: import_v49.z.object({
+    start: import_v49.z.coerce.number().optional(),
+    end: import_v49.z.coerce.number().optional()
+  }).optional()
+});
+var EventLogSchema = import_v49.z.object({
+  id: import_v49.z.string().describe("Event ID (KSUID)"),
+  timestamp: import_v49.z.number().describe("Event timestamp (epoch milliseconds)"),
+  event_name: import_v49.z.string().describe("Name of the event"),
+  customer_id: import_v49.z.string().describe("Customer identifier"),
+  value: import_v49.z.number().describe("Event value/count"),
+  properties: import_v49.z.object({}).describe("Event properties (JSONB)")
+});
+var EventLogResponseSchema = createCursorPaginatedResponseSchema(EventLogSchema);
+
+// src/sdk/features/featureTypes.ts
+var import_v410 = require("zod/v4");
 var FeatureType = /* @__PURE__ */ ((FeatureType2) => {
   FeatureType2["Boolean"] = "boolean";
   FeatureType2["SingleUse"] = "single_use";
@@ -1041,21 +1114,21 @@ var FeatureType = /* @__PURE__ */ ((FeatureType2) => {
   FeatureType2["CreditSystem"] = "credit_system";
   return FeatureType2;
 })(FeatureType || {});
-var FeatureSchema = import_v48.z.object({
-  id: import_v48.z.string(),
-  name: import_v48.z.string(),
-  type: import_v48.z.enum(FeatureType),
-  display: import_v48.z.object({
-    singular: import_v48.z.string(),
-    plural: import_v48.z.string()
+var FeatureSchema = import_v410.z.object({
+  id: import_v410.z.string(),
+  name: import_v410.z.string(),
+  type: import_v410.z.enum(FeatureType),
+  display: import_v410.z.object({
+    singular: import_v410.z.string(),
+    plural: import_v410.z.string()
   }).nullish(),
-  credit_schema: import_v48.z.array(
-    import_v48.z.object({
-      metered_feature_id: import_v48.z.string(),
-      credit_cost: import_v48.z.number()
+  credit_schema: import_v410.z.array(
+    import_v410.z.object({
+      metered_feature_id: import_v410.z.string(),
+      credit_cost: import_v410.z.number()
     })
   ).nullish(),
-  archived: import_v48.z.boolean()
+  archived: import_v410.z.boolean()
 });
 
 // src/libraries/react/hooks/helpers/handleCheck.ts
@@ -1336,6 +1409,16 @@ async function redeemCode(params) {
   return res;
 }
 
+// src/libraries/react/client/clientAnalyticsMethods.ts
+async function eventListMethod(params) {
+  const res = await this.post(`${this.prefix}/events/list`, params);
+  return res;
+}
+async function eventAggregateMethod(params) {
+  const res = await this.post(`${this.prefix}/events/aggregate`, params);
+  return res;
+}
+
 // src/libraries/react/client/ReactAutumnClient.tsx
 var AutumnClient = class {
   backendUrl;
@@ -1535,6 +1618,10 @@ var AutumnClient = class {
   products = {
     list: listProductsMethod.bind(this)
   };
+  events = {
+    list: eventListMethod.bind(this),
+    aggregate: eventAggregateMethod.bind(this)
+  };
 };
 
 // src/libraries/react/AutumnContext.tsx
@@ -2389,6 +2476,42 @@ var ConvexAutumnClient = class {
       }
     }
   };
+  events = {
+    list: async (params) => {
+      try {
+        const result = await this.convex.action(
+          this.convexApi.listEvents,
+          params
+        );
+        return result;
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    },
+    aggregate: async (params) => {
+      try {
+        const result = await this.convex.action(
+          this.convexApi.aggregateEvents,
+          params
+        );
+        return result;
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    }
+  };
 };
 
 // src/libraries/react/ReactAutumnProvider.tsx
@@ -2602,6 +2725,75 @@ var usePaywall = ({
   };
 };
 
+// src/libraries/react/hooks/useListEvents.tsx
+var import_swr6 = __toESM(require("swr"));
+var useListEvents = (params) => {
+  const context = useAutumnContext({
+    AutumnContext,
+    name: "useListEvents"
+  });
+  const client = context.client;
+  const fetcher = async () => {
+    try {
+      const { data: data2, error: error2 } = await client.events.list(params);
+      if (error2) throw error2;
+      return data2;
+    } catch (error2) {
+      throw new AutumnError({
+        message: "Failed to fetch event list",
+        code: "fetch_event_list_failed"
+      });
+    }
+  };
+  const { data, error, mutate } = (0, import_swr6.default)(
+    ["eventList", params.customer_id, params.feature_id, params.time_range],
+    fetcher,
+    { refreshInterval: 0 }
+  );
+  return {
+    list: data?.list,
+    hasMore: data?.has_more,
+    nextCursor: data?.next_cursor,
+    isLoading: !error && !data,
+    error,
+    refetch: mutate
+  };
+};
+
+// src/libraries/react/hooks/useAggregateEvents.tsx
+var import_swr7 = __toESM(require("swr"));
+var useAggregateEvents = (params) => {
+  const context = useAutumnContext({
+    AutumnContext,
+    name: "useAggregateEvents"
+  });
+  const client = context.client;
+  const fetcher = async () => {
+    try {
+      const { data: data2, error: error2 } = await client.events.aggregate(params);
+      if (error2) throw error2;
+      return data2;
+    } catch (error2) {
+      throw new AutumnError({
+        message: "Failed to fetch event aggregation",
+        code: "fetch_event_aggregation_failed"
+      });
+    }
+  };
+  const { data, error, mutate } = (0, import_swr7.default)(
+    ["eventAggregate", params.customer_id, params.feature_id, params.range, params.bin_size],
+    fetcher,
+    { refreshInterval: 0 }
+  );
+  return {
+    list: data?.list,
+    total: data?.total,
+    isLoading: !error && !data,
+    error,
+    refetch: mutate
+  };
+};
+
 // ../node_modules/.pnpm/@radix-ui+react-accordion@1.2.11_@types+react-dom@19.1.9_@types+react@19.1.10__@types+r_88fa064b3d5df5119586fe1472472636/node_modules/@radix-ui/react-accordion/dist/index.mjs
 var import_react8 = __toESM(require("react"), 1);
 
@@ -11711,10 +11903,12 @@ var useAutumn = () => {
   CheckoutDialog,
   PaywallDialog,
   PricingTable,
+  useAggregateEvents,
   useAnalytics,
   useAutumn,
   useCustomer,
   useEntity,
+  useListEvents,
   usePaywall,
   usePricingTable
 });

package/dist/libraries/react/index.mjs

@@ -469,6 +469,26 @@ var getFeature = async ({
   return instance.get(`/features/${id}`);
 };
 
+// src/sdk/events/eventMethods.ts
+var eventMethods = (instance) => {
+  return {
+    list: (params) => staticWrapper(handleEventList, instance, { params }),
+    aggregate: (params) => staticWrapper(handleEventAggregate, instance, { params })
+  };
+};
+var handleEventList = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/events/list", params);
+};
+var handleEventAggregate = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/events/aggregate", params);
+};
+
 // src/sdk/client.ts
 var LATEST_API_VERSION = "1.2";
 var Autumn = class {
@@ -529,11 +549,13 @@ var Autumn = class {
   static entities = entityMethods();
   static referrals = referralMethods();
   static features = featureMethods();
+  static events = eventMethods();
   customers = customerMethods(this);
   products = productMethods(this);
   entities = entityMethods(this);
   referrals = referralMethods(this);
   features = featureMethods(this);
+  events = eventMethods(this);
   /**
    * Initiates a checkout flow for a product purchase.
    * 
@@ -916,12 +938,6 @@ var CheckParamsSchema = z5.object({
   with_preview: z5.boolean().optional(),
   entity_data: EntityDataSchema.optional()
 });
-var QueryRangeEnum = z5.enum(["24h", "7d", "30d", "90d", "last_cycle"]);
-var QueryParamsSchema = z5.object({
-  customer_id: z5.string(),
-  feature_id: z5.string().or(z5.array(z5.string())),
-  range: QueryRangeEnum.optional()
-});
 
 // src/sdk/referrals/referralTypes.ts
 import { z as z6 } from "zod/v4";
@@ -954,8 +970,7 @@ var AttachParamsSchema = z7.object({
   entity_data: z7.any().optional(),
   checkout_session_params: z7.record(z7.string(), z7.any()).optional(),
   reward: z7.string().optional(),
-  invoice: z7.boolean().optional(),
-  new_billing_subscription: z7.boolean().optional()
+  invoice: z7.boolean().optional()
 });
 var AttachResultSchema = z7.object({
   checkout_url: z7.string().optional(),
@@ -984,12 +999,68 @@ var CheckoutParamsSchema = z7.object({
   customer_data: CustomerDataSchema.optional(),
   entity_data: z7.any().optional(),
   checkout_session_params: z7.record(z7.string(), z7.any()).optional(),
-  reward: z7.string().optional(),
-  new_billing_subscription: z7.boolean().optional()
+  reward: z7.string().optional()
 });
 
-// src/sdk/features/featureTypes.ts
+// src/sdk/general/cursorTypes.ts
 import { z as z8 } from "zod/v4";
+var PaginationDefaults = {
+  Limit: 100,
+  MaxLimit: 1e3
+};
+var CursorPaginationQuerySchema = z8.object({
+  starting_after: z8.string().optional(),
+  limit: z8.coerce.number().int().min(1).max(PaginationDefaults.MaxLimit).default(PaginationDefaults.Limit).optional()
+});
+var createCursorPaginatedResponseSchema = (itemSchema) => z8.object({
+  list: z8.array(itemSchema),
+  has_more: z8.boolean(),
+  next_cursor: z8.string().nullable()
+});
+
+// src/sdk/events/eventTypes.ts
+import { z as z9 } from "zod/v4";
+var QueryRangeEnum = z9.enum([
+  "24h",
+  "7d",
+  "30d",
+  "90d",
+  "last_cycle",
+  "1bc",
+  "3bc"
+]);
+var BinSizeEnum = z9.enum(["day", "hour"]);
+var QueryParamsSchema = z9.object({
+  customer_id: z9.string(),
+  feature_id: z9.string().or(z9.array(z9.string())),
+  range: QueryRangeEnum.optional(),
+  group_by: z9.string().startsWith("properties.").optional(),
+  bin_size: BinSizeEnum.optional(),
+  custom_range: z9.object({
+    start: z9.number(),
+    end: z9.number()
+  }).optional()
+});
+var LogParamsSchema = CursorPaginationQuerySchema.extend({
+  customer_id: z9.string(),
+  feature_id: z9.string().or(z9.array(z9.string())),
+  time_range: z9.object({
+    start: z9.coerce.number().optional(),
+    end: z9.coerce.number().optional()
+  }).optional()
+});
+var EventLogSchema = z9.object({
+  id: z9.string().describe("Event ID (KSUID)"),
+  timestamp: z9.number().describe("Event timestamp (epoch milliseconds)"),
+  event_name: z9.string().describe("Name of the event"),
+  customer_id: z9.string().describe("Customer identifier"),
+  value: z9.number().describe("Event value/count"),
+  properties: z9.object({}).describe("Event properties (JSONB)")
+});
+var EventLogResponseSchema = createCursorPaginatedResponseSchema(EventLogSchema);
+
+// src/sdk/features/featureTypes.ts
+import { z as z10 } from "zod/v4";
 var FeatureType = /* @__PURE__ */ ((FeatureType2) => {
   FeatureType2["Boolean"] = "boolean";
   FeatureType2["SingleUse"] = "single_use";
@@ -997,21 +1068,21 @@ var FeatureType = /* @__PURE__ */ ((FeatureType2) => {
   FeatureType2["CreditSystem"] = "credit_system";
   return FeatureType2;
 })(FeatureType || {});
-var FeatureSchema = z8.object({
-  id: z8.string(),
-  name: z8.string(),
-  type: z8.enum(FeatureType),
-  display: z8.object({
-    singular: z8.string(),
-    plural: z8.string()
+var FeatureSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
+  type: z10.enum(FeatureType),
+  display: z10.object({
+    singular: z10.string(),
+    plural: z10.string()
   }).nullish(),
-  credit_schema: z8.array(
-    z8.object({
-      metered_feature_id: z8.string(),
-      credit_cost: z8.number()
+  credit_schema: z10.array(
+    z10.object({
+      metered_feature_id: z10.string(),
+      credit_cost: z10.number()
     })
   ).nullish(),
-  archived: z8.boolean()
+  archived: z10.boolean()
 });
 
 // src/libraries/react/hooks/helpers/handleCheck.ts
@@ -1292,6 +1363,16 @@ async function redeemCode(params) {
   return res;
 }
 
+// src/libraries/react/client/clientAnalyticsMethods.ts
+async function eventListMethod(params) {
+  const res = await this.post(`${this.prefix}/events/list`, params);
+  return res;
+}
+async function eventAggregateMethod(params) {
+  const res = await this.post(`${this.prefix}/events/aggregate`, params);
+  return res;
+}
+
 // src/libraries/react/client/ReactAutumnClient.tsx
 var AutumnClient = class {
   backendUrl;
@@ -1491,6 +1572,10 @@ var AutumnClient = class {
   products = {
     list: listProductsMethod.bind(this)
   };
+  events = {
+    list: eventListMethod.bind(this),
+    aggregate: eventAggregateMethod.bind(this)
+  };
 };
 
 // src/libraries/react/AutumnContext.tsx
@@ -2345,6 +2430,42 @@ var ConvexAutumnClient = class {
       }
     }
   };
+  events = {
+    list: async (params) => {
+      try {
+        const result = await this.convex.action(
+          this.convexApi.listEvents,
+          params
+        );
+        return result;
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    },
+    aggregate: async (params) => {
+      try {
+        const result = await this.convex.action(
+          this.convexApi.aggregateEvents,
+          params
+        );
+        return result;
+      } catch (error) {
+        return {
+          data: null,
+          error: new AutumnError({
+            message: error.message,
+            code: "convex_action_failed"
+          })
+        };
+      }
+    }
+  };
 };
 
 // src/libraries/react/ReactAutumnProvider.tsx
@@ -2558,6 +2679,75 @@ var usePaywall = ({
   };
 };
 
+// src/libraries/react/hooks/useListEvents.tsx
+import useSWR6 from "swr";
+var useListEvents = (params) => {
+  const context = useAutumnContext({
+    AutumnContext,
+    name: "useListEvents"
+  });
+  const client = context.client;
+  const fetcher = async () => {
+    try {
+      const { data: data2, error: error2 } = await client.events.list(params);
+      if (error2) throw error2;
+      return data2;
+    } catch (error2) {
+      throw new AutumnError({
+        message: "Failed to fetch event list",
+        code: "fetch_event_list_failed"
+      });
+    }
+  };
+  const { data, error, mutate } = useSWR6(
+    ["eventList", params.customer_id, params.feature_id, params.time_range],
+    fetcher,
+    { refreshInterval: 0 }
+  );
+  return {
+    list: data?.list,
+    hasMore: data?.has_more,
+    nextCursor: data?.next_cursor,
+    isLoading: !error && !data,
+    error,
+    refetch: mutate
+  };
+};
+
+// src/libraries/react/hooks/useAggregateEvents.tsx
+import useSWR7 from "swr";
+var useAggregateEvents = (params) => {
+  const context = useAutumnContext({
+    AutumnContext,
+    name: "useAggregateEvents"
+  });
+  const client = context.client;
+  const fetcher = async () => {
+    try {
+      const { data: data2, error: error2 } = await client.events.aggregate(params);
+      if (error2) throw error2;
+      return data2;
+    } catch (error2) {
+      throw new AutumnError({
+        message: "Failed to fetch event aggregation",
+        code: "fetch_event_aggregation_failed"
+      });
+    }
+  };
+  const { data, error, mutate } = useSWR7(
+    ["eventAggregate", params.customer_id, params.feature_id, params.range, params.bin_size],
+    fetcher,
+    { refreshInterval: 0 }
+  );
+  return {
+    list: data?.list,
+    total: data?.total,
+    isLoading: !error && !data,
+    error,
+    refetch: mutate
+  };
+};
+
 // ../node_modules/.pnpm/@radix-ui+react-accordion@1.2.11_@types+react-dom@19.1.9_@types+react@19.1.10__@types+r_88fa064b3d5df5119586fe1472472636/node_modules/@radix-ui/react-accordion/dist/index.mjs
 import React13 from "react";
 
@@ -11666,10 +11856,12 @@ export {
   CheckoutDialog,
   PaywallDialog,
   PricingTable,
+  useAggregateEvents,
   useAnalytics,
   useAutumn,
   useCustomer,
   useEntity,
+  useListEvents,
   usePaywall,
   usePricingTable
 };

package/dist/libraries/react/{prodTypes-C4aZSZfO.d.mts → prodTypes-DVvNGoR7.d.mts}

@@ -168,4 +168,4 @@ interface Product {
     };
 }
 
-export { AppEnv as A, type CheckFeaturePreview as C, type Product as P, type CheckFeatureResult as a, type CheckProductResult as b, type ProductItem as c, type ProductScenario as d, ProductItemInterval as e };
+export { AppEnv as A, type CheckFeaturePreview as C, type Product as P, type ProductItem as a, type ProductScenario as b, type CheckFeatureResult as c, type CheckProductResult as d, ProductItemInterval as e };

package/dist/libraries/react/{prodTypes-C4aZSZfO.d.ts → prodTypes-DVvNGoR7.d.ts}

@@ -168,4 +168,4 @@ interface Product {
     };
 }
 
-export { AppEnv as A, type CheckFeaturePreview as C, type Product as P, type CheckFeatureResult as a, type CheckProductResult as b, type ProductItem as c, type ProductScenario as d, ProductItemInterval as e };
+export { AppEnv as A, type CheckFeaturePreview as C, type Product as P, type ProductItem as a, type ProductScenario as b, type CheckFeatureResult as c, type CheckProductResult as d, ProductItemInterval as e };