autumn-js 0.0.108 → 0.0.109

package/dist/libraries/react/components/attach-dialog/attach-dialog-synced.js

@@ -39,7 +39,7 @@ __export(attach_dialog_synced_exports, {
 });
 module.exports = __toCommonJS(attach_dialog_synced_exports);
 var AccordionPrimitive2 = __toESM(require("@radix-ui/react-accordion"));
-var import_react11 = require("react");
+var import_react12 = require("react");
 
 // ../node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
 function r(e) {
@@ -5101,13 +5101,15 @@ var getAttachContent = (checkoutResult) => {
 };
 
 // src/libraries/react/BaseAutumnProvider.tsx
-var import_react6 = require("react");
+var import_react7 = require("react");
+var import_react8 = require("react");
 
-// src/libraries/react/hooks/useDialog.tsx
+// src/libraries/react/hooks/helpers/useDialog.tsx
 var import_react4 = require("react");
 
 // src/libraries/react/hooks/useCustomerBase.tsx
 var import_swr2 = __toESM(require("swr"));
+var import_react6 = require("react");
 
 // src/libraries/react/errorUtils/logAuthError.ts
 var logAuthError = async (response) => {
@@ -5194,6 +5196,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";
@@ -5571,60 +5579,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",
@@ -5634,71 +5614,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 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 CustomerDataSchema = import_zod2.z.object({
+  name: import_zod2.z.string().nullish(),
+  email: import_zod2.z.string().nullish(),
+  fingerprint: import_zod2.z.string().nullish()
 });
-var BillingPortalParamsSchema = import_zod4.z.object({
-  return_url: import_zod4.z.string().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_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
@@ -5812,6 +5882,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() {
@@ -5995,6 +6070,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),
@@ -6034,7 +6110,8 @@ var AutumnContext = (0, import_react5.createContext)({
     },
     setComponent: () => {
     }
-  }
+  },
+  paywallRef: { current: null }
 });
 var useAutumnContext = ({
   AutumnContext: AutumnContext2,
@@ -6209,14 +6286,9 @@ var defaultSWRConfig = {
   refreshInterval: 0
 };
 var usePricingTableBase = ({
-  AutumnContext: AutumnContext2,
+  client,
   params
 }) => {
-  const context = useAutumnContext({
-    AutumnContext: AutumnContext2,
-    name: "usePricingTable"
-  });
-  const client = context.client;
   const fetcher = async () => {
     try {
       const { data: data2, error: error2 } = await client.products.list();
@@ -6242,31 +6314,15 @@ var usePricingTableBase = ({
   };
 };
 
-// src/libraries/react/hooks/useAutumnBase.tsx
+// src/libraries/react/hooks/helpers/useAutumnBase.tsx
 var useAutumnBase = ({
-  AutumnContext: AutumnContext2,
+  // AutumnContext,
+  context,
+  client,
   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 { attachDialog, paywallDialog } = context || {};
+  const { refetch: refetchPricingTable } = usePricingTableBase({ client });
   const attachWithoutDialog = async (params) => {
     const result = await client.attach(params);
     if (result.error) {
@@ -6284,9 +6340,7 @@ var useAutumnBase = ({
     if (refetchCustomer) {
       await refetchCustomer();
     }
-    if (setAttachOpen) {
-      setAttachOpen(false);
-    }
+    attachDialog?.setOpen(false);
     return result;
   };
   const checkout = async (params) => {
@@ -6304,9 +6358,9 @@ var useAutumnBase = ({
       return { data, error };
     }
     if (params.dialog) {
-      setAttachProps({ checkoutResult: data, attachParams: rest });
-      setAttachComponent(params.dialog);
-      setAttachOpen(true);
+      attachDialog?.setProps({ checkoutResult: data, attachParams: rest });
+      attachDialog?.setComponent(params.dialog);
+      attachDialog?.setOpen(true);
     }
     return { data, error };
   };
@@ -6326,16 +6380,15 @@ var useAutumnBase = ({
     if (!preview) {
       return await attachWithoutDialog(rest);
     } else {
-      setAttachProps({ preview, attachParams: rest });
-      setAttachOpen(true);
+      attachDialog?.setProps({ preview, attachParams: rest });
+      attachDialog?.setOpen(true);
     }
     return checkRes;
   };
   const attach = async (params) => {
     const { dialog } = params;
-    let finalDialog = dialog;
-    if (finalDialog && !attachOpen) {
-      setAttachComponent(finalDialog);
+    if (dialog && !attachDialog?.open) {
+      attachDialog?.setComponent(dialog);
       return await attachWithDialog(params);
     }
     return await attachWithoutDialog(params);
@@ -6347,26 +6400,6 @@ var useAutumnBase = ({
     }
     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) {
@@ -6420,7 +6453,7 @@ var useAutumnBase = ({
   };
   return {
     attach,
-    check,
+    // check,
     track,
     cancel,
     openBillingPortal,
@@ -6429,7 +6462,7 @@ var useAutumnBase = ({
   };
 };
 
-// src/libraries/react/hooks/handleAllowed.ts
+// src/libraries/react/hooks/helpers/handleCheck.ts
 var getCusFeature = ({
   customer,
   featureId,
@@ -6452,14 +6485,10 @@ var getCusFeature = ({
     requiredBalance
   };
 };
-var handleFeatureAllowed = ({
-  customer,
-  params
+var getFeatureAllowed = ({
+  cusFeature,
+  requiredBalance
 }) => {
-  let { cusFeature, requiredBalance } = getCusFeature({
-    customer,
-    featureId: params.featureId
-  });
   if (!cusFeature) return false;
   if (cusFeature.type == "static") return true;
   if (cusFeature.unlimited || cusFeature.overage_allowed) return true;
@@ -6469,37 +6498,97 @@ var handleFeatureAllowed = ({
   }
   return (cusFeature.balance || 0) >= requiredBalance;
 };
-var handleAllowed = ({
+var handleFeatureCheck = ({
   customer,
+  isEntity,
   params
 }) => {
-  if (!customer) return false;
-  if (!params.featureId && !params.productId) {
-    throw new Error("allowed() requires either featureId or productId");
+  let { cusFeature, requiredBalance } = getCusFeature({
+    customer,
+    featureId: params.featureId
+  });
+  let allowed = getFeatureAllowed({ cusFeature, requiredBalance });
+  let result = {
+    allowed,
+    feature_id: params.featureId,
+    customer_id: isEntity ? customer.customer_id : customer.id,
+    required_balance: requiredBalance,
+    ...cusFeature
+  };
+  if (isEntity) {
+    result.entity_id = customer.id;
+  }
+  return CheckFeatureResultSchema.parse(result);
+};
+var handleProductCheck = ({
+  customer,
+  isEntity,
+  params
+}) => {
+  let product = customer.products.find((p) => p.id == params.productId);
+  let allowed = product?.status === "active";
+  let result = {
+    allowed,
+    customer_id: isEntity ? customer.customer_id : customer.id,
+    product_id: params.productId
+  };
+  if (product) {
+    result.status = product.status;
   }
-  if (params.featureId) {
-    return handleFeatureAllowed({ customer, params });
+  if (isEntity) {
+    result.entity_id = customer.id;
   }
-  if (params.productId) {
-    let product = customer.products.find((p) => p.id == params.productId);
-    if (!product) return false;
-    let status = product.status;
-    if (status == "scheduled") return false;
-    return true;
+  return result;
+};
+var openDialog = ({
+  result,
+  params,
+  context
+}) => {
+  let open = result.allowed === false && params.dialog && context;
+  if (!open) return;
+  const isInRenderCycle = (() => {
+    const stack = new Error().stack || "";
+    return stack.includes("renderWithHooks") || stack.includes("updateFunctionComponent") || stack.includes("beginWork") || stack.includes("performUnitOfWork") || stack.includes("workLoop") || stack.includes("Component.render") || stack.includes("FunctionComponent");
+  })();
+  if (isInRenderCycle) {
+    context.paywallRef.current = {
+      component: params.dialog,
+      open: true,
+      props: params
+    };
+  } else {
+    context.paywallDialog.setComponent(params.dialog);
+    context.paywallDialog.setProps(params);
+    context.paywallDialog.setOpen(true);
   }
-  return false;
+};
+var handleCheck2 = ({
+  customer,
+  isEntity,
+  params,
+  context
+}) => {
+  if (!customer) {
+    return {
+      allowed: false,
+      feature_id: "",
+      customer_id: "",
+      required_balance: 0
+    };
+  }
+  if (!params.featureId && !params.productId) {
+    throw new Error("allowed() requires either featureId or productId");
+  }
+  let result;
+  if (params.featureId)
+    result = handleFeatureCheck({ customer, params, isEntity });
+  if (params.productId)
+    result = handleProductCheck({ customer, params, isEntity });
+  return result;
 };
 
 // src/libraries/react/hooks/useCustomerBase.tsx
-var emptyDefaultFunctions = {
-  attach: "",
-  check: "",
-  track: "",
-  cancel: "",
-  openBillingPortal: "",
-  setupPayment: "",
-  checkout: ""
-};
 var useCustomerBase = ({
   params,
   AutumnContext: AutumnContext2,
@@ -6510,7 +6599,6 @@ var useCustomerBase = ({
     context = useAutumnContext({
       AutumnContext: AutumnContext2,
       name: "useCustomer"
-      // errorIfNotInitialized: !authClientExists,
     });
   }
   if (!client) {
@@ -6540,13 +6628,13 @@ var useCustomerBase = ({
     fallbackData: null,
     ...params?.swrConfig
   });
-  let autumnFunctions = emptyDefaultFunctions;
-  if (AutumnContext2) {
-    autumnFunctions = useAutumnBase({
-      AutumnContext: AutumnContext2,
-      refetchCustomer: mutate
-    });
-  }
+  const autumnFunctions = useAutumnBase({
+    context,
+    client,
+    refetchCustomer: mutate
+  });
+  (0, import_react6.useEffect)(() => {
+  }, [context?.paywallRef.current]);
   return {
     customer: error ? null : customer,
     isLoading,
@@ -6556,7 +6644,30 @@ var useCustomerBase = ({
     createEntity: client.entities.create,
     createReferralCode: client.referrals.createCode,
     redeemReferralCode: client.referrals.redeemCode,
-    allowed: (params2) => handleAllowed({ customer, params: params2 })
+    check: (params2) => {
+      const result = handleCheck2({
+        customer,
+        params: params2,
+        isEntity: false,
+        context
+      });
+      openDialog({
+        result,
+        params: params2,
+        context
+      });
+      return result;
+    },
+    /** @deprecated Use check() instead */
+    allowed: (params2) => {
+      const result = handleCheck2({
+        customer,
+        params: params2,
+        isEntity: false,
+        context
+      });
+      return result.allowed;
+    }
   };
 };
 
@@ -6576,27 +6687,32 @@ var useCustomer = (params) => {
 
 // src/libraries/react/hooks/useEntityBase.tsx
 var import_swr3 = __toESM(require("swr"));
-var import_react7 = require("react");
+var import_react9 = require("react");
+
+// src/libraries/react/hooks/useAnalytics.tsx
+var import_swr4 = __toESM(require("swr"));
+
+// src/libraries/react/hooks/usePaywall.tsx
+var import_swr5 = __toESM(require("swr"));
 
 // src/libraries/react/components/check-dialog/check-dialog-synced.tsx
-var import_react8 = require("react");
 var import_jsx_runtime13 = require("react/jsx-runtime");
 
 // src/libraries/react/components/pricing-table/pricing-table-synced.tsx
-var import_react9 = __toESM(require("react"));
-var import_react10 = require("react");
+var import_react10 = __toESM(require("react"));
+var import_react11 = require("react");
 
 // src/libraries/react/components/ui/switch.tsx
-var React30 = __toESM(require("react"));
+var React32 = __toESM(require("react"));
 
 // ../node_modules/.pnpm/@radix-ui+react-switch@1.2.5_@types+react-dom@19.1.6_@types+react@19.1.8__@types+react@19.1.8_uhx276sbw7dr3tfricp4xfbxsq/node_modules/@radix-ui/react-switch/dist/index.mjs
-var React29 = __toESM(require("react"), 1);
+var React31 = __toESM(require("react"), 1);
 
 // ../node_modules/.pnpm/@radix-ui+react-use-previous@1.1.1_@types+react@19.1.8_react@19.1.0/node_modules/@radix-ui/react-use-previous/dist/index.mjs
-var React27 = __toESM(require("react"), 1);
+var React29 = __toESM(require("react"), 1);
 function usePrevious(value) {
-  const ref = React27.useRef({ value, previous: value });
-  return React27.useMemo(() => {
+  const ref = React29.useRef({ value, previous: value });
+  return React29.useMemo(() => {
     if (ref.current.value !== value) {
       ref.current.previous = ref.current.value;
       ref.current.value = value;
@@ -6606,9 +6722,9 @@ function usePrevious(value) {
 }
 
 // ../node_modules/.pnpm/@radix-ui+react-use-size@1.1.1_@types+react@19.1.8_react@19.1.0/node_modules/@radix-ui/react-use-size/dist/index.mjs
-var React28 = __toESM(require("react"), 1);
+var React30 = __toESM(require("react"), 1);
 function useSize(element) {
-  const [size, setSize] = React28.useState(void 0);
+  const [size, setSize] = React30.useState(void 0);
   useLayoutEffect2(() => {
     if (element) {
       setSize({ width: element.offsetWidth, height: element.offsetHeight });
@@ -6647,7 +6763,7 @@ var import_jsx_runtime14 = require("react/jsx-runtime");
 var SWITCH_NAME = "Switch";
 var [createSwitchContext, createSwitchScope] = createContextScope(SWITCH_NAME);
 var [SwitchProvider, useSwitchContext] = createSwitchContext(SWITCH_NAME);
-var Switch = React29.forwardRef(
+var Switch = React31.forwardRef(
   (props, forwardedRef) => {
     const {
       __scopeSwitch,
@@ -6661,9 +6777,9 @@ var Switch = React29.forwardRef(
       form,
       ...switchProps
     } = props;
-    const [button, setButton] = React29.useState(null);
+    const [button, setButton] = React31.useState(null);
     const composedRefs = useComposedRefs(forwardedRef, (node) => setButton(node));
-    const hasConsumerStoppedPropagationRef = React29.useRef(false);
+    const hasConsumerStoppedPropagationRef = React31.useRef(false);
     const isFormControl = button ? form || !!button.closest("form") : true;
     const [checked, setChecked] = useControllableState({
       prop: checkedProp,
@@ -6713,7 +6829,7 @@ var Switch = React29.forwardRef(
 );
 Switch.displayName = SWITCH_NAME;
 var THUMB_NAME = "SwitchThumb";
-var SwitchThumb = React29.forwardRef(
+var SwitchThumb = React31.forwardRef(
   (props, forwardedRef) => {
     const { __scopeSwitch, ...thumbProps } = props;
     const context = useSwitchContext(THUMB_NAME, __scopeSwitch);
@@ -6730,7 +6846,7 @@ var SwitchThumb = React29.forwardRef(
 );
 SwitchThumb.displayName = THUMB_NAME;
 var BUBBLE_INPUT_NAME = "SwitchBubbleInput";
-var SwitchBubbleInput = React29.forwardRef(
+var SwitchBubbleInput = React31.forwardRef(
   ({
     __scopeSwitch,
     control,
@@ -6738,11 +6854,11 @@ var SwitchBubbleInput = React29.forwardRef(
     bubbles = true,
     ...props
   }, forwardedRef) => {
-    const ref = React29.useRef(null);
+    const ref = React31.useRef(null);
     const composedRefs = useComposedRefs(ref, forwardedRef);
     const prevChecked = usePrevious(checked);
     const controlSize = useSize(control);
-    React29.useEffect(() => {
+    React31.useEffect(() => {
       const input = ref.current;
       if (!input) return;
       const inputProto = window.HTMLInputElement.prototype;
@@ -6787,7 +6903,7 @@ var Thumb = SwitchThumb;
 
 // src/libraries/react/components/ui/switch.tsx
 var import_jsx_runtime15 = require("react/jsx-runtime");
-var Switch2 = React30.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+var Switch2 = React32.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
   Root2,
   {
     className: cn(
@@ -6829,15 +6945,15 @@ if (typeof document !== "undefined") {
 
 // src/libraries/react/components/pricing-table/pricing-table-synced.tsx
 var import_jsx_runtime17 = require("react/jsx-runtime");
-var PricingTableContext = (0, import_react10.createContext)({
+var PricingTableContext = (0, import_react11.createContext)({
   isAnnualToggle: false,
   setIsAnnualToggle: () => {
   },
   products: [],
   showFeatures: true
 });
-var PricingCardButton = import_react9.default.forwardRef(({ recommended, children, className, onClick, ...props }, ref) => {
-  const [loading, setLoading] = (0, import_react10.useState)(false);
+var PricingCardButton = import_react10.default.forwardRef(({ recommended, children, className, onClick, ...props }, ref) => {
+  const [loading, setLoading] = (0, import_react11.useState)(false);
   const handleClick = async (e) => {
     setLoading(true);
     try {
@@ -6876,11 +6992,11 @@ var PricingCardButton = import_react9.default.forwardRef(({ recommended, childre
 PricingCardButton.displayName = "PricingCardButton";
 
 // src/libraries/react/components/ui/accordion.tsx
-var React32 = __toESM(require("react"));
+var React34 = __toESM(require("react"));
 var AccordionPrimitive = __toESM(require("@radix-ui/react-accordion"));
 var import_jsx_runtime18 = require("react/jsx-runtime");
 var Accordion = AccordionPrimitive.Root;
-var AccordionItem = React32.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+var AccordionItem = React34.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
   AccordionPrimitive.Item,
   {
     ref,
@@ -6889,7 +7005,7 @@ var AccordionItem = React32.forwardRef(({ className, ...props }, ref) => /* @__P
   }
 ));
 AccordionItem.displayName = "AccordionItem";
-var AccordionTrigger = React32.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AccordionPrimitive.Header, { className: "au-flex", children: /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(
+var AccordionTrigger = React34.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AccordionPrimitive.Header, { className: "au-flex", children: /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(
   AccordionPrimitive.Trigger,
   {
     ref,
@@ -6905,7 +7021,7 @@ var AccordionTrigger = React32.forwardRef(({ className, children, ...props }, re
   }
 ) }));
 AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName;
-var AccordionContent = React32.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+var AccordionContent = React34.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
   AccordionPrimitive.Content,
   {
     ref,
@@ -6917,12 +7033,12 @@ var AccordionContent = React32.forwardRef(({ className, children, ...props }, re
 AccordionContent.displayName = AccordionPrimitive.Content.displayName;
 
 // src/libraries/react/components/ui/popover.tsx
-var React33 = __toESM(require("react"));
+var React35 = __toESM(require("react"));
 var PopoverPrimitive = __toESM(require("@radix-ui/react-popover"));
 var import_jsx_runtime19 = require("react/jsx-runtime");
 var Popover = PopoverPrimitive.Root;
 var PopoverTrigger = PopoverPrimitive.Trigger;
-var PopoverContent = React33.forwardRef(({ className, align = "center", sideOffset = 4, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+var PopoverContent = React35.forwardRef(({ className, align = "center", sideOffset = 4, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
   PopoverPrimitive.Content,
   {
     ref,
@@ -6938,9 +7054,9 @@ var PopoverContent = React33.forwardRef(({ className, align = "center", sideOffs
 PopoverContent.displayName = PopoverPrimitive.Content.displayName;
 
 // src/libraries/react/components/ui/input.tsx
-var React34 = __toESM(require("react"));
+var React36 = __toESM(require("react"));
 var import_jsx_runtime20 = require("react/jsx-runtime");
-var Input = React34.forwardRef(
+var Input = React36.forwardRef(
   ({ className, type, onClick, ...props }, ref) => {
     return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
       "input",
@@ -6971,13 +7087,13 @@ var formatCurrency = ({
 };
 function AttachDialog(params) {
   const { attach } = useCustomer();
-  const [checkoutResult, setCheckoutResult] = (0, import_react11.useState)(params?.checkoutResult);
-  (0, import_react11.useEffect)(() => {
+  const [checkoutResult, setCheckoutResult] = (0, import_react12.useState)(params?.checkoutResult);
+  (0, import_react12.useEffect)(() => {
     if (params.checkoutResult) {
       setCheckoutResult(params.checkoutResult);
     }
   }, [params.checkoutResult]);
-  const [loading, setLoading] = (0, import_react11.useState)(false);
+  const [loading, setLoading] = (0, import_react12.useState)(false);
   if (!checkoutResult) {
     return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_jsx_runtime21.Fragment, {});
   }
@@ -7150,12 +7266,12 @@ var PrepaidItem = ({
   setCheckoutResult
 }) => {
   const { quantity = 0, billing_units: billingUnits = 1 } = item;
-  const [quantityInput, setQuantityInput] = (0, import_react11.useState)(
+  const [quantityInput, setQuantityInput] = (0, import_react12.useState)(
     (quantity / billingUnits).toString()
   );
   const { checkout } = useCustomer();
-  const [loading, setLoading] = (0, import_react11.useState)(false);
-  const [open, setOpen] = (0, import_react11.useState)(false);
+  const [loading, setLoading] = (0, import_react12.useState)(false);
+  const [open, setOpen] = (0, import_react12.useState)(false);
   const scenario = checkoutResult.product.scenario;
   const handleSave = async () => {
     setLoading(true);