autumn-js 0.0.108 → 0.0.110

package/dist/libraries/react/hooks/{useAutumnBase.js → useAnalytics.js}

@@ -29,12 +29,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/libraries/react/hooks/useAutumnBase.tsx
-var useAutumnBase_exports = {};
-__export(useAutumnBase_exports, {
-  useAutumnBase: () => useAutumnBase
+// src/libraries/react/hooks/useAnalytics.tsx
+var useAnalytics_exports = {};
+__export(useAnalytics_exports, {
+  useAnalytics: () => useAnalytics
 });
-module.exports = __toCommonJS(useAutumnBase_exports);
+module.exports = __toCommonJS(useAnalytics_exports);
 
 // src/libraries/react/errorUtils/logAuthError.ts
 var logAuthError = async (response) => {
@@ -121,6 +121,12 @@ var handleCheck = async ({
 }) => {
   return instance.post("/check", params);
 };
+var handleQuery = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/query", params);
+};
 
 // src/libraries/backend/constants.ts
 var autumnApiUrl = "https://api.useautumn.com/v1";
@@ -498,60 +504,32 @@ var Autumn = class {
       params
     });
   }
+  static query = (params) => staticWrapper(handleQuery, void 0, { params });
+  async query(params) {
+    return handleQuery({
+      instance: this,
+      params
+    });
+  }
 };
 
-// src/sdk/customers/entities/entTypes.ts
-var import_zod = require("zod");
-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 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/products/prodEnums.ts
+var ProductItemInterval = /* @__PURE__ */ ((ProductItemInterval2) => {
+  ProductItemInterval2["Minute"] = "minute";
+  ProductItemInterval2["Hour"] = "hour";
+  ProductItemInterval2["Day"] = "day";
+  ProductItemInterval2["Week"] = "week";
+  ProductItemInterval2["Month"] = "month";
+  ProductItemInterval2["Quarter"] = "quarter";
+  ProductItemInterval2["SemiAnnual"] = "semi_annual";
+  ProductItemInterval2["Year"] = "year";
+  ProductItemInterval2["Multiple"] = "multiple";
+  return ProductItemInterval2;
+})(ProductItemInterval || {});
 
 // src/sdk/customers/cusEnums.ts
-var import_zod3 = require("zod");
-var CustomerExpandEnum = import_zod3.z.enum([
+var import_zod = require("zod");
+var CustomerExpandEnum = import_zod.z.enum([
   "invoices",
   "rewards",
   "trials_used",
@@ -561,71 +539,161 @@ var CustomerExpandEnum = import_zod3.z.enum([
 ]);
 
 // src/sdk/customers/cusTypes.ts
-var import_zod4 = require("zod");
-var CustomerDataSchema = import_zod4.z.object({
-  name: import_zod4.z.string().nullish(),
-  email: import_zod4.z.string().nullish(),
-  fingerprint: import_zod4.z.string().nullish()
+var import_zod2 = require("zod");
+var CoreCusFeatureSchema = import_zod2.z.object({
+  unlimited: import_zod2.z.boolean().optional(),
+  interval: import_zod2.z.nativeEnum(ProductItemInterval).optional(),
+  balance: import_zod2.z.number().optional(),
+  usage: import_zod2.z.number().optional(),
+  included_usage: import_zod2.z.number().optional(),
+  next_reset_at: import_zod2.z.number().optional(),
+  overage_allowed: import_zod2.z.boolean().optional(),
+  usage_limit: import_zod2.z.number().optional(),
+  breakdown: import_zod2.z.array(
+    import_zod2.z.object({
+      interval: import_zod2.z.nativeEnum(ProductItemInterval),
+      balance: import_zod2.z.number().optional(),
+      usage: import_zod2.z.number().optional(),
+      included_usage: import_zod2.z.number().optional(),
+      next_reset_at: import_zod2.z.number().optional()
+    })
+  ).optional(),
+  credit_schema: import_zod2.z.array(
+    import_zod2.z.object({
+      feature_id: import_zod2.z.string(),
+      credit_amount: import_zod2.z.number()
+    })
+  ).optional()
+});
+var CustomerDataSchema = import_zod2.z.object({
+  name: import_zod2.z.string().nullish(),
+  email: import_zod2.z.string().nullish(),
+  fingerprint: import_zod2.z.string().nullish()
 });
-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 CreateCustomerParamsSchema = import_zod2.z.object({
+  id: import_zod2.z.string().nullish(),
+  email: import_zod2.z.string().nullish(),
+  name: import_zod2.z.string().nullish(),
+  fingerprint: import_zod2.z.string().nullish(),
+  metadata: import_zod2.z.record(import_zod2.z.any()).optional(),
+  expand: import_zod2.z.array(CustomerExpandEnum).optional()
 });
-var BillingPortalParamsSchema = import_zod4.z.object({
-  return_url: import_zod4.z.string().optional()
+var BillingPortalParamsSchema = import_zod2.z.object({
+  return_url: import_zod2.z.string().optional()
 });
 
-// src/sdk/referrals/referralTypes.ts
+// src/sdk/general/checkTypes.ts
+var import_zod3 = require("zod");
+var CheckFeatureResultSchema = import_zod3.z.object({
+  allowed: import_zod3.z.boolean(),
+  feature_id: import_zod3.z.string(),
+  customer_id: import_zod3.z.string(),
+  entity_id: import_zod3.z.string().optional(),
+  required_balance: import_zod3.z.number()
+}).extend(CoreCusFeatureSchema.shape);
+
+// src/sdk/customers/entities/entTypes.ts
+var import_zod4 = require("zod");
+var EntityDataSchema = import_zod4.z.object({
+  name: import_zod4.z.string().optional(),
+  feature_id: import_zod4.z.string()
+});
+
+// src/sdk/general/genTypes.ts
 var import_zod5 = require("zod");
-var CreateReferralCodeParamsSchema = import_zod5.z.object({
+var CancelParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  product_id: import_zod5.z.string(),
+  entity_id: import_zod5.z.string().optional(),
+  cancel_immediately: import_zod5.z.boolean().optional()
+});
+var CancelResultSchema = import_zod5.z.object({
+  success: import_zod5.z.boolean(),
   customer_id: import_zod5.z.string(),
-  program_id: import_zod5.z.string()
+  product_id: import_zod5.z.string()
 });
-var RedeemReferralCodeParamsSchema = import_zod5.z.object({
+var TrackParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  value: import_zod5.z.number().optional(),
+  feature_id: import_zod5.z.string().optional(),
+  event_name: import_zod5.z.string().optional(),
+  entity_id: import_zod5.z.string().optional(),
+  customer_data: import_zod5.z.any().optional(),
+  idempotency_key: import_zod5.z.string().optional(),
+  entity_data: import_zod5.z.any().optional()
+});
+var TrackResultSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
   code: import_zod5.z.string(),
-  customer_id: import_zod5.z.string()
+  customer_id: import_zod5.z.string(),
+  feature_id: import_zod5.z.string().optional(),
+  event_name: import_zod5.z.string().optional()
+});
+var CheckParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  feature_id: import_zod5.z.string().optional(),
+  product_id: import_zod5.z.string().optional(),
+  entity_id: import_zod5.z.string().optional(),
+  customer_data: import_zod5.z.any().optional(),
+  required_balance: import_zod5.z.number().optional(),
+  send_event: import_zod5.z.boolean().optional(),
+  with_preview: import_zod5.z.boolean().optional(),
+  entity_data: EntityDataSchema.optional()
+});
+var QueryRangeEnum = import_zod5.z.enum(["24h", "7d", "30d", "90d", "last_cycle"]);
+var QueryParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  feature_id: import_zod5.z.string().or(import_zod5.z.array(import_zod5.z.string())),
+  range: QueryRangeEnum.optional()
 });
 
-// src/sdk/general/attachTypes.ts
+// src/sdk/referrals/referralTypes.ts
 var import_zod6 = require("zod");
-var AttachFeatureOptionsSchema = import_zod6.z.object({
-  feature_id: import_zod6.z.string(),
-  quantity: import_zod6.z.number()
-});
-var AttachParamsSchema = import_zod6.z.object({
+var CreateReferralCodeParamsSchema = import_zod6.z.object({
   customer_id: import_zod6.z.string(),
-  product_id: import_zod6.z.string().optional(),
-  entity_id: import_zod6.z.string().optional(),
-  options: import_zod6.z.array(AttachFeatureOptionsSchema).optional(),
-  product_ids: import_zod6.z.array(import_zod6.z.string()).optional(),
-  free_trial: import_zod6.z.boolean().optional(),
-  success_url: import_zod6.z.string().optional(),
-  metadata: import_zod6.z.record(import_zod6.z.string()).optional(),
-  force_checkout: import_zod6.z.boolean().optional(),
-  customer_data: CustomerDataSchema.optional(),
-  entity_data: import_zod6.z.any().optional(),
-  checkout_session_params: import_zod6.z.record(import_zod6.z.any()).optional(),
-  reward: import_zod6.z.string().optional()
+  program_id: import_zod6.z.string()
 });
-var AttachResultSchema = import_zod6.z.object({
-  checkout_url: import_zod6.z.string().optional(),
-  customer_id: import_zod6.z.string(),
-  product_ids: import_zod6.z.array(import_zod6.z.string()),
+var RedeemReferralCodeParamsSchema = import_zod6.z.object({
   code: import_zod6.z.string(),
-  message: import_zod6.z.string(),
-  customer_data: import_zod6.z.any().optional()
+  customer_id: import_zod6.z.string()
 });
-var CheckoutParamsSchema = import_zod6.z.object({
-  customer_id: import_zod6.z.string(),
-  product_id: import_zod6.z.string(),
-  entity_id: import_zod6.z.string().optional(),
-  success_url: import_zod6.z.string().optional(),
+
+// src/sdk/general/attachTypes.ts
+var import_zod7 = require("zod");
+var AttachFeatureOptionsSchema = import_zod7.z.object({
+  feature_id: import_zod7.z.string(),
+  quantity: import_zod7.z.number()
+});
+var AttachParamsSchema = import_zod7.z.object({
+  customer_id: import_zod7.z.string(),
+  product_id: import_zod7.z.string().optional(),
+  entity_id: import_zod7.z.string().optional(),
+  options: import_zod7.z.array(AttachFeatureOptionsSchema).optional(),
+  product_ids: import_zod7.z.array(import_zod7.z.string()).optional(),
+  free_trial: import_zod7.z.boolean().optional(),
+  success_url: import_zod7.z.string().optional(),
+  metadata: import_zod7.z.record(import_zod7.z.string()).optional(),
+  force_checkout: import_zod7.z.boolean().optional(),
   customer_data: CustomerDataSchema.optional(),
-  options: import_zod6.z.array(AttachFeatureOptionsSchema).optional()
+  entity_data: import_zod7.z.any().optional(),
+  checkout_session_params: import_zod7.z.record(import_zod7.z.any()).optional(),
+  reward: import_zod7.z.string().optional()
+});
+var AttachResultSchema = import_zod7.z.object({
+  checkout_url: import_zod7.z.string().optional(),
+  customer_id: import_zod7.z.string(),
+  product_ids: import_zod7.z.array(import_zod7.z.string()),
+  code: import_zod7.z.string(),
+  message: import_zod7.z.string(),
+  customer_data: import_zod7.z.any().optional()
+});
+var CheckoutParamsSchema = import_zod7.z.object({
+  customer_id: import_zod7.z.string(),
+  product_id: import_zod7.z.string(),
+  entity_id: import_zod7.z.string().optional(),
+  success_url: import_zod7.z.string().optional(),
+  customer_data: CustomerDataSchema.optional(),
+  options: import_zod7.z.array(AttachFeatureOptionsSchema).optional()
 });
 
 // src/libraries/react/errorUtils/logFetchError.ts
@@ -739,6 +807,11 @@ async function openBillingPortalMethod(params) {
   const res = await this.post(`${this.prefix}/billing_portal`, snakeParams);
   return res;
 }
+async function queryMethod(params) {
+  let snakeParams = toSnakeCase(params);
+  const res = await this.post(`${this.prefix}/query`, snakeParams);
+  return res;
+}
 
 // src/libraries/react/client/clientProdMethods.ts
 async function listProductsMethod() {
@@ -922,6 +995,7 @@ var AutumnClient = class {
   track = trackMethod.bind(this);
   openBillingPortal = openBillingPortalMethod.bind(this);
   setupPayment = setupPaymentMethod.bind(this);
+  query = queryMethod.bind(this);
   entities = {
     create: createEntityMethod.bind(this),
     get: getEntityMethod.bind(this),
@@ -961,7 +1035,8 @@ var AutumnContext = (0, import_react.createContext)({
     },
     setComponent: () => {
     }
-  }
+  },
+  paywallRef: { current: null }
 });
 var useAutumnContext = ({
   AutumnContext: AutumnContext2,
@@ -975,387 +1050,39 @@ var useAutumnContext = ({
   return context;
 };
 
-// src/libraries/react/hooks/usePricingTableBase.tsx
+// src/libraries/react/hooks/useAnalytics.tsx
 var import_swr = __toESM(require("swr"));
-var mergeProductDetails = (products, productDetails) => {
-  if (!products) {
-    return null;
-  }
-  if (!productDetails) {
-    return products.map((product) => {
-      if (product.base_variant_id) {
-        let baseProduct = products.find(
-          (p) => p.id === product.base_variant_id
-        );
-        if (baseProduct) {
-          return {
-            ...product,
-            name: baseProduct.name
-          };
-        }
-      }
-      return product;
-    });
-  }
-  let fetchedProducts = structuredClone(products);
-  let mergedProducts = [];
-  for (const overrideDetails of productDetails) {
-    if (!overrideDetails.id) {
-      let properties = {};
-      let overrideItems2 = overrideDetails.items?.map((item) => ({
-        display: {
-          primary_text: item.primaryText,
-          secondary_text: item.secondaryText
-        }
-      }));
-      let overridePrice2 = overrideDetails.price;
-      if (overrideDetails.price) {
-        properties.is_free = false;
-        overrideItems2 = [
-          {
-            display: {
-              primary_text: overridePrice2?.primaryText,
-              secondary_text: overridePrice2?.secondaryText
-            }
-          },
-          ...overrideItems2 || []
-        ];
-      }
-      if (!overrideItems2 || overrideItems2.length === 0) {
-        overrideItems2 = [
-          {
-            display: {
-              primary_text: ""
-            }
-          }
-        ];
-      }
-      mergedProducts.push({
-        display: {
-          name: overrideDetails.name,
-          description: overrideDetails.description,
-          button_text: overrideDetails.buttonText,
-          recommend_text: overrideDetails.recommendText,
-          everything_from: overrideDetails.everythingFrom,
-          button_url: overrideDetails.buttonUrl
-        },
-        items: overrideItems2,
-        properties
-      });
-      continue;
-    }
-    let fetchedProduct = fetchedProducts.find(
-      (p) => p.id === overrideDetails.id
-    );
-    if (!fetchedProduct) {
-      continue;
-    }
-    let displayName = fetchedProduct.name;
-    let baseVariantId = fetchedProduct.base_variant_id;
-    if (baseVariantId) {
-      let baseProduct = fetchedProducts.find((p) => p.id === baseVariantId);
-      if (baseProduct) {
-        displayName = baseProduct.name;
-      }
-    }
-    displayName = overrideDetails.name || displayName;
-    const originalIsFree = fetchedProduct.properties?.is_free;
-    let overrideProperties = fetchedProduct.properties || {};
-    let overrideItems = overrideDetails.items;
-    let overridePrice = overrideDetails.price;
-    let mergedItems = [];
-    if (overridePrice) {
-      overrideProperties.is_free = false;
-      if (originalIsFree || overrideItems !== void 0) {
-        mergedItems.push({
-          display: {
-            primary_text: overridePrice.primaryText,
-            secondary_text: overridePrice.secondaryText
-          }
-        });
-      } else {
-        fetchedProduct.items[0].display = {
-          primary_text: overridePrice.primaryText,
-          secondary_text: overridePrice.secondaryText
-        };
-      }
-    } else {
-      if (overrideItems && !originalIsFree) {
-        mergedItems.push(fetchedProduct.items[0]);
-      }
-    }
-    if (overrideItems) {
-      for (const overrideItem of overrideItems) {
-        if (!overrideItem.featureId) {
-          mergedItems.push({
-            display: {
-              primary_text: overrideItem.primaryText,
-              secondary_text: overrideItem.secondaryText
-            }
-          });
-        } else {
-          let fetchedItem = fetchedProduct.items.find(
-            (i) => i.feature_id === overrideItem.featureId
-          );
-          if (!fetchedItem) {
-            console.error(
-              `Feature with id ${overrideItem.featureId} not found for product ${fetchedProduct.id}`
-            );
-            continue;
-          }
-          mergedItems.push({
-            ...fetchedItem,
-            display: {
-              primary_text: overrideItem.primaryText || fetchedItem.display?.primary_text,
-              secondary_text: overrideItem.secondaryText || fetchedItem.display?.secondary_text
-            }
-          });
-        }
-      }
-    } else {
-      mergedItems = fetchedProduct.items;
-    }
-    const mergedProduct = {
-      ...fetchedProduct,
-      items: mergedItems,
-      properties: overrideProperties,
-      display: {
-        name: displayName,
-        description: overrideDetails.description,
-        button_text: overrideDetails.buttonText,
-        recommend_text: overrideDetails.recommendText,
-        everything_from: overrideDetails.everythingFrom,
-        button_url: overrideDetails.buttonUrl
-      }
-    };
-    mergedProducts.push(mergedProduct);
-  }
-  return mergedProducts;
-};
-var defaultSWRConfig = {
-  refreshInterval: 0
-};
-var usePricingTableBase = ({
-  AutumnContext: AutumnContext2,
-  params
-}) => {
+var useAnalytics = (params) => {
   const context = useAutumnContext({
-    AutumnContext: AutumnContext2,
-    name: "usePricingTable"
+    AutumnContext,
+    name: "useAnalytics"
   });
   const client = context.client;
   const fetcher = async () => {
     try {
-      const { data: data2, error: error2 } = await client.products.list();
+      const { data: data2, error: error2 } = await client.query(params);
       if (error2) throw error2;
-      return data2?.list || [];
+      return data2;
     } catch (error2) {
       throw new AutumnError({
-        message: "Failed to fetch pricing table products",
-        code: "failed_to_fetch_pricing_table_products"
+        message: "Failed to fetch analytics",
+        code: "fetch_analytics_failed"
       });
     }
   };
   const { data, error, mutate } = (0, import_swr.default)(
-    "pricing-table",
+    "analytics",
     fetcher,
-    { ...defaultSWRConfig }
+    { refreshInterval: 0 }
   );
   return {
-    products: mergeProductDetails(data || [], params?.productDetails),
+    data: data?.list,
     isLoading: !error && !data,
     error,
     refetch: mutate
   };
 };
-
-// src/libraries/react/hooks/useAutumnBase.tsx
-var useAutumnBase = ({
-  AutumnContext: AutumnContext2,
-  refetchCustomer
-}) => {
-  const context = useAutumnContext({
-    AutumnContext: AutumnContext2,
-    name: "useAutumn"
-  });
-  const { attachDialog, paywallDialog } = context;
-  const client = context.client;
-  const { refetch: refetchPricingTable } = usePricingTableBase({
-    AutumnContext: AutumnContext2
-  });
-  let {
-    open: attachOpen,
-    setProps: setAttachProps,
-    setOpen: setAttachOpen,
-    setComponent: setAttachComponent
-  } = attachDialog;
-  let {
-    setProps: setCheckProps,
-    setOpen: setCheckOpen,
-    setComponent: setPaywallComponent
-  } = paywallDialog;
-  const attachWithoutDialog = async (params) => {
-    const result = await client.attach(params);
-    if (result.error) {
-      return result;
-    }
-    let data = result.data;
-    if (data?.checkout_url && typeof window !== "undefined") {
-      if (params.openInNewTab) {
-        window.open(data.checkout_url, "_blank");
-      } else {
-        window.location.href = data.checkout_url;
-      }
-    }
-    await refetchPricingTable();
-    if (refetchCustomer) {
-      await refetchCustomer();
-    }
-    if (setAttachOpen) {
-      setAttachOpen(false);
-    }
-    return result;
-  };
-  const checkout = async (params) => {
-    const { data, error } = await client.checkout(params);
-    const { dialog, ...rest } = params;
-    if (error) {
-      return { data, error };
-    }
-    if (data.url) {
-      if (params.openInNewTab) {
-        window.open(data.url, "_blank");
-      } else {
-        window.location.href = data.url;
-      }
-      return { data, error };
-    }
-    if (params.dialog) {
-      setAttachProps({ checkoutResult: data, attachParams: rest });
-      setAttachComponent(params.dialog);
-      setAttachOpen(true);
-    }
-    return { data, error };
-  };
-  const attachWithDialog = async (params) => {
-    let { ...rest } = params;
-    const { productId, entityId, entityData } = params;
-    const checkRes = await client.check({
-      productId,
-      entityId,
-      entityData,
-      withPreview: true
-    });
-    if (checkRes.error) {
-      return checkRes;
-    }
-    let preview = checkRes.data.preview;
-    if (!preview) {
-      return await attachWithoutDialog(rest);
-    } else {
-      setAttachProps({ preview, attachParams: rest });
-      setAttachOpen(true);
-    }
-    return checkRes;
-  };
-  const attach = async (params) => {
-    const { dialog } = params;
-    let finalDialog = dialog;
-    if (finalDialog && !attachOpen) {
-      setAttachComponent(finalDialog);
-      return await attachWithDialog(params);
-    }
-    return await attachWithoutDialog(params);
-  };
-  const cancel = async (params) => {
-    const res = await client.cancel(params);
-    if (res.error) {
-      return res;
-    }
-    return res;
-  };
-  const check = async (params) => {
-    let { dialog, withPreview } = params;
-    if (dialog) {
-      setPaywallComponent(dialog);
-    }
-    const res = await client.check({
-      ...params,
-      withPreview: withPreview || dialog ? true : false
-    });
-    if (res.error) {
-      return res;
-    }
-    let data = res.data;
-    if (data && data.preview && dialog) {
-      let preview = data.preview;
-      setCheckProps({ preview });
-      setCheckOpen(true);
-    }
-    return res;
-  };
-  const track = async (params) => {
-    const res = await client.track(params);
-    if (res.error) {
-      return res;
-    }
-    return res;
-  };
-  const openBillingPortal = async (params) => {
-    let defaultParams = {
-      openInNewTab: false
-    };
-    let finalParams = {
-      ...defaultParams,
-      ...params
-    };
-    const res = await client.openBillingPortal(finalParams);
-    if (res.error) {
-      return res;
-    }
-    let data = res.data;
-    if (data?.url && typeof window !== "undefined") {
-      if (finalParams.openInNewTab) {
-        window.open(data.url, "_blank");
-      } else {
-        window.open(data.url, "_self");
-      }
-      return res;
-    } else {
-      return res;
-    }
-  };
-  const setupPayment = async (params) => {
-    let defaultParams = {
-      openInNewTab: false
-    };
-    let finalParams = {
-      ...defaultParams,
-      ...params || {}
-    };
-    const res = await client.setupPayment(finalParams);
-    if (res.data?.url && typeof window !== "undefined") {
-      if (finalParams.openInNewTab) {
-        window.open(res.data.url, "_blank");
-      } else {
-        window.open(res.data.url, "_self");
-      }
-      return res;
-    } else {
-      return res;
-    }
-  };
-  return {
-    attach,
-    check,
-    track,
-    cancel,
-    openBillingPortal,
-    setupPayment,
-    checkout
-  };
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  useAutumnBase
+  useAnalytics
 });