autumn-js 0.0.108 → 0.0.110

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

@@ -45,7 +45,7 @@ var React24 = __toESM(require("react"), 1);
 
 // ../node_modules/.pnpm/@radix-ui+primitive@1.1.2/node_modules/@radix-ui/primitive/dist/index.mjs
 function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
-  return function handleEvent(event) {
+  return function handleEvent2(event) {
     originalEventHandler?.(event);
     if (checkForDefaultPrevented === false || !event.defaultPrevented) {
       return ourEventHandler?.(event);
@@ -2217,12 +2217,20 @@ var createLucideIcon = (iconName, iconNode) => {
   return Component;
 };
 
+// ../node_modules/.pnpm/lucide-react@0.523.0_react@19.1.0/node_modules/lucide-react/dist/esm/icons/chevron-down.js
+var __iconNode = [["path", { d: "m6 9 6 6 6-6", key: "qrunsl" }]];
+var ChevronDown = createLucideIcon("chevron-down", __iconNode);
+
+// ../node_modules/.pnpm/lucide-react@0.523.0_react@19.1.0/node_modules/lucide-react/dist/esm/icons/loader-circle.js
+var __iconNode2 = [["path", { d: "M21 12a9 9 0 1 1-6.219-8.56", key: "13zald" }]];
+var LoaderCircle = createLucideIcon("loader-circle", __iconNode2);
+
 // ../node_modules/.pnpm/lucide-react@0.523.0_react@19.1.0/node_modules/lucide-react/dist/esm/icons/x.js
-var __iconNode = [
+var __iconNode3 = [
   ["path", { d: "M18 6 6 18", key: "1bl5f8" }],
   ["path", { d: "m6 6 12 12", key: "d8bk6v" }]
 ];
-var X = createLucideIcon("x", __iconNode);
+var X = createLucideIcon("x", __iconNode3);
 
 // ../node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
 function r(e) {
@@ -4842,9 +4850,6 @@ var DialogDescription2 = React25.forwardRef(({ className, ...props }, ref) => /*
 ));
 DialogDescription2.displayName = Description.displayName;
 
-// src/libraries/react/components/check-dialog/check-dialog-synced.tsx
-var import_react4 = require("react");
-
 // src/libraries/react/components/ui/button.tsx
 var React26 = __toESM(require("react"));
 
@@ -4932,8 +4937,1472 @@ var Button = React26.forwardRef(
 );
 Button.displayName = "Button";
 
+// src/libraries/react/BaseAutumnProvider.tsx
+var import_react7 = require("react");
+var import_react8 = require("react");
+
+// 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) => {
+  if (response.status === 401) {
+    let clonedResponse = response.clone();
+    let data = await clonedResponse.json();
+    if (data.message.includes("Missing authorization header")) {
+      console.error(`[Autumn] Missing authorization header.
+
+Use the getBearerToken prop in <AutumnProvider /> to set the authorization header.
+https://docs.useautumn.com/quickstart/quickstart#5-set-up-autumnprovider`);
+      return true;
+    }
+  }
+  return false;
+};
+
+// src/sdk/error.ts
+var AutumnError = class _AutumnError extends Error {
+  message;
+  code;
+  constructor(response) {
+    super(response.message);
+    this.message = response.message;
+    this.code = response.code;
+  }
+  static fromError(error) {
+    return new _AutumnError({
+      message: error.message || "Unknown error",
+      code: error.code || "unknown_error"
+    });
+  }
+  toString() {
+    return `${this.message} (code: ${this.code})`;
+  }
+  toJSON() {
+    return {
+      message: this.message,
+      code: this.code
+    };
+  }
+};
+
+// src/sdk/general/genMethods.ts
+var handleCheckout = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/checkout", params);
+};
+var handleAttach = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/attach", params);
+};
+var handleSetupPayment = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/setup_payment", params);
+};
+var handleCancel = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/cancel", params);
+};
+var handleTrack = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/track", params);
+};
+var handleUsage = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/usage", params);
+};
+var handleCheck = async ({
+  instance,
+  params
+}) => {
+  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";
+
+// src/sdk/utils.ts
+var staticWrapper = (callback, instance, args) => {
+  if (!instance) {
+    instance = new Autumn();
+  }
+  return callback({ instance, ...args });
+};
+
+// src/sdk/customers/cusMethods.ts
+var customerMethods = (instance) => {
+  return {
+    get: (id, params) => staticWrapper(getCustomer, instance, { id, params }),
+    create: (params) => staticWrapper(createCustomer, instance, { params }),
+    update: (id, params) => staticWrapper(updateCustomer, instance, { id, params }),
+    delete: (id) => staticWrapper(deleteCustomer, instance, { id }),
+    billingPortal: (id, params) => staticWrapper(billingPortal, instance, { id, params })
+  };
+};
+var getExpandStr = (expand) => {
+  if (!expand) {
+    return "";
+  }
+  return `expand=${expand.join(",")}`;
+};
+var getCustomer = async ({
+  instance,
+  id,
+  params
+}) => {
+  if (!id) {
+    return {
+      data: null,
+      error: new AutumnError({
+        message: "Customer ID is required",
+        code: "CUSTOMER_ID_REQUIRED"
+      })
+    };
+  }
+  return instance.get(`/customers/${id}?${getExpandStr(params?.expand)}`);
+};
+var createCustomer = async ({
+  instance,
+  params
+}) => {
+  return instance.post(`/customers?${getExpandStr(params?.expand)}`, params);
+};
+var updateCustomer = async ({
+  instance,
+  id,
+  params
+}) => {
+  return instance.post(`/customers/${id}`, params);
+};
+var deleteCustomer = async ({
+  instance,
+  id
+}) => {
+  return instance.delete(`/customers/${id}`);
+};
+var billingPortal = async ({
+  instance,
+  id,
+  params
+}) => {
+  return instance.post(`/customers/${id}/billing_portal`, params);
+};
+
+// src/sdk/customers/entities/entMethods.ts
+var entityMethods = (instance) => {
+  return {
+    get: (customer_id, entity_id, params) => staticWrapper(getEntity, instance, {
+      customer_id,
+      entity_id,
+      params
+    }),
+    create: (customer_id, params) => staticWrapper(createEntity, instance, { customer_id, params }),
+    delete: (customer_id, entity_id) => staticWrapper(deleteEntity, instance, { customer_id, entity_id })
+  };
+};
+var getExpandStr2 = (expand) => {
+  if (!expand) {
+    return "";
+  }
+  return `expand=${expand.join(",")}`;
+};
+var getEntity = async ({
+  instance,
+  customer_id,
+  entity_id,
+  params
+}) => {
+  return instance.get(
+    `/customers/${customer_id}/entities/${entity_id}?${getExpandStr2(
+      params?.expand
+    )}`
+  );
+};
+var createEntity = async ({
+  instance,
+  customer_id,
+  params
+}) => {
+  return instance.post(`/customers/${customer_id}/entities`, params);
+};
+var deleteEntity = async ({
+  instance,
+  customer_id,
+  entity_id
+}) => {
+  return instance.delete(`/customers/${customer_id}/entities/${entity_id}`);
+};
+
+// src/sdk/products/prodMethods.ts
+var productMethods = (instance) => {
+  return {
+    get: (id) => staticWrapper(getProduct, instance, { id }),
+    create: (params) => staticWrapper(createProduct, instance, { params }),
+    list: (params) => staticWrapper(listProducts, instance, { params })
+  };
+};
+var listProducts = async ({
+  instance,
+  params
+}) => {
+  let path = "/products_beta";
+  if (params) {
+    const queryParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        queryParams.append(key, String(value));
+      }
+    }
+    const queryString = queryParams.toString();
+    if (queryString) {
+      path += `?${queryString}`;
+    }
+  }
+  return instance.get(path);
+};
+var getProduct = async ({
+  instance,
+  id
+}) => {
+  return instance.get(`/products/${id}`);
+};
+var createProduct = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/products", params);
+};
+
+// src/sdk/referrals/referralMethods.ts
+var referralMethods = (instance) => {
+  return {
+    createCode: (params) => staticWrapper(createReferralCode, instance, { params }),
+    redeemCode: (params) => staticWrapper(redeemReferralCode, instance, { params })
+  };
+};
+var createReferralCode = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/referrals/code", params);
+};
+var redeemReferralCode = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/referrals/redeem", params);
+};
+
+// src/sdk/response.ts
+var toContainerResult = async ({
+  response,
+  logger: logger2,
+  logError = true
+}) => {
+  if (response.status < 200 || response.status >= 300) {
+    let error;
+    try {
+      error = await response.json();
+      if (logError) {
+        logger2.error(`[Autumn] ${error.message}`);
+      }
+    } catch (error2) {
+      throw error2;
+      return {
+        data: null,
+        error: new AutumnError({
+          message: "Failed to parse JSON response from Autumn",
+          code: "internal_error"
+        }),
+        statusCode: response.status
+      };
+    }
+    return {
+      data: null,
+      error: new AutumnError({
+        message: error.message,
+        code: error.code
+      }),
+      statusCode: response.status
+    };
+  }
+  try {
+    let data = await response.json();
+    return {
+      data,
+      error: null,
+      statusCode: response?.status
+    };
+  } catch (error) {
+    throw error;
+    return {
+      data: null,
+      error: new AutumnError({
+        message: "Failed to parse Autumn API response",
+        code: "internal_error"
+      }),
+      statusCode: response?.status
+    };
+  }
+};
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var getTime = () => {
+  let timeString = (/* @__PURE__ */ new Date()).toISOString();
+  return `[${timeString.split("T")[1].split(".")[0]}]`;
+};
+var greaterThanLevel = (level) => {
+  return levels.indexOf(level) >= levels.indexOf(logger.level);
+};
+var levels = ["debug", "info", "warn", "error", "fatal"];
+var logger = {
+  ...console,
+  level: "info",
+  debug: (...args) => {
+    if (greaterThanLevel("debug")) {
+      console.log(getTime(), import_chalk.default.gray("DEBUG"), ...args);
+    }
+  },
+  log: (...args) => {
+    console.log(getTime(), import_chalk.default.blue("INFO"), ...args);
+  },
+  info: (...args) => {
+    if (greaterThanLevel("info")) {
+      console.log(getTime(), import_chalk.default.blue("INFO"), ...args);
+    }
+  },
+  warn: (...args) => {
+    if (greaterThanLevel("warn")) {
+      console.log(getTime(), import_chalk.default.yellow("WARN"), ...args);
+    }
+  },
+  error: (...args) => {
+    if (greaterThanLevel("error")) {
+      console.log(getTime(), import_chalk.default.red("ERROR"), ...args);
+    }
+  }
+};
+
+// src/sdk/client.ts
+var LATEST_API_VERSION = "1.2";
+var Autumn = class {
+  secretKey;
+  publishableKey;
+  headers;
+  url;
+  logger = console;
+  constructor(options) {
+    try {
+      this.secretKey = options?.secretKey || process.env.AUTUMN_SECRET_KEY;
+      this.publishableKey = options?.publishableKey || process.env.AUTUMN_PUBLISHABLE_KEY;
+    } catch (error) {
+    }
+    if (!this.secretKey && !this.publishableKey && !options?.headers) {
+      throw new Error("Autumn secret key or publishable key is required");
+    }
+    this.headers = options?.headers || {
+      Authorization: `Bearer ${this.secretKey || this.publishableKey}`,
+      "Content-Type": "application/json"
+    };
+    let version = options?.version || LATEST_API_VERSION;
+    this.headers["x-api-version"] = version;
+    this.url = options?.url || autumnApiUrl;
+    this.logger = logger;
+    this.logger.level = options?.logLevel || "info";
+  }
+  async get(path) {
+    const response = await fetch(`${this.url}${path}`, {
+      headers: this.headers
+    });
+    return toContainerResult({ response, logger: this.logger });
+  }
+  async post(path, body) {
+    try {
+      const response = await fetch(`${this.url}${path}`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(body)
+      });
+      return toContainerResult({ response, logger: this.logger });
+    } catch (error) {
+      console.error("Error sending request:", error);
+      throw error;
+    }
+  }
+  async delete(path) {
+    const response = await fetch(`${this.url}${path}`, {
+      method: "DELETE",
+      headers: this.headers
+    });
+    return toContainerResult({ response, logger: this.logger });
+  }
+  static customers = customerMethods();
+  static products = productMethods();
+  static entities = entityMethods();
+  static referrals = referralMethods();
+  customers = customerMethods(this);
+  products = productMethods(this);
+  entities = entityMethods(this);
+  referrals = referralMethods(this);
+  static checkout = (params) => staticWrapper(handleCheckout, void 0, { params });
+  async checkout(params) {
+    return handleCheckout({
+      instance: this,
+      params
+    });
+  }
+  static attach = (params) => staticWrapper(handleAttach, void 0, { params });
+  static usage = (params) => staticWrapper(handleUsage, void 0, { params });
+  async attach(params) {
+    return handleAttach({
+      instance: this,
+      params
+    });
+  }
+  static setupPayment = (params) => staticWrapper(handleSetupPayment, void 0, { params });
+  async setupPayment(params) {
+    return handleSetupPayment({
+      instance: this,
+      params
+    });
+  }
+  static cancel = (params) => staticWrapper(handleCancel, void 0, { params });
+  async cancel(params) {
+    return handleCancel({
+      instance: this,
+      params
+    });
+  }
+  static check = (params) => staticWrapper(handleCheck, void 0, { params });
+  async check(params) {
+    return handleCheck({
+      instance: this,
+      params
+    });
+  }
+  static track = (params) => staticWrapper(handleTrack, void 0, { params });
+  async track(params) {
+    return handleTrack({
+      instance: this,
+      params
+    });
+  }
+  async usage(params) {
+    return handleUsage({
+      instance: this,
+      params
+    });
+  }
+  static query = (params) => staticWrapper(handleQuery, void 0, { params });
+  async query(params) {
+    return handleQuery({
+      instance: this,
+      params
+    });
+  }
+};
+
+// 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_zod = require("zod");
+var CustomerExpandEnum = import_zod.z.enum([
+  "invoices",
+  "rewards",
+  "trials_used",
+  "entities",
+  "referrals",
+  "payment_method"
+]);
+
+// src/sdk/customers/cusTypes.ts
+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_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/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 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(),
+  product_id: import_zod5.z.string()
+});
+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(),
+  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/referrals/referralTypes.ts
+var import_zod6 = require("zod");
+var CreateReferralCodeParamsSchema = import_zod6.z.object({
+  customer_id: import_zod6.z.string(),
+  program_id: import_zod6.z.string()
+});
+var RedeemReferralCodeParamsSchema = import_zod6.z.object({
+  code: import_zod6.z.string(),
+  customer_id: import_zod6.z.string()
+});
+
+// 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(),
+  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
+var logFetchError = ({
+  method,
+  backendUrl,
+  path,
+  error
+}) => {
+  console.error(`[Autumn] Fetch failed: ${method} ${backendUrl}${path}
+
+1. Check that backendUrl in <AutumnProvider/> is correctly set.
+2. Check that autumnHandler is correctly registered on your backend.`);
+};
+
+// src/libraries/react/client/clientCompMethods.ts
+async function getPricingTableMethod() {
+  const res = await this.get(`${this.prefix}/components/pricing_table`);
+  return res;
+}
+
+// src/libraries/react/client/clientCusMethods.ts
+var createCustomerMethod = async ({
+  client,
+  params
+}) => {
+  let result = await client.post(`${client.prefix}/customers`, params);
+  return result;
+};
+
+// src/libraries/react/utils/toSnakeCase.ts
+function stringToSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+var toSnakeCase = (obj, excludeKeys) => {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => toSnakeCase(item, excludeKeys));
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => {
+        const snakeKey = stringToSnakeCase(key);
+        if (excludeKeys && excludeKeys.includes(key)) {
+          return [snakeKey, value];
+        }
+        return [snakeKey, toSnakeCase(value, excludeKeys)];
+      })
+    );
+  }
+  return obj;
+};
+
+// src/utils/entityUtils.tsx
+var getEntityExpandStr = (expand) => {
+  if (!expand) {
+    return "";
+  }
+  return `expand=${expand.join(",")}`;
+};
+
+// src/libraries/react/client/clientEntityMethods.ts
+async function createEntityMethod(params) {
+  let snakeParams = toSnakeCase(params);
+  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(`${this.prefix}/entities/${entityId}?${expand}`);
+  return res;
+}
+async function deleteEntityMethod(entityId) {
+  const res = await this.delete(`${this.prefix}/entities/${entityId}`);
+  return res;
+}
+
+// src/libraries/react/client/clientGenMethods.ts
+async function checkoutMethod(params) {
+  let snakeParams = toSnakeCase(params);
+  const res = await this.post(`${this.prefix}/checkout`, snakeParams);
+  return res;
+}
+async function attachMethod(params) {
+  let snakeParams = toSnakeCase(params, ["checkoutSessionparams"]);
+  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(`${this.prefix}/setup_payment`, snakeParams);
+  return res;
+}
+async function cancelMethod(params) {
+  let snakeParams = toSnakeCase(params);
+  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(`${this.prefix}/check`, snakeParams);
+  return res;
+}
+async function trackMethod(params) {
+  let snakeParams = toSnakeCase(params);
+  const res = await this.post(`${this.prefix}/track`, snakeParams);
+  return res;
+}
+async function openBillingPortalMethod(params) {
+  let snakeParams = toSnakeCase(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() {
+  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(`${this.prefix}/referrals/code`, snakeParams);
+  return res;
+}
+async function redeemCode(params) {
+  let snakeParams = toSnakeCase(params);
+  const res = await this.post(`${this.prefix}/referrals/redeem`, snakeParams);
+  return res;
+}
+
+// src/libraries/react/client/ReactAutumnClient.tsx
+var AutumnClient = class {
+  backendUrl;
+  getBearerToken;
+  customerData;
+  includeCredentials;
+  prefix;
+  constructor({
+    backendUrl,
+    getBearerToken,
+    customerData,
+    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, {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" }
+      });
+      return { valid: true, includeCredentials: true };
+    } catch (error) {
+      try {
+        await fetch(testEndpoint, {
+          method: "POST",
+          credentials: "omit",
+          headers: { "Content-Type": "application/json" }
+        });
+        return { valid: true, includeCredentials: false };
+      } catch (error2) {
+        return { valid: false, includeCredentials: void 0 };
+      }
+    }
+  }
+  /**
+   * Automatically determines whether to include credentials based on CORS detection
+   */
+  async shouldIncludeCredentials() {
+    if (this.includeCredentials !== void 0) {
+      return this.includeCredentials;
+    }
+    try {
+      const corsResult = await this.detectCors();
+      if (corsResult.valid) {
+        console.warn(
+          `[Autumn] Detected CORS credentials: ${corsResult.includeCredentials}`
+        );
+        console.warn(
+          `[Autumn] To disable this warning, you can set includeCredentials={${corsResult.includeCredentials ? "true" : "false"}} in <AutumnProvider />`
+        );
+        this.includeCredentials = corsResult.includeCredentials;
+      }
+      return corsResult.includeCredentials || false;
+    } catch (error) {
+      console.error(`[Autumn] Error detecting CORS: ${error.message}`);
+      return false;
+    }
+  }
+  async getHeaders() {
+    let headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.getBearerToken) {
+      try {
+        let token = await this.getBearerToken();
+        headers.Authorization = `Bearer ${token}`;
+      } catch (error) {
+        console.error(`Failed to call getToken() in AutumnProvider`);
+      }
+    }
+    return headers;
+  }
+  async handleFetch({
+    path,
+    method,
+    body
+  }) {
+    body = method === "POST" ? JSON.stringify({
+      ...body,
+      customer_data: this.customerData || void 0
+    }) : void 0;
+    const includeCredentials = await this.shouldIncludeCredentials();
+    try {
+      const response = await fetch(`${this.backendUrl}${path}`, {
+        method,
+        body,
+        headers: await this.getHeaders(),
+        credentials: includeCredentials ? "include" : "omit"
+      });
+      const loggedError = await logAuthError(response);
+      return await toContainerResult({
+        response,
+        logger: console,
+        logError: !loggedError
+      });
+    } catch (error) {
+      logFetchError({
+        method,
+        backendUrl: this.backendUrl || "",
+        path,
+        error
+      });
+      return {
+        data: null,
+        error: new AutumnError({
+          message: error.message,
+          code: "fetch_failed"
+        })
+      };
+    }
+  }
+  async post(path, body) {
+    return await this.handleFetch({
+      path,
+      method: "POST",
+      body
+    });
+  }
+  async get(path) {
+    return await this.handleFetch({
+      path,
+      method: "GET"
+    });
+  }
+  async delete(path) {
+    return await this.handleFetch({
+      path,
+      method: "DELETE"
+    });
+  }
+  async createCustomer(params) {
+    return await createCustomerMethod({
+      client: this,
+      params
+    });
+  }
+  async getPricingTable() {
+    return await getPricingTableMethod.bind(this)();
+  }
+  attach = attachMethod.bind(this);
+  checkout = checkoutMethod.bind(this);
+  cancel = cancelMethod.bind(this);
+  check = checkMethod.bind(this);
+  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),
+    delete: deleteEntityMethod.bind(this)
+  };
+  referrals = {
+    createCode: createCode.bind(this),
+    redeemCode: redeemCode.bind(this)
+  };
+  products = {
+    list: listProductsMethod.bind(this)
+  };
+};
+
+// src/libraries/react/AutumnContext.tsx
+var import_react5 = require("react");
+var AutumnContext = (0, import_react5.createContext)({
+  initialized: false,
+  disableDialogs: false,
+  client: new AutumnClient({ backendUrl: "" }),
+  paywallDialog: {
+    props: null,
+    setProps: () => {
+    },
+    open: false,
+    setOpen: () => {
+    },
+    setComponent: () => {
+    }
+  },
+  attachDialog: {
+    props: null,
+    setProps: () => {
+    },
+    open: false,
+    setOpen: () => {
+    },
+    setComponent: () => {
+    }
+  },
+  paywallRef: { current: null }
+});
+var useAutumnContext = ({
+  AutumnContext: AutumnContext2,
+  name,
+  errorIfNotInitialized = true
+}) => {
+  const context = (0, import_react5.useContext)(AutumnContext2);
+  if (!context.initialized && errorIfNotInitialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
+  }
+  return context;
+};
+
+// src/libraries/react/hooks/usePricingTableBase.tsx
+var import_swr = __toESM(require("swr"));
+
+// src/libraries/react/BaseAutumnProvider.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+
+// src/libraries/react/ReactAutumnProvider.tsx
+var import_jsx_runtime11 = require("react/jsx-runtime");
+
+// src/libraries/react/hooks/useEntityBase.tsx
+var import_swr3 = __toESM(require("swr"));
+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"));
+var usePaywall = ({
+  featureId,
+  entityId
+}) => {
+  const context = useAutumnContext({
+    AutumnContext,
+    name: "usePaywall"
+  });
+  const enabled = !!featureId && !!context;
+  const fetcher = async () => {
+    if (!featureId) {
+      return { preview: void 0 };
+    }
+    const { data: data2, error: error2 } = await context.client.check({
+      featureId,
+      withPreview: true
+    });
+    if (error2) throw error2;
+    return data2;
+  };
+  const queryKey = [`check`, featureId, entityId];
+  const { data, error, isLoading } = (0, import_swr5.default)(queryKey, fetcher, {
+    refreshInterval: 0,
+    enabled
+  });
+  return {
+    data: data?.preview,
+    error,
+    isLoading
+  };
+};
+
+// src/libraries/react/components/attach-dialog/attach-dialog-synced.tsx
+var AccordionPrimitive2 = __toESM(require("@radix-ui/react-accordion"));
+var import_react10 = require("react");
+
+// src/libraries/react/components/attach-dialog/lib/attach-content.tsx
+var import_jsx_runtime12 = require("react/jsx-runtime");
+
+// src/libraries/react/components/ui/accordion.tsx
+var React29 = __toESM(require("react"));
+var AccordionPrimitive = __toESM(require("@radix-ui/react-accordion"));
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var AccordionItem = React29.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+  AccordionPrimitive.Item,
+  {
+    ref,
+    className: cn("au-border-b", className),
+    ...props
+  }
+));
+AccordionItem.displayName = "AccordionItem";
+var AccordionTrigger = React29.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(AccordionPrimitive.Header, { className: "au-flex", children: /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
+  AccordionPrimitive.Trigger,
+  {
+    ref,
+    className: cn(
+      "au-flex au-flex-1 au-items-center au-justify-between au-py-4 au-text-sm au-font-medium au-transition-all hover:au-underline au-text-left [&[data-state=open]>svg]:au-rotate-180",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(ChevronDown, { className: "au-h-4 au-w-4 au-shrink-0 au-text-muted-foreground au-transition-transform au-duration-200" })
+    ]
+  }
+) }));
+AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName;
+var AccordionContent = React29.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+  AccordionPrimitive.Content,
+  {
+    ref,
+    className: "au-overflow-hidden au-text-sm data-[state=closed]:au-animate-accordion-up data-[state=open]:au-animate-accordion-down",
+    ...props,
+    children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: cn("au-pb-4 au-pt-0", className), children })
+  }
+));
+AccordionContent.displayName = AccordionPrimitive.Content.displayName;
+
+// src/libraries/react/components/ui/popover.tsx
+var React30 = __toESM(require("react"));
+var PopoverPrimitive = __toESM(require("@radix-ui/react-popover"));
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var PopoverContent = React30.forwardRef(({ className, align = "center", sideOffset = 4, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+  PopoverPrimitive.Content,
+  {
+    ref,
+    align,
+    sideOffset,
+    className: cn(
+      "au-root au-z-[9999] au-w-72 au-rounded-md au-border au-bg-popover au-p-4 au-text-popover-foreground au-shadow-md au-outline-none data-[state=open]:au-animate-in data-[state=closed]:au-animate-out data-[state=closed]:au-fade-out-0 data-[state=open]:au-fade-in-0 data-[state=closed]:au-zoom-out-95 data-[state=open]:au-zoom-in-95 data-[side=bottom]:au-slide-in-from-top-2 data-[side=left]:au-slide-in-from-right-2 data-[side=right]:au-slide-in-from-left-2 data-[side=top]:au-slide-in-from-bottom-2 au-origin-[--radix-popover-content-transform-origin]",
+      className
+    ),
+    ...props
+  }
+));
+PopoverContent.displayName = PopoverPrimitive.Content.displayName;
+
+// src/libraries/react/components/ui/input.tsx
+var React31 = __toESM(require("react"));
+var import_jsx_runtime15 = require("react/jsx-runtime");
+var Input = React31.forwardRef(
+  ({ className, type, onClick, ...props }, ref) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      "input",
+      {
+        type,
+        className: cn(
+          "file:au-text-foreground placeholder:au-text-muted-foreground selection:au-bg-primary selection:au-text-primary-foreground dark:au-bg-input/30 au-border-input au-flex au-h-9 au-w-full au-min-w-0 au-rounded-md au-border au-bg-transparent au-px-3 au-py-1 au-text-base au-shadow-xs au-transition-[color,box-shadow] au-outline-none file:au-inline-flex file:au-h-7 file:au-border-0 file:au-bg-transparent file:au-text-sm file:au-font-medium disabled:au-pointer-events-none disabled:au-cursor-not-allowed disabled:au-opacity-50 md:au-text-sm focus-visible:au-border-ring focus-visible:au-ring-ring/50 focus-visible:au-ring-[3px] aria-invalid:au-ring-destructive/20 dark:aria-invalid:au-ring-destructive/40 aria-invalid:au-border-destructive",
+          className
+        ),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Input.displayName = "Input";
+
+// src/libraries/react/components/attach-dialog/attach-dialog-synced.tsx
+var import_jsx_runtime16 = require("react/jsx-runtime");
+
+// src/libraries/react/components/pricing-table/pricing-table-synced.tsx
+var import_react11 = __toESM(require("react"));
+var import_react12 = require("react");
+
+// src/libraries/react/components/ui/switch.tsx
+var React36 = __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 React35 = __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 React33 = __toESM(require("react"), 1);
+function usePrevious(value) {
+  const ref = React33.useRef({ value, previous: value });
+  return React33.useMemo(() => {
+    if (ref.current.value !== value) {
+      ref.current.previous = ref.current.value;
+      ref.current.value = value;
+    }
+    return ref.current.previous;
+  }, [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 React34 = __toESM(require("react"), 1);
+function useSize(element) {
+  const [size, setSize] = React34.useState(void 0);
+  useLayoutEffect2(() => {
+    if (element) {
+      setSize({ width: element.offsetWidth, height: element.offsetHeight });
+      const resizeObserver = new ResizeObserver((entries) => {
+        if (!Array.isArray(entries)) {
+          return;
+        }
+        if (!entries.length) {
+          return;
+        }
+        const entry = entries[0];
+        let width;
+        let height;
+        if ("borderBoxSize" in entry) {
+          const borderSizeEntry = entry["borderBoxSize"];
+          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+          width = borderSize["inlineSize"];
+          height = borderSize["blockSize"];
+        } else {
+          width = element.offsetWidth;
+          height = element.offsetHeight;
+        }
+        setSize({ width, height });
+      });
+      resizeObserver.observe(element, { box: "border-box" });
+      return () => resizeObserver.unobserve(element);
+    } else {
+      setSize(void 0);
+    }
+  }, [element]);
+  return size;
+}
+
+// ../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 import_jsx_runtime17 = require("react/jsx-runtime");
+var SWITCH_NAME = "Switch";
+var [createSwitchContext, createSwitchScope] = createContextScope(SWITCH_NAME);
+var [SwitchProvider, useSwitchContext] = createSwitchContext(SWITCH_NAME);
+var Switch = React35.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      __scopeSwitch,
+      name,
+      checked: checkedProp,
+      defaultChecked,
+      required,
+      disabled,
+      value = "on",
+      onCheckedChange,
+      form,
+      ...switchProps
+    } = props;
+    const [button, setButton] = React35.useState(null);
+    const composedRefs = useComposedRefs(forwardedRef, (node) => setButton(node));
+    const hasConsumerStoppedPropagationRef = React35.useRef(false);
+    const isFormControl = button ? form || !!button.closest("form") : true;
+    const [checked, setChecked] = useControllableState({
+      prop: checkedProp,
+      defaultProp: defaultChecked ?? false,
+      onChange: onCheckedChange,
+      caller: SWITCH_NAME
+    });
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(SwitchProvider, { scope: __scopeSwitch, checked, disabled, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        Primitive.button,
+        {
+          type: "button",
+          role: "switch",
+          "aria-checked": checked,
+          "aria-required": required,
+          "data-state": getState2(checked),
+          "data-disabled": disabled ? "" : void 0,
+          disabled,
+          value,
+          ...switchProps,
+          ref: composedRefs,
+          onClick: composeEventHandlers(props.onClick, (event) => {
+            setChecked((prevChecked) => !prevChecked);
+            if (isFormControl) {
+              hasConsumerStoppedPropagationRef.current = event.isPropagationStopped();
+              if (!hasConsumerStoppedPropagationRef.current) event.stopPropagation();
+            }
+          })
+        }
+      ),
+      isFormControl && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        SwitchBubbleInput,
+        {
+          control: button,
+          bubbles: !hasConsumerStoppedPropagationRef.current,
+          name,
+          value,
+          checked,
+          required,
+          disabled,
+          form,
+          style: { transform: "translateX(-100%)" }
+        }
+      )
+    ] });
+  }
+);
+Switch.displayName = SWITCH_NAME;
+var THUMB_NAME = "SwitchThumb";
+var SwitchThumb = React35.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeSwitch, ...thumbProps } = props;
+    const context = useSwitchContext(THUMB_NAME, __scopeSwitch);
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      Primitive.span,
+      {
+        "data-state": getState2(context.checked),
+        "data-disabled": context.disabled ? "" : void 0,
+        ...thumbProps,
+        ref: forwardedRef
+      }
+    );
+  }
+);
+SwitchThumb.displayName = THUMB_NAME;
+var BUBBLE_INPUT_NAME = "SwitchBubbleInput";
+var SwitchBubbleInput = React35.forwardRef(
+  ({
+    __scopeSwitch,
+    control,
+    checked,
+    bubbles = true,
+    ...props
+  }, forwardedRef) => {
+    const ref = React35.useRef(null);
+    const composedRefs = useComposedRefs(ref, forwardedRef);
+    const prevChecked = usePrevious(checked);
+    const controlSize = useSize(control);
+    React35.useEffect(() => {
+      const input = ref.current;
+      if (!input) return;
+      const inputProto = window.HTMLInputElement.prototype;
+      const descriptor = Object.getOwnPropertyDescriptor(
+        inputProto,
+        "checked"
+      );
+      const setChecked = descriptor.set;
+      if (prevChecked !== checked && setChecked) {
+        const event = new Event("click", { bubbles });
+        setChecked.call(input, checked);
+        input.dispatchEvent(event);
+      }
+    }, [prevChecked, checked, bubbles]);
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      "input",
+      {
+        type: "checkbox",
+        "aria-hidden": true,
+        defaultChecked: checked,
+        ...props,
+        tabIndex: -1,
+        ref: composedRefs,
+        style: {
+          ...props.style,
+          ...controlSize,
+          position: "absolute",
+          pointerEvents: "none",
+          opacity: 0,
+          margin: 0
+        }
+      }
+    );
+  }
+);
+SwitchBubbleInput.displayName = BUBBLE_INPUT_NAME;
+function getState2(checked) {
+  return checked ? "checked" : "unchecked";
+}
+var Root4 = Switch;
+var Thumb = SwitchThumb;
+
+// src/libraries/react/components/ui/switch.tsx
+var import_jsx_runtime18 = require("react/jsx-runtime");
+var Switch2 = React36.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+  Root4,
+  {
+    className: cn(
+      "au-peer au-inline-flex au-h-5 au-w-9 au-shrink-0 au-cursor-pointer au-items-center au-rounded-full au-border-2 au-border-transparent au-shadow-sm au-transition-colors focus-visible:au-outline-none focus-visible:au-ring-2 focus-visible:au-ring-ring focus-visible:au-ring-offset-2 focus-visible:au-ring-offset-background au-disabled:cursor-not-allowed au-disabled:opacity-50 data-[state=checked]:au-bg-primary data-[state=unchecked]:au-bg-input",
+      className
+    ),
+    ...props,
+    ref,
+    children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+      Thumb,
+      {
+        className: cn(
+          "au-pointer-events-none au-block au-h-4 au-w-4 au-rounded-full au-bg-background au-shadow-lg au-ring-0 au-transition-transform data-[state=checked]:au-translate-x-4 data-[state=unchecked]:au-translate-x-0"
+        )
+      }
+    )
+  }
+));
+Switch2.displayName = Root4.displayName;
+
+// src/libraries/react/components/pricing-table/lib/pricing-table-content.tsx
+var import_jsx_runtime19 = require("react/jsx-runtime");
+
+// src/libraries/react/utils/inject-styles.ts
+if (typeof document !== "undefined") {
+  const styleId = "au-spinner-keyframes";
+  if (!document.getElementById(styleId)) {
+    const style = document.createElement("style");
+    style.id = styleId;
+    style.textContent = `
+      @keyframes spin {
+        from { transform: rotate(0deg); }
+        to { transform: rotate(360deg); }
+      }
+    `;
+    document.head.appendChild(style);
+  }
+}
+
+// src/libraries/react/components/pricing-table/pricing-table-synced.tsx
+var import_jsx_runtime20 = require("react/jsx-runtime");
+var PricingTableContext = (0, import_react12.createContext)({
+  isAnnualToggle: false,
+  setIsAnnualToggle: () => {
+  },
+  products: [],
+  showFeatures: true
+});
+var PricingCardButton = import_react11.default.forwardRef(({ recommended, children, className, onClick, ...props }, ref) => {
+  const [loading, setLoading] = (0, import_react12.useState)(false);
+  const handleClick = async (e) => {
+    setLoading(true);
+    try {
+      await onClick?.(e);
+    } catch (error) {
+      console.error(error);
+    } finally {
+      setLoading(false);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+    Button,
+    {
+      className: cn(
+        "au-w-full au-py-3 au-px-4 au-group au-overflow-hidden au-relative au-transition-all au-duration-300 hover:au-brightness-90 au-border au-rounded-lg",
+        className
+      ),
+      ...props,
+      variant: recommended ? "default" : "secondary",
+      ref,
+      disabled: loading || props.disabled,
+      onClick: handleClick,
+      children: loading ? /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(LoaderCircle, { className: "au-h-4 au-w-4 au-animate-spin" }) : /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_jsx_runtime20.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "au-flex au-items-center au-justify-between au-w-full au-transition-transform au-duration-300 group-hover:au-translate-y-[-130%]", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { children }),
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { className: "au-text-sm", children: "\u2192" })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "au-flex au-items-center au-justify-between au-w-full au-absolute au-px-4 au-translate-y-[130%] au-transition-transform au-duration-300 group-hover:au-translate-y-0 au-mt-2 group-hover:au-mt-0", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { children }),
+          /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { className: "au-text-sm", children: "\u2192" })
+        ] })
+      ] })
+    }
+  );
+});
+PricingCardButton.displayName = "PricingCardButton";
+
 // src/libraries/react/components/check-dialog/lib/check-content.tsx
 var getCheckContent = (preview) => {
+  if (!preview) {
+    return {
+      title: "Feature Unavailable",
+      message: "This feature is not available for your account."
+    };
+  }
   const { scenario, products, feature_name } = preview;
   if (products.length == 0) {
     switch (scenario) {
@@ -4978,19 +6447,21 @@ var getCheckContent = (preview) => {
 };
 
 // src/libraries/react/components/check-dialog/check-dialog-synced.tsx
-var import_jsx_runtime10 = require("react/jsx-runtime");
+var import_jsx_runtime21 = require("react/jsx-runtime");
 function CheckDialog(params) {
-  const [loading] = (0, import_react4.useState)(false);
-  if (!params || !params.preview) {
-    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_jsx_runtime10.Fragment, {});
+  const { data: preview } = usePaywall({
+    featureId: params?.featureId,
+    entityId: params?.entityId
+  });
+  if (!params || !preview) {
+    return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_jsx_runtime21.Fragment, {});
   }
   const { open, setOpen } = params;
-  const { products } = params.preview;
-  const { title, message } = getCheckContent(params.preview);
-  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(Dialog2, { open, onOpenChange: setOpen, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(DialogContent2, { className: "au-p-0 au-pt-4 au-gap-0 au-text-foreground au-overflow-hidden au-text-sm", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(DialogTitle2, { className: cn("au-font-bold au-text-xl au-px-6"), children: title }),
-    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "au-px-6 au-my-2", children: message }),
-    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(DialogFooter, { className: "au-flex au-flex-col sm:au-flex-row au-justify-between au-gap-x-4 au-py-2 au-mt-4 au-pl-6 au-pr-3 au-bg-secondary au-border-t", children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+  const { title, message } = getCheckContent(preview);
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(Dialog2, { open, onOpenChange: setOpen, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(DialogContent2, { className: "au-p-0 au-pt-4 au-gap-0 au-text-foreground au-overflow-hidden au-text-sm", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(DialogTitle2, { className: cn("au-font-bold au-text-xl au-px-6"), children: title }),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { className: "au-px-6 au-my-2", children: message }),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(DialogFooter, { className: "au-flex au-flex-col sm:au-flex-row au-justify-between au-gap-x-4 au-py-2 au-mt-4 au-pl-6 au-pr-3 au-bg-secondary au-border-t", children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
       Button,
       {
         size: "sm",
@@ -5009,6 +6480,8 @@ lucide-react/dist/esm/shared/src/utils.js:
 lucide-react/dist/esm/defaultAttributes.js:
 lucide-react/dist/esm/Icon.js:
 lucide-react/dist/esm/createLucideIcon.js:
+lucide-react/dist/esm/icons/chevron-down.js:
+lucide-react/dist/esm/icons/loader-circle.js:
 lucide-react/dist/esm/icons/x.js:
 lucide-react/dist/esm/lucide-react.js:
   (**