autumn-js 0.1.49 → 0.1.51-beta.0

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";
@@ -988,8 +1004,65 @@ var CheckoutParamsSchema = z7.object({
   new_billing_subscription: z7.boolean().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 +1070,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 +1365,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 +1574,10 @@ var AutumnClient = class {
   products = {
     list: listProductsMethod.bind(this)
   };
+  events = {
+    list: eventListMethod.bind(this),
+    aggregate: eventAggregateMethod.bind(this)
+  };
 };
 
 // src/libraries/react/AutumnContext.tsx
@@ -1895,7 +1982,7 @@ var useCustomerBase = ({
     client = context.client;
   }
   const baseUrl = client?.backendUrl || "";
-  const queryKey = ["customer", baseUrl, params?.expand];
+  const queryKey = ["customer", baseUrl, params?.expand, ...params?.extraQueryKeys || []];
   const fetchCustomer = async () => {
     const { data, error: error2 } = await client.createCustomer({
       errorOnNotFound: params?.errorOnNotFound,
@@ -2345,6 +2432,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 +2681,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 +11858,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 };

package/dist/next/client/NextAutumnClient.d.mts

@@ -1,11 +1,86 @@
-import { f as CheckResult, c as SetupPaymentResult, Q as QueryResult, A as AttachParams, C as CancelParams, b as CancelResult, e as CheckParams, T as TrackParams, a as TrackResult, O as OpenBillingPortalParams } from './clientAttachTypes-CYbSvvX0.mjs';
-import { C as CheckoutResult, a as CreateReferralCodeResult, R as RedeemReferralCodeResult, A as AttachResult, b as CreateEntityParams, G as GetEntityParams } from './clientEntTypes-aLfa3lyP.mjs';
+import { f as CheckResult, c as SetupPaymentResult, A as AttachParams, C as CancelParams, b as CancelResult, e as CheckParams, T as TrackParams, a as TrackResult, O as OpenBillingPortalParams } from './clientAttachTypes-C8e1uv-S.mjs';
+import { C as CheckoutResult, b as CreateReferralCodeResult, R as RedeemReferralCodeResult, A as AttachResult, a as CreateEntityParams, G as GetEntityParams } from './clientEntTypes--IF-i2B5.mjs';
 import { A as AutumnPromise, R as Result } from './response-DKQ_cb7U.mjs';
-import { C as CustomerData, b as CreateCustomerParams, a as Customer, B as BillingPortalResult } from './cusTypes-CXjHwB-c.mjs';
-import { E as Entity, D as DeleteEntityResult } from './entTypes-BkN-Puru.mjs';
+import { C as CustomerData, f as CreateCustomerParams, a as Customer, B as BillingPortalResult } from './cusTypes-Cny6ELGC.mjs';
+import { E as Entity, D as DeleteEntityResult } from './entTypes-2N5YUUiP.mjs';
 import { A as AutumnError } from './error-DHbclCVh.mjs';
-import { P as Product } from './prodTypes-B_VMILpU.mjs';
-import 'zod/v4';
+import { b as Product } from './prodTypes-HrKk7bUE.mjs';
+import { z } from 'zod/v4';
+
+type QueryResult = {
+    list: Array<{
+        period: number;
+    } & {
+        [key: string]: number | Record<string, number>;
+    }>;
+};
+
+declare const EventListParamsSchema: z.ZodObject<{
+    starting_after: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    customer_id: z.ZodString;
+    feature_id: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>;
+    time_range: z.ZodOptional<z.ZodObject<{
+        start: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        end: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type EventListParams = z.infer<typeof EventListParamsSchema>;
+declare const EventListResponseSchema: z.ZodObject<{
+    list: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        event_name: z.ZodString;
+        customer_id: z.ZodString;
+        value: z.ZodNumber;
+        properties: z.ZodObject<{}, z.core.$strip>;
+    }, z.core.$strip>>;
+    has_more: z.ZodBoolean;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type EventListResponse = z.infer<typeof EventListResponseSchema>;
+declare const EventAggregationParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    feature_id: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>;
+    group_by: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodEnum<{
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+        "90d": "90d";
+        last_cycle: "last_cycle";
+        "1bc": "1bc";
+        "3bc": "3bc";
+    }>>;
+    bin_size: z.ZodDefault<z.ZodEnum<{
+        day: "day";
+        hour: "hour";
+    }>>;
+    custom_range: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type EventAggregationParams = z.infer<typeof EventAggregationParamsSchema>;
+type FlatAggregatedRow = {
+    period: number;
+    [featureName: string]: number;
+};
+type GroupedAggregatedRow = {
+    period: number;
+} & {
+    [featureName: string]: Record<string, number>;
+};
+type AggregatedEventRow = FlatAggregatedRow | GroupedAggregatedRow;
+declare const EventAggregationTotalSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    count: z.ZodNumber;
+    sum: z.ZodNumber;
+}, z.core.$strip>>;
+type EventAggregationTotal = z.infer<typeof EventAggregationTotalSchema>;
+type EventAggregationResponse = {
+    list: AggregatedEventRow[];
+    total: EventAggregationTotal;
+};
 
 interface AutumnClientConfig {
     backendUrl?: string;
@@ -61,6 +136,10 @@ interface IAutumnClient {
             list: Product[];
         }>;
     };
+    events: {
+        list(params: EventListParams): AutumnPromise<EventListResponse>;
+        aggregate(params: EventAggregationParams): AutumnPromise<EventAggregationResponse>;
+    };
 }
 declare class AutumnClient implements IAutumnClient {
     readonly backendUrl?: string;
@@ -195,7 +274,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: {
@@ -225,6 +304,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>;
+    };
 }
 
 interface ErrorResponse {

package/dist/next/client/NextAutumnClient.d.ts

@@ -1,11 +1,86 @@
-import { f as CheckResult, c as SetupPaymentResult, Q as QueryResult, A as AttachParams, C as CancelParams, b as CancelResult, e as CheckParams, T as TrackParams, a as TrackResult, O as OpenBillingPortalParams } from './clientAttachTypes-p30QOQW2.js';
-import { C as CheckoutResult, a as CreateReferralCodeResult, R as RedeemReferralCodeResult, A as AttachResult, b as CreateEntityParams, G as GetEntityParams } from './clientEntTypes-Bsi7ciUF.js';
+import { f as CheckResult, c as SetupPaymentResult, A as AttachParams, C as CancelParams, b as CancelResult, e as CheckParams, T as TrackParams, a as TrackResult, O as OpenBillingPortalParams } from './clientAttachTypes-Ca9YkmkW.js';
+import { C as CheckoutResult, b as CreateReferralCodeResult, R as RedeemReferralCodeResult, A as AttachResult, a as CreateEntityParams, G as GetEntityParams } from './clientEntTypes-DtmpIviv.js';
 import { A as AutumnPromise, R as Result } from './response-CLgEplsF.js';
-import { C as CustomerData, b as CreateCustomerParams, a as Customer, B as BillingPortalResult } from './cusTypes-B-rJwpui.js';
-import { E as Entity, D as DeleteEntityResult } from './entTypes-DjKFS-Zk.js';
+import { C as CustomerData, f as CreateCustomerParams, a as Customer, B as BillingPortalResult } from './cusTypes-DJ8I9f_a.js';
+import { E as Entity, D as DeleteEntityResult } from './entTypes-D04IFxc9.js';
 import { A as AutumnError } from './error-DHbclCVh.js';
-import { P as Product } from './prodTypes-B_VMILpU.js';
-import 'zod/v4';
+import { b as Product } from './prodTypes-HrKk7bUE.js';
+import { z } from 'zod/v4';
+
+type QueryResult = {
+    list: Array<{
+        period: number;
+    } & {
+        [key: string]: number | Record<string, number>;
+    }>;
+};
+
+declare const EventListParamsSchema: z.ZodObject<{
+    starting_after: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    customer_id: z.ZodString;
+    feature_id: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>;
+    time_range: z.ZodOptional<z.ZodObject<{
+        start: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        end: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type EventListParams = z.infer<typeof EventListParamsSchema>;
+declare const EventListResponseSchema: z.ZodObject<{
+    list: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        event_name: z.ZodString;
+        customer_id: z.ZodString;
+        value: z.ZodNumber;
+        properties: z.ZodObject<{}, z.core.$strip>;
+    }, z.core.$strip>>;
+    has_more: z.ZodBoolean;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type EventListResponse = z.infer<typeof EventListResponseSchema>;
+declare const EventAggregationParamsSchema: z.ZodObject<{
+    customer_id: z.ZodString;
+    feature_id: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>;
+    group_by: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodEnum<{
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+        "90d": "90d";
+        last_cycle: "last_cycle";
+        "1bc": "1bc";
+        "3bc": "3bc";
+    }>>;
+    bin_size: z.ZodDefault<z.ZodEnum<{
+        day: "day";
+        hour: "hour";
+    }>>;
+    custom_range: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type EventAggregationParams = z.infer<typeof EventAggregationParamsSchema>;
+type FlatAggregatedRow = {
+    period: number;
+    [featureName: string]: number;
+};
+type GroupedAggregatedRow = {
+    period: number;
+} & {
+    [featureName: string]: Record<string, number>;
+};
+type AggregatedEventRow = FlatAggregatedRow | GroupedAggregatedRow;
+declare const EventAggregationTotalSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    count: z.ZodNumber;
+    sum: z.ZodNumber;
+}, z.core.$strip>>;
+type EventAggregationTotal = z.infer<typeof EventAggregationTotalSchema>;
+type EventAggregationResponse = {
+    list: AggregatedEventRow[];
+    total: EventAggregationTotal;
+};
 
 interface AutumnClientConfig {
     backendUrl?: string;
@@ -61,6 +136,10 @@ interface IAutumnClient {
             list: Product[];
         }>;
     };
+    events: {
+        list(params: EventListParams): AutumnPromise<EventListResponse>;
+        aggregate(params: EventAggregationParams): AutumnPromise<EventAggregationResponse>;
+    };
 }
 declare class AutumnClient implements IAutumnClient {
     readonly backendUrl?: string;
@@ -195,7 +274,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: {
@@ -225,6 +304,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>;
+    };
 }
 
 interface ErrorResponse {

package/dist/next/client/NextAutumnProvider.d.mts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { C as CustomerData } from './cusTypes-CXjHwB-c.mjs';
-import './prodTypes-B_VMILpU.mjs';
+import { C as CustomerData } from './cusTypes-Cny6ELGC.mjs';
+import './prodTypes-HrKk7bUE.mjs';
 import 'zod/v4';
 
 declare const NextAutumnProvider: ({ encryptedCustomerId, customerData, children, defaultReturnUrl, }: {

package/dist/next/client/NextAutumnProvider.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { C as CustomerData } from './cusTypes-B-rJwpui.js';
-import './prodTypes-B_VMILpU.js';
+import { C as CustomerData } from './cusTypes-DJ8I9f_a.js';
+import './prodTypes-HrKk7bUE.js';
 import 'zod/v4';
 
 declare const NextAutumnProvider: ({ encryptedCustomerId, customerData, children, defaultReturnUrl, }: {

package/dist/next/client/{clientAttachTypes-p30QOQW2.d.ts → clientAttachTypes-C8e1uv-S.d.mts}

@@ -1,4 +1,4 @@
-import { C as CheckFeatureResult, c as CheckProductResult } from './prodTypes-B_VMILpU.js';
+import { C as CheckFeatureResult, c as CheckProductResult } from './prodTypes-HrKk7bUE.mjs';
 import { z } from 'zod/v4';
 
 declare const CancelResultSchema: z.ZodObject<{
@@ -20,13 +20,6 @@ interface SetupPaymentResult {
     customer_id: string;
     url: string;
 }
-type QueryResult = {
-    list: Array<{
-        period: number;
-    } & {
-        [key: string]: number;
-    }>;
-};
 
 declare const CancelParamsSchema: z.ZodObject<{
     productId: z.ZodString;
@@ -107,4 +100,4 @@ declare const CheckoutParamsSchema: z.ZodObject<{
 }, z.core.$strip>;
 type CheckoutParams = z.infer<typeof CheckoutParamsSchema>;
 
-export type { AttachParams as A, CancelParams as C, OpenBillingPortalParams as O, QueryResult as Q, SetupPaymentParams as S, TrackParams as T, TrackResult as a, CancelResult as b, SetupPaymentResult as c, CheckoutParams as d, CheckParams as e, CheckResult as f };
+export type { AttachParams as A, CancelParams as C, OpenBillingPortalParams as O, SetupPaymentParams as S, TrackParams as T, TrackResult as a, CancelResult as b, SetupPaymentResult as c, CheckoutParams as d, CheckParams as e, CheckResult as f };