autumn-js 0.0.92 → 0.0.95

package/dist/libraries/react/BaseAutumnProvider.js

@@ -549,44 +549,96 @@ var Autumn = class {
   }
 };
 
-// src/sdk/general/genTypes.ts
+// src/sdk/customers/entities/entTypes.ts
 var import_zod = require("zod");
-var AttachParamsSchema = import_zod.z.object({
-  customer_id: import_zod.z.string(),
-  product_id: import_zod.z.string().optional(),
-  entity_id: import_zod.z.string().optional(),
-  options: import_zod.z.array(import_zod.z.object({
-    feature_id: import_zod.z.string(),
-    quantity: import_zod.z.number()
-  })).optional(),
-  product_ids: import_zod.z.array(import_zod.z.string()).optional(),
+var EntityDataSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
+  feature_id: import_zod.z.string()
+});
+
+// src/sdk/general/genTypes.ts
+var import_zod2 = require("zod");
+var AttachFeatureOptionsSchema = import_zod2.z.object({
+  feature_id: import_zod2.z.string(),
+  quantity: import_zod2.z.number()
+});
+var AttachParamsSchema = import_zod2.z.object({
+  customer_id: import_zod2.z.string(),
+  product_id: import_zod2.z.string().optional(),
+  entity_id: import_zod2.z.string().optional(),
+  options: import_zod2.z.array(
+    import_zod2.z.object({
+      feature_id: import_zod2.z.string(),
+      quantity: import_zod2.z.number()
+    })
+  ).optional(),
+  product_ids: import_zod2.z.array(import_zod2.z.string()).optional(),
   // If set, will attach multiple products to the customer (cannot be used with product_id)
-  free_trial: import_zod.z.boolean().optional(),
+  free_trial: import_zod2.z.boolean().optional(),
   // Default is true -- if set to false, will bypass product free trial
-  success_url: import_zod.z.string().optional(),
+  success_url: import_zod2.z.string().optional(),
   // Passed to Stripe
-  metadata: import_zod.z.record(import_zod.z.string()).optional(),
+  metadata: import_zod2.z.record(import_zod2.z.string()).optional(),
   // Passed to Stripe
-  force_checkout: import_zod.z.boolean().optional(),
+  force_checkout: import_zod2.z.boolean().optional(),
   // Default is false -- if set to true, will force the customer to checkout (not allowed for upgrades / downgrades)
-  customer_data: import_zod.z.any().optional(),
-  entity_data: import_zod.z.any().optional(),
-  checkout_session_params: import_zod.z.record(import_zod.z.any()).optional(),
+  customer_data: import_zod2.z.any().optional(),
+  entity_data: import_zod2.z.any().optional(),
+  checkout_session_params: import_zod2.z.record(import_zod2.z.any()).optional(),
   // Passed to Stripe
-  reward: import_zod.z.string().optional()
+  reward: import_zod2.z.string().optional()
 });
-var AttachResultSchema = import_zod.z.object({
-  checkout_url: import_zod.z.string().optional(),
-  customer_id: import_zod.z.string(),
-  product_ids: import_zod.z.array(import_zod.z.string()),
-  code: import_zod.z.string(),
-  message: import_zod.z.string(),
-  customer_data: import_zod.z.any().optional()
+var AttachResultSchema = import_zod2.z.object({
+  checkout_url: import_zod2.z.string().optional(),
+  customer_id: import_zod2.z.string(),
+  product_ids: import_zod2.z.array(import_zod2.z.string()),
+  code: import_zod2.z.string(),
+  message: import_zod2.z.string(),
+  customer_data: import_zod2.z.any().optional()
+});
+var CancelParamsSchema = import_zod2.z.object({
+  customer_id: import_zod2.z.string(),
+  product_id: import_zod2.z.string(),
+  entity_id: import_zod2.z.string().optional(),
+  cancel_immediately: import_zod2.z.boolean().optional()
+});
+var CancelResultSchema = import_zod2.z.object({
+  success: import_zod2.z.boolean(),
+  customer_id: import_zod2.z.string(),
+  product_id: import_zod2.z.string()
+});
+var TrackParamsSchema = import_zod2.z.object({
+  customer_id: import_zod2.z.string(),
+  value: import_zod2.z.number().optional(),
+  feature_id: import_zod2.z.string().optional(),
+  event_name: import_zod2.z.string().optional(),
+  entity_id: import_zod2.z.string().optional(),
+  customer_data: import_zod2.z.any().optional(),
+  idempotency_key: import_zod2.z.string().optional(),
+  entity_data: import_zod2.z.any().optional()
+});
+var TrackResultSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  code: import_zod2.z.string(),
+  customer_id: import_zod2.z.string(),
+  feature_id: import_zod2.z.string().optional(),
+  event_name: import_zod2.z.string().optional()
+});
+var CheckParamsSchema = import_zod2.z.object({
+  customer_id: import_zod2.z.string(),
+  feature_id: import_zod2.z.string().optional(),
+  product_id: import_zod2.z.string().optional(),
+  entity_id: import_zod2.z.string().optional(),
+  customer_data: import_zod2.z.any().optional(),
+  required_balance: import_zod2.z.number().optional(),
+  send_event: import_zod2.z.boolean().optional(),
+  with_preview: import_zod2.z.boolean().optional(),
+  entity_data: EntityDataSchema.optional()
 });
 
 // src/sdk/customers/cusEnums.ts
-var import_zod2 = require("zod");
-var CustomerExpandEnum = import_zod2.z.enum([
+var import_zod3 = require("zod");
+var CustomerExpandEnum = import_zod3.z.enum([
   "invoices",
   "rewards",
   "trials_used",
@@ -596,14 +648,28 @@ var CustomerExpandEnum = import_zod2.z.enum([
 ]);
 
 // src/sdk/customers/cusTypes.ts
-var import_zod3 = require("zod");
-var CreateCustomerParamsSchema = import_zod3.z.object({
-  id: import_zod3.z.string().nullish(),
-  email: import_zod3.z.string().nullish(),
-  name: import_zod3.z.string().nullish(),
-  fingerprint: import_zod3.z.string().nullish(),
-  metadata: import_zod3.z.record(import_zod3.z.any()).optional(),
-  expand: import_zod3.z.array(CustomerExpandEnum).optional()
+var import_zod4 = require("zod");
+var CreateCustomerParamsSchema = import_zod4.z.object({
+  id: import_zod4.z.string().nullish(),
+  email: import_zod4.z.string().nullish(),
+  name: import_zod4.z.string().nullish(),
+  fingerprint: import_zod4.z.string().nullish(),
+  metadata: import_zod4.z.record(import_zod4.z.any()).optional(),
+  expand: import_zod4.z.array(CustomerExpandEnum).optional()
+});
+var BillingPortalParamsSchema = import_zod4.z.object({
+  return_url: import_zod4.z.string().optional()
+});
+
+// src/sdk/referrals/referralTypes.ts
+var import_zod5 = require("zod");
+var CreateReferralCodeParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  program_id: import_zod5.z.string()
+});
+var RedeemReferralCodeParamsSchema = import_zod5.z.object({
+  code: import_zod5.z.string(),
+  customer_id: import_zod5.z.string()
 });
 
 // src/libraries/react/errorUtils/logFetchError.ts
@@ -621,7 +687,7 @@ var logFetchError = ({
 
 // src/libraries/react/client/clientCompMethods.ts
 async function getPricingTableMethod() {
-  const res = await this.get("/api/autumn/components/pricing_table");
+  const res = await this.get(`${this.prefix}/components/pricing_table`);
   return res;
 }
 
@@ -630,7 +696,7 @@ var createCustomerMethod = async ({
   client,
   params
 }) => {
-  let result = await client.post("/api/autumn/customers", params);
+  let result = await client.post(`${client.prefix}/customers`, params);
   return result;
 };
 
@@ -666,17 +732,17 @@ var getEntityExpandStr = (expand) => {
 // src/libraries/react/client/clientEntityMethods.ts
 async function createEntityMethod(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/entities", snakeParams);
+  const res = await this.post(`${this.prefix}/entities`, snakeParams);
   return res;
 }
 async function getEntityMethod(entityId, params) {
   let snakeParams = toSnakeCase(params);
   let expand = getEntityExpandStr(params?.expand);
-  const res = await this.get(`/api/autumn/entities/${entityId}?${expand}`);
+  const res = await this.get(`${this.prefix}/entities/${entityId}?${expand}`);
   return res;
 }
 async function deleteEntityMethod(entityId) {
-  const res = await this.delete(`/api/autumn/entities/${entityId}`);
+  const res = await this.delete(`${this.prefix}/entities/${entityId}`);
   return res;
 }
 
@@ -684,51 +750,51 @@ async function deleteEntityMethod(entityId) {
 async function attachMethod(params) {
   let { dialog, ...rest } = params;
   let snakeParams = toSnakeCase(rest, ["checkoutSessionparams"]);
-  const res = await this.post("/api/autumn/attach", snakeParams);
+  const res = await this.post(`${this.prefix}/attach`, snakeParams);
   return res;
 }
 async function setupPaymentMethod(params) {
   let snakeParams = toSnakeCase(params, ["checkoutSessionParams"]);
-  const res = await this.post("/api/autumn/setup_payment", snakeParams);
+  const res = await this.post(`${this.prefix}/setup_payment`, snakeParams);
   return res;
 }
 async function cancelMethod(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/cancel", snakeParams);
+  const res = await this.post(`${this.prefix}/cancel`, snakeParams);
   return res;
 }
 async function checkMethod(params) {
   let { dialog, ...rest } = params;
   let snakeParams = toSnakeCase(rest);
-  const res = await this.post("/api/autumn/check", snakeParams);
+  const res = await this.post(`${this.prefix}/check`, snakeParams);
   return res;
 }
 async function trackMethod(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/track", snakeParams);
+  const res = await this.post(`${this.prefix}/track`, snakeParams);
   return res;
 }
 async function openBillingPortalMethod(params) {
   let snakeParams = toSnakeCase(params || {});
-  const res = await this.post("/api/autumn/billing_portal", snakeParams);
+  const res = await this.post(`${this.prefix}/billing_portal`, snakeParams);
   return res;
 }
 
 // src/libraries/react/client/clientProdMethods.ts
 async function listProductsMethod() {
-  const res = await this.get("/api/autumn/products");
+  const res = await this.get(`${this.prefix}/products`);
   return res;
 }
 
 // src/libraries/react/client/clientReferralMethods.ts
 async function createCode(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/referrals/code", snakeParams);
+  const res = await this.post(`${this.prefix}/referrals/code`, snakeParams);
   return res;
 }
 async function redeemCode(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/referrals/redeem", snakeParams);
+  const res = await this.post(`${this.prefix}/referrals/redeem`, snakeParams);
   return res;
 }
 
@@ -738,23 +804,31 @@ var AutumnClient = class {
   getBearerToken;
   customerData;
   includeCredentials;
-  corsDetected;
-  corsSupportsCredentials;
+  prefix;
   constructor({
     backendUrl,
     getBearerToken,
     customerData,
-    includeCredentials
+    includeCredentials,
+    betterAuthUrl
   }) {
     this.backendUrl = backendUrl;
     this.getBearerToken = getBearerToken;
     this.customerData = customerData;
     this.includeCredentials = includeCredentials;
+    this.prefix = "/api/autumn";
+    if (betterAuthUrl) {
+      this.prefix = "/api/auth/autumn";
+      this.backendUrl = betterAuthUrl;
+    }
   }
   /**
    * Detects if the backend supports CORS credentials by making an OPTIONS request
    */
   async detectCors() {
+    if (this.prefix?.includes("/api/auth")) {
+      return { valid: true, includeCredentials: true };
+    }
     const testEndpoint = `${this.backendUrl}/api/autumn/cors`;
     try {
       await fetch(testEndpoint, {
@@ -934,6 +1008,9 @@ var useAutumnContext = ({
   errorIfNotInitialized = true
 }) => {
   const context = (0, import_react2.useContext)(AutumnContext2);
+  if (!context.initialized && errorIfNotInitialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
+  }
   return context;
 };
 
@@ -1386,21 +1463,19 @@ var useCustomerBase = ({
   AutumnContext: AutumnContext2,
   client
 }) => {
-  const queryKey = ["customer", params?.expand];
   let context;
-  let authClientExists = !!params?.authClient;
   if (AutumnContext2) {
     context = useAutumnContext({
       AutumnContext: AutumnContext2,
-      name: "useCustomer",
-      errorIfNotInitialized: !authClientExists
+      name: "useCustomer"
+      // errorIfNotInitialized: !authClientExists,
     });
   }
-  if (authClientExists) {
-    client = params?.authClient?.autumn;
-  } else if (!client) {
+  if (!client) {
     client = context.client;
   }
+  let baseUrl = client?.backendUrl || "";
+  const queryKey = ["customer", baseUrl, params?.expand];
   const fetchCustomer = async () => {
     const { data, error: error2 } = await client.createCustomer({
       errorOnNotFound: params?.errorOnNotFound,
@@ -1424,10 +1499,9 @@ var useCustomerBase = ({
     ...params?.swrConfig
   });
   let autumnFunctions = emptyDefaultFunctions;
-  if (AutumnContext2 || params?.authClient) {
+  if (AutumnContext2) {
     autumnFunctions = useAutumnBase({
-      AutumnContext: AutumnContext2,
-      authClient: params?.authClient
+      AutumnContext: AutumnContext2
     });
   }
   return {

package/dist/libraries/react/BaseAutumnProvider.mjs

@@ -3,23 +3,23 @@
 "use client";
 import {
   BaseAutumnProvider
-} from "./chunk-DIJJCQ2N.mjs";
-import "./chunk-4QPHNIQ7.mjs";
-import "./chunk-6SDVW33H.mjs";
+} from "./chunk-DVMVIAZE.mjs";
+import "./chunk-T5PIJ4HG.mjs";
 import "./chunk-3JJC2VU5.mjs";
-import "./chunk-RZW3QO6B.mjs";
-import "./chunk-TCCWWPEC.mjs";
-import "./chunk-HL4JNKWK.mjs";
-import "./chunk-NCPXL3J2.mjs";
-import "./chunk-V5PKOA5A.mjs";
-import "./chunk-JNM4BLTM.mjs";
-import "./chunk-YUV2Y2RW.mjs";
-import "./chunk-3EYF7OI5.mjs";
-import "./chunk-KQT5G3HT.mjs";
+import "./chunk-LVDONEVF.mjs";
+import "./chunk-R4BYOLST.mjs";
+import "./chunk-4QPHNIQ7.mjs";
+import "./chunk-G3FBFZLU.mjs";
+import "./chunk-ALFXUHDD.mjs";
 import "./chunk-JVCOY7ZL.mjs";
 import "./chunk-CIBQ4BJU.mjs";
-import "./chunk-NZ5PEXT2.mjs";
-import "./chunk-TGX6UKKS.mjs";
+import "./chunk-V575SGOW.mjs";
+import "./chunk-ZV4RPZTM.mjs";
+import "./chunk-VTGR7VVK.mjs";
+import "./chunk-WFFVOEUG.mjs";
+import "./chunk-ZF2HUCN6.mjs";
+import "./chunk-VUBJ6JM3.mjs";
+import "./chunk-KQT5G3HT.mjs";
 export {
   BaseAutumnProvider
 };

package/dist/libraries/react/{ReactAutumnClient-BmHGkNH1.d.mts → ReactAutumnClient-BuSRDMJN.d.mts}

@@ -2,9 +2,9 @@ import { CreateEntityParams, GetEntityParams } from './client/types/clientEntTyp
 import { OpenBillingPortalParams, SetupPaymentParams } from './client/types/clientGenTypes.mjs';
 import * as React from 'react';
 import { A as AutumnError } from './error-DHbclCVh.mjs';
-import { R as Result, A as AutumnPromise, C as CancelResult, b as CheckResult, T as TrackResult, S as SetupPaymentResult } from './response-Bt5OMm4y.mjs';
-import { h as ProductItem, l as ProductScenario, C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResult, P as Product } from './cusTypes-WaPJKeAb.mjs';
-import { E as Entity, D as DeleteEntityResult } from './entTypes-aIV0QUCW.mjs';
+import { R as Result, A as AutumnPromise, b as CheckResult, S as SetupPaymentResult } from './response-CWluLfIs.mjs';
+import { i as ProductItem, l as ProductScenario, C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResult, P as Product } from './cusTypes-Vw94kPR9.mjs';
+import { E as Entity, D as DeleteEntityResult } from './entTypes-Ho-VocKG.mjs';
 
 interface PricingTableProduct {
     id: string;
@@ -46,15 +46,15 @@ interface AutumnClientConfig {
     getBearerToken?: () => Promise<string | null | undefined>;
     customerData?: CustomerData;
     includeCredentials?: boolean;
+    betterAuthUrl?: string;
 }
 declare class AutumnClient {
     readonly backendUrl?: string;
     protected readonly getBearerToken?: () => Promise<string | null | undefined>;
     protected readonly customerData?: CustomerData;
     protected includeCredentials?: boolean;
-    private corsDetected?;
-    private corsSupportsCredentials?;
-    constructor({ backendUrl, getBearerToken, customerData, includeCredentials, }: AutumnClientConfig);
+    readonly prefix: string;
+    constructor({ backendUrl, getBearerToken, customerData, includeCredentials, betterAuthUrl, }: AutumnClientConfig);
     /**
      * Detects if the backend supports CORS credentials by making an OPTIONS request
      */
@@ -80,11 +80,10 @@ declare class AutumnClient {
     }, AutumnError>>;
     attach: (params: {
         options?: {
-            quantity: number;
             featureId: string;
+            quantity: number;
         }[] | undefined;
         metadata?: Record<string, string> | undefined;
-        reward?: string | undefined;
         productId?: string | undefined;
         entityId?: string | undefined;
         productIds?: string[] | undefined;
@@ -94,24 +93,29 @@ declare class AutumnClient {
         dialog?: ((args_0: any, ...args: unknown[]) => JSX.Element | React.ReactNode) | undefined;
         entityData?: any;
         openInNewTab?: boolean | undefined;
+        reward?: string | undefined;
         checkoutSessionParams?: Record<string, any> | undefined;
     }) => AutumnPromise<{
         customer_id: string;
         code: string;
         message: string;
         product_ids: string[];
-        customer_data?: any;
         checkout_url?: string | undefined;
+        customer_data?: any;
     }>;
     cancel: (params: {
         productId: string;
         entityId?: string | undefined;
         cancelImmediately?: boolean | undefined;
-    }) => AutumnPromise<CancelResult>;
+    }) => AutumnPromise<{
+        customer_id: string;
+        success: boolean;
+        product_id: string;
+    }>;
     check: (params: {
-        featureId?: string | undefined;
         productId?: string | undefined;
         entityId?: string | undefined;
+        featureId?: string | undefined;
         dialog?: ((args_0: any, ...args: unknown[]) => JSX.Element | React.ReactNode) | undefined;
         entityData?: any;
         requiredBalance?: number | undefined;
@@ -120,12 +124,18 @@ declare class AutumnClient {
     }) => AutumnPromise<CheckResult>;
     track: (params: {
         value?: number | undefined;
-        featureId?: string | undefined;
         entityId?: string | undefined;
+        featureId?: string | undefined;
         entityData?: any;
         eventName?: string | undefined;
         idempotencyKey?: string | undefined;
-    }) => AutumnPromise<TrackResult>;
+    }) => AutumnPromise<{
+        id: string;
+        customer_id: string;
+        code: string;
+        feature_id?: string | undefined;
+        event_name?: string | undefined;
+    }>;
     openBillingPortal: (params?: OpenBillingPortalParams | undefined) => AutumnPromise<BillingPortalResult>;
     setupPayment: (params: SetupPaymentParams) => AutumnPromise<SetupPaymentResult>;
     entities: {

package/dist/libraries/react/{ReactAutumnClient-PGnPqPkr.d.ts → ReactAutumnClient-k0qbHX8f.d.ts}

@@ -2,9 +2,9 @@ import { CreateEntityParams, GetEntityParams } from './client/types/clientEntTyp
 import { OpenBillingPortalParams, SetupPaymentParams } from './client/types/clientGenTypes.js';
 import * as React from 'react';
 import { A as AutumnError } from './error-DHbclCVh.js';
-import { R as Result, A as AutumnPromise, C as CancelResult, b as CheckResult, T as TrackResult, S as SetupPaymentResult } from './response-CvPzWrT9.js';
-import { h as ProductItem, l as ProductScenario, C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResult, P as Product } from './cusTypes-WaPJKeAb.js';
-import { E as Entity, D as DeleteEntityResult } from './entTypes-D01S8gFX.js';
+import { R as Result, A as AutumnPromise, b as CheckResult, S as SetupPaymentResult } from './response-CQf3mDB8.js';
+import { i as ProductItem, l as ProductScenario, C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResult, P as Product } from './cusTypes-Vw94kPR9.js';
+import { E as Entity, D as DeleteEntityResult } from './entTypes-B7nuhHD7.js';
 
 interface PricingTableProduct {
     id: string;
@@ -46,15 +46,15 @@ interface AutumnClientConfig {
     getBearerToken?: () => Promise<string | null | undefined>;
     customerData?: CustomerData;
     includeCredentials?: boolean;
+    betterAuthUrl?: string;
 }
 declare class AutumnClient {
     readonly backendUrl?: string;
     protected readonly getBearerToken?: () => Promise<string | null | undefined>;
     protected readonly customerData?: CustomerData;
     protected includeCredentials?: boolean;
-    private corsDetected?;
-    private corsSupportsCredentials?;
-    constructor({ backendUrl, getBearerToken, customerData, includeCredentials, }: AutumnClientConfig);
+    readonly prefix: string;
+    constructor({ backendUrl, getBearerToken, customerData, includeCredentials, betterAuthUrl, }: AutumnClientConfig);
     /**
      * Detects if the backend supports CORS credentials by making an OPTIONS request
      */
@@ -80,11 +80,10 @@ declare class AutumnClient {
     }, AutumnError>>;
     attach: (params: {
         options?: {
-            quantity: number;
             featureId: string;
+            quantity: number;
         }[] | undefined;
         metadata?: Record<string, string> | undefined;
-        reward?: string | undefined;
         productId?: string | undefined;
         entityId?: string | undefined;
         productIds?: string[] | undefined;
@@ -94,24 +93,29 @@ declare class AutumnClient {
         dialog?: ((args_0: any, ...args: unknown[]) => JSX.Element | React.ReactNode) | undefined;
         entityData?: any;
         openInNewTab?: boolean | undefined;
+        reward?: string | undefined;
         checkoutSessionParams?: Record<string, any> | undefined;
     }) => AutumnPromise<{
         customer_id: string;
         code: string;
         message: string;
         product_ids: string[];
-        customer_data?: any;
         checkout_url?: string | undefined;
+        customer_data?: any;
     }>;
     cancel: (params: {
         productId: string;
         entityId?: string | undefined;
         cancelImmediately?: boolean | undefined;
-    }) => AutumnPromise<CancelResult>;
+    }) => AutumnPromise<{
+        customer_id: string;
+        success: boolean;
+        product_id: string;
+    }>;
     check: (params: {
-        featureId?: string | undefined;
         productId?: string | undefined;
         entityId?: string | undefined;
+        featureId?: string | undefined;
         dialog?: ((args_0: any, ...args: unknown[]) => JSX.Element | React.ReactNode) | undefined;
         entityData?: any;
         requiredBalance?: number | undefined;
@@ -120,12 +124,18 @@ declare class AutumnClient {
     }) => AutumnPromise<CheckResult>;
     track: (params: {
         value?: number | undefined;
-        featureId?: string | undefined;
         entityId?: string | undefined;
+        featureId?: string | undefined;
         entityData?: any;
         eventName?: string | undefined;
         idempotencyKey?: string | undefined;
-    }) => AutumnPromise<TrackResult>;
+    }) => AutumnPromise<{
+        id: string;
+        customer_id: string;
+        code: string;
+        feature_id?: string | undefined;
+        event_name?: string | undefined;
+    }>;
     openBillingPortal: (params?: OpenBillingPortalParams | undefined) => AutumnPromise<BillingPortalResult>;
     setupPayment: (params: SetupPaymentParams) => AutumnPromise<SetupPaymentResult>;
     entities: {

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

@@ -1,14 +1,14 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { C as CustomerData } from './cusTypes-WaPJKeAb.mjs';
+import { C as CustomerData } from './cusTypes-Vw94kPR9.mjs';
 import 'zod';
 
-declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, authClient, }: {
+declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, betterAuthUrl, }: {
     children: React.ReactNode;
     getBearerToken?: () => Promise<string | null | undefined>;
     backendUrl?: string;
     customerData?: CustomerData;
     includeCredentials?: boolean;
-    authClient?: any;
+    betterAuthUrl?: string;
 }) => react_jsx_runtime.JSX.Element;
 
 export { ReactAutumnProvider };

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

@@ -1,14 +1,14 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { C as CustomerData } from './cusTypes-WaPJKeAb.js';
+import { C as CustomerData } from './cusTypes-Vw94kPR9.js';
 import 'zod';
 
-declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, authClient, }: {
+declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, betterAuthUrl, }: {
     children: React.ReactNode;
     getBearerToken?: () => Promise<string | null | undefined>;
     backendUrl?: string;
     customerData?: CustomerData;
     includeCredentials?: boolean;
-    authClient?: any;
+    betterAuthUrl?: string;
 }) => react_jsx_runtime.JSX.Element;
 
 export { ReactAutumnProvider };