autumn-js 0.0.107 → 0.0.109

package/dist/libraries/react/hooks/usePricingTableBase.js

@@ -106,6 +106,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";
@@ -483,60 +489,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",
@@ -546,435 +524,162 @@ 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(),
+  product_id: import_zod5.z.string()
+});
+var TrackParamsSchema = import_zod5.z.object({
   customer_id: import_zod5.z.string(),
-  program_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 RedeemReferralCodeParamsSchema = import_zod5.z.object({
+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()
 });
-
-// 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/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;
-}
-
-// 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);
-  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_react = require("react");
-var AutumnContext = (0, import_react.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: () => {
-    }
-  }
+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()
 });
-var useAutumnContext = ({
-  AutumnContext: AutumnContext2,
-  name,
-  errorIfNotInitialized = true
-}) => {
-  const context = (0, import_react.useContext)(AutumnContext2);
-  if (!context.initialized && errorIfNotInitialized) {
-    throw new Error(`${name} must be used within <AutumnProvider />`);
-  }
-  return context;
-};
 
 // src/libraries/react/hooks/usePricingTableBase.tsx
 var mergeProductDetails = (products, productDetails) => {
@@ -1136,14 +841,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();