autumn-js 0.1.49 → 0.1.50

package/dist/libraries/react/{ReactAutumnClient-BFsdUmZR.d.mts → ReactAutumnClient-CRqMIWBm.d.mts}

@@ -1,9 +1,10 @@
 import { A as AutumnError } from './error-DHbclCVh.mjs';
-import { a as CheckResult, S as SetupPaymentResult, Q as QueryResult } from './genTypes-B5_6Pu_4.mjs';
-import { C as CheckoutResult } from './attachTypes-BNlJ6XXa.mjs';
-import { P as Product } from './prodTypes-C4aZSZfO.mjs';
-import { C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResult } from './cusTypes-RU0fmR-t.mjs';
-import { E as Entity, D as DeleteEntityResult } from './entTypes-SfJb3hb2.mjs';
+import { a as CheckResult, S as SetupPaymentResult, E as Entity, D as DeleteEntityResult } from './entTypes-DnM96qsh.mjs';
+import { C as CheckoutResult } from './attachTypes-LC2oFUhU.mjs';
+import { Q as QueryResult } from './eventTypes-MwzIb0X5.mjs';
+import { P as Product } from './prodTypes-DVvNGoR7.mjs';
+import { C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResult } from './cusTypes-BugnOlMR.mjs';
+import { EventListParams, EventListResponse, EventAggregationParams, EventAggregationResponse } from './client/types/clientAnalyticsTypes.mjs';
 
 type Success<T> = {
     data: T;
@@ -93,6 +94,10 @@ interface IAutumnClient {
             list: Product[];
         }>;
     };
+    events: {
+        list(params: EventListParams): AutumnPromise<EventListResponse>;
+        aggregate(params: EventAggregationParams): AutumnPromise<EventAggregationResponse>;
+    };
 }
 declare class AutumnClient implements IAutumnClient {
     readonly backendUrl?: string;
@@ -148,7 +153,6 @@ declare class AutumnClient implements IAutumnClient {
         openInNewTab?: boolean | undefined;
         reward?: string | undefined;
         checkoutSessionParams?: Record<string, any> | undefined;
-        newBillingSubscription?: boolean | undefined;
     }) => AutumnPromise<{
         customer_id: string;
         product_ids: string[];
@@ -180,7 +184,6 @@ declare class AutumnClient implements IAutumnClient {
         freeTrial?: boolean | undefined;
         checkoutSessionParams?: Record<string, any> | undefined;
         reward?: string | undefined;
-        newBillingSubscription?: boolean | undefined;
     }) => AutumnPromise<CheckoutResult>;
     cancel: (params: {
         productId: string;
@@ -227,7 +230,7 @@ declare class AutumnClient implements IAutumnClient {
     }) => AutumnPromise<SetupPaymentResult>;
     query: (params: {
         featureId: string | string[];
-        range?: "24h" | "7d" | "30d" | "90d" | "last_cycle" | undefined;
+        range?: "24h" | "7d" | "30d" | "90d" | "last_cycle" | "1bc" | "3bc" | undefined;
     }) => AutumnPromise<QueryResult>;
     entities: {
         create: (params: {
@@ -257,6 +260,40 @@ declare class AutumnClient implements IAutumnClient {
             list: Product[];
         }>;
     };
+    events: {
+        list: (params: {
+            customer_id: string;
+            feature_id: string | string[];
+            starting_after?: string | undefined;
+            limit?: number | undefined;
+            time_range?: {
+                start?: number | undefined;
+                end?: number | undefined;
+            } | undefined;
+        }) => AutumnPromise<{
+            list: {
+                id: string;
+                timestamp: number;
+                event_name: string;
+                customer_id: string;
+                value: number;
+                properties: Record<string, never>;
+            }[];
+            has_more: boolean;
+            next_cursor: string | null;
+        }>;
+        aggregate: (params: {
+            customer_id: string;
+            feature_id: string | string[];
+            bin_size: "day" | "hour";
+            group_by?: string | undefined;
+            range?: "24h" | "7d" | "30d" | "90d" | "last_cycle" | "1bc" | "3bc" | undefined;
+            custom_range?: {
+                start: number;
+                end: number;
+            } | undefined;
+        }) => AutumnPromise<EventAggregationResponse>;
+    };
 }
 
 export { AutumnClient as A, type CreateReferralCodeResult as C, type ErrorResponse as E, type IAutumnClient as I, type OmitCustomerType as O, type RedeemReferralCodeResult as R, type Success as S, type AutumnPromise as a, type AutumnClientConfig as b };

package/dist/libraries/react/ReactAutumnProvider.d.mts

@@ -1,6 +1,6 @@
-import { C as CustomerData } from './cusTypes-RU0fmR-t.mjs';
+import { C as CustomerData } from './cusTypes-BugnOlMR.mjs';
 import React__default from 'react';
-import './prodTypes-C4aZSZfO.mjs';
+import './prodTypes-DVvNGoR7.mjs';
 import 'zod/v4';
 
 declare const ReactAutumnProvider: ({ children, getBearerToken, convex, backendUrl, customerData, includeCredentials, betterAuthUrl, headers, convexApi, pathPrefix, }: {

package/dist/libraries/react/ReactAutumnProvider.d.ts

@@ -1,6 +1,6 @@
-import { C as CustomerData } from './cusTypes-D3QQXjif.js';
+import { C as CustomerData } from './cusTypes-DjKY5YzO.js';
 import React__default from 'react';
-import './prodTypes-C4aZSZfO.js';
+import './prodTypes-DVvNGoR7.js';
 import 'zod/v4';
 
 declare const ReactAutumnProvider: ({ children, getBearerToken, convex, backendUrl, customerData, includeCredentials, betterAuthUrl, headers, convexApi, pathPrefix, }: {

package/dist/libraries/react/ReactAutumnProvider.js

@@ -480,6 +480,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 {
@@ -540,11 +560,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.
    * 
@@ -927,12 +949,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");
@@ -965,8 +981,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(),
@@ -995,12 +1010,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";
@@ -1008,21 +1079,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
@@ -1303,6 +1374,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;
@@ -1502,6 +1583,10 @@ var AutumnClient = class {
   products = {
     list: listProductsMethod.bind(this)
   };
+  events = {
+    list: eventListMethod.bind(this),
+    aggregate: eventAggregateMethod.bind(this)
+  };
 };
 
 // src/libraries/react/AutumnContext.tsx
@@ -2356,6 +2441,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

package/dist/libraries/react/ReactAutumnProvider.mjs

@@ -2,24 +2,25 @@
 
 import {
   ReactAutumnProvider
-} from "./chunk-JH5EPPKO.mjs";
-import "./chunk-VLUYKW5V.mjs";
+} from "./chunk-6RYHL5YC.mjs";
+import "./chunk-H4IXGV3L.mjs";
 import "./chunk-RFSQBGLO.mjs";
-import "./chunk-DQYNN6TC.mjs";
-import "./chunk-L47NULL3.mjs";
-import "./chunk-CKJ75O47.mjs";
-import "./chunk-VWRMGYHF.mjs";
-import "./chunk-QXNGODGB.mjs";
-import "./chunk-LI6VQXG6.mjs";
-import "./chunk-OX6N6HG4.mjs";
+import "./chunk-YQPZAVM5.mjs";
+import "./chunk-44N7NFQE.mjs";
+import "./chunk-G6FXYR4B.mjs";
+import "./chunk-ZTM7O3QH.mjs";
+import "./chunk-36VHLX44.mjs";
+import "./chunk-IF6IRI5K.mjs";
+import "./chunk-OMSHSISK.mjs";
+import "./chunk-OYBOLAL5.mjs";
 import "./chunk-3HZWPY3Y.mjs";
 import "./chunk-V575SGOW.mjs";
 import "./chunk-SUENW2KS.mjs";
 import "./chunk-JVCOY7ZL.mjs";
 import "./chunk-CIBQ4BJU.mjs";
-import "./chunk-B6C26BAU.mjs";
+import "./chunk-SP5G7NCG.mjs";
+import "./chunk-XDQLJ7QR.mjs";
 import "./chunk-WFFVOEUG.mjs";
-import "./chunk-OYBOLAL5.mjs";
 export {
   ReactAutumnProvider
 };

package/dist/libraries/react/{attachTypes-eg914-6v.d.ts → attachTypes-LC2oFUhU.d.mts}

@@ -1,4 +1,4 @@
-import { c as ProductItem, P as Product } from './prodTypes-C4aZSZfO.js';
+import { a as ProductItem, P as Product } from './prodTypes-DVvNGoR7.mjs';
 import { z } from 'zod/v4';
 
 declare const AttachFeatureOptionsSchema: z.ZodObject<{
@@ -42,7 +42,6 @@ declare const CheckoutParamsSchema: z.ZodObject<{
     entity_data: z.ZodOptional<z.ZodAny>;
     checkout_session_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     reward: z.ZodOptional<z.ZodString>;
-    new_billing_subscription: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type CheckoutParams = z.infer<typeof CheckoutParamsSchema>;
 type CheckoutResult = {

package/dist/libraries/react/{attachTypes-BNlJ6XXa.d.mts → attachTypes-LWj2dkge.d.ts}

@@ -1,4 +1,4 @@
-import { c as ProductItem, P as Product } from './prodTypes-C4aZSZfO.mjs';
+import { a as ProductItem, P as Product } from './prodTypes-DVvNGoR7.js';
 import { z } from 'zod/v4';
 
 declare const AttachFeatureOptionsSchema: z.ZodObject<{
@@ -42,7 +42,6 @@ declare const CheckoutParamsSchema: z.ZodObject<{
     entity_data: z.ZodOptional<z.ZodAny>;
     checkout_session_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     reward: z.ZodOptional<z.ZodString>;
-    new_billing_subscription: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type CheckoutParams = z.infer<typeof CheckoutParamsSchema>;
 type CheckoutResult = {

package/dist/libraries/react/{chunk-QXNGODGB.mjs → chunk-36VHLX44.mjs}

@@ -2,7 +2,7 @@
 
 import {
   AutumnClient
-} from "./chunk-OX6N6HG4.mjs";
+} from "./chunk-OMSHSISK.mjs";
 
 // src/libraries/react/AutumnContext.tsx
 import { createContext, useContext } from "react";

package/dist/libraries/react/{chunk-CKJ75O47.mjs → chunk-44N7NFQE.mjs}

@@ -2,7 +2,7 @@
 
 import {
   usePricingTableBase
-} from "./chunk-VWRMGYHF.mjs";
+} from "./chunk-ZTM7O3QH.mjs";
 
 // src/libraries/react/hooks/helpers/useAutumnBase.tsx
 var useAutumnBase = ({

package/dist/libraries/react/{chunk-JH5EPPKO.mjs → chunk-6RYHL5YC.mjs}

@@ -2,16 +2,16 @@
 
 import {
   BaseAutumnProvider
-} from "./chunk-VLUYKW5V.mjs";
+} from "./chunk-H4IXGV3L.mjs";
 import {
   AutumnContext
-} from "./chunk-QXNGODGB.mjs";
+} from "./chunk-36VHLX44.mjs";
 import {
   ConvexAutumnClient
-} from "./chunk-LI6VQXG6.mjs";
+} from "./chunk-IF6IRI5K.mjs";
 import {
   AutumnClient
-} from "./chunk-OX6N6HG4.mjs";
+} from "./chunk-OMSHSISK.mjs";
 
 // src/libraries/react/ReactAutumnProvider.tsx
 import { jsx } from "react/jsx-runtime";

package/dist/libraries/react/{chunk-L47NULL3.mjs → chunk-G6FXYR4B.mjs}

@@ -2,7 +2,7 @@
 
 import {
   CheckFeatureResultSchema
-} from "./chunk-B6C26BAU.mjs";
+} from "./chunk-SP5G7NCG.mjs";
 
 // src/libraries/react/hooks/helpers/handleCheck.ts
 var getCusFeature = ({

package/dist/libraries/react/chunk-GLEGQFJL.mjs

@@ -0,0 +1,47 @@
+"use client";
+
+import {
+  AutumnContext,
+  useAutumnContext
+} from "./chunk-36VHLX44.mjs";
+import {
+  AutumnError
+} from "./chunk-SP5G7NCG.mjs";
+
+// src/libraries/react/hooks/useAggregateEvents.tsx
+import useSWR 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 } = useSWR(
+    ["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
+  };
+};
+
+export {
+  useAggregateEvents
+};

package/dist/libraries/react/{chunk-SI6B4BHU.mjs → chunk-GNQFXLIJ.mjs}

@@ -2,10 +2,10 @@
 
 import {
   useCustomerBase
-} from "./chunk-DQYNN6TC.mjs";
+} from "./chunk-YQPZAVM5.mjs";
 import {
   AutumnContext
-} from "./chunk-QXNGODGB.mjs";
+} from "./chunk-36VHLX44.mjs";
 
 // src/libraries/react/hooks/useCustomer.tsx
 var useCustomer = (params) => {

package/dist/libraries/react/{chunk-VLUYKW5V.mjs → chunk-H4IXGV3L.mjs}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-RFSQBGLO.mjs";
 import {
   useCustomerBase
-} from "./chunk-DQYNN6TC.mjs";
+} from "./chunk-YQPZAVM5.mjs";
 
 // src/libraries/react/BaseAutumnProvider.tsx
 import { useRef } from "react";

package/dist/libraries/react/{chunk-LI6VQXG6.mjs → chunk-IF6IRI5K.mjs}

@@ -2,7 +2,7 @@
 
 import {
   AutumnError
-} from "./chunk-B6C26BAU.mjs";
+} from "./chunk-SP5G7NCG.mjs";
 
 // src/libraries/react/client/ConvexAutumnClient.tsx
 var ConvexAutumnClient = class {
@@ -312,6 +312,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"
+          })
+        };
+      }
+    }
+  };
 };
 
 export {

package/dist/libraries/react/{chunk-QD2JROMM.mjs → chunk-JX5R5JG5.mjs}

@@ -2,10 +2,10 @@
 
 import {
   useEntityBase
-} from "./chunk-GPH4S2JR.mjs";
+} from "./chunk-XVE6NBEM.mjs";
 import {
   AutumnContext
-} from "./chunk-QXNGODGB.mjs";
+} from "./chunk-36VHLX44.mjs";
 
 // src/libraries/react/hooks/useEntity.tsx
 var useEntity = (entityId, params) => {

package/dist/libraries/react/{chunk-OUHC5C52.mjs → chunk-KR7BWKK3.mjs}

@@ -3,10 +3,10 @@
 import {
   AutumnContext,
   useAutumnContext
-} from "./chunk-QXNGODGB.mjs";
+} from "./chunk-36VHLX44.mjs";
 import {
   AutumnError
-} from "./chunk-B6C26BAU.mjs";
+} from "./chunk-SP5G7NCG.mjs";
 
 // src/libraries/react/hooks/useAnalytics.tsx
 import useSWR from "swr";

package/dist/libraries/react/{chunk-LV7UF5CG.mjs → chunk-M3CQSMV6.mjs}

@@ -2,11 +2,11 @@
 
 import {
   usePricingTableBase
-} from "./chunk-VWRMGYHF.mjs";
+} from "./chunk-ZTM7O3QH.mjs";
 import {
   AutumnContext,
   useAutumnContext
-} from "./chunk-QXNGODGB.mjs";
+} from "./chunk-36VHLX44.mjs";
 
 // src/libraries/react/hooks/usePricingTable.tsx
 var usePricingTable = (params) => {

package/dist/libraries/react/{chunk-OX6N6HG4.mjs → chunk-OMSHSISK.mjs}

@@ -1,5 +1,10 @@
 "use client";
 
+import {
+  createEntityMethod,
+  deleteEntityMethod,
+  getEntityMethod
+} from "./chunk-OYBOLAL5.mjs";
 import {
   attachMethod,
   cancelMethod,
@@ -26,15 +31,14 @@ import {
 import {
   AutumnError,
   toContainerResult
-} from "./chunk-B6C26BAU.mjs";
+} from "./chunk-SP5G7NCG.mjs";
+import {
+  eventAggregateMethod,
+  eventListMethod
+} from "./chunk-XDQLJ7QR.mjs";
 import {
   createCustomerMethod
 } from "./chunk-WFFVOEUG.mjs";
-import {
-  createEntityMethod,
-  deleteEntityMethod,
-  getEntityMethod
-} from "./chunk-OYBOLAL5.mjs";
 
 // src/libraries/react/client/ReactAutumnClient.tsx
 var AutumnClient = class {
@@ -235,6 +239,10 @@ var AutumnClient = class {
   products = {
     list: listProductsMethod.bind(this)
   };
+  events = {
+    list: eventListMethod.bind(this),
+    aggregate: eventAggregateMethod.bind(this)
+  };
 };
 
 export {