autumn-js 0.0.67 → 0.0.72

package/dist/libraries/react/BaseAutumnProvider.js

@@ -54,7 +54,7 @@ var useDialog = (component) => {
 };
 
 // src/libraries/react/hooks/useCustomerBase.tsx
-var import_swr = __toESM(require("swr"));
+var import_swr2 = __toESM(require("swr"));
 
 // src/sdk/error.ts
 var AutumnError = class _AutumnError extends Error {
@@ -253,7 +253,7 @@ var listProducts = async ({
   instance,
   params
 }) => {
-  let path = "/products";
+  let path = "/products_beta";
   if (params) {
     const queryParams = new URLSearchParams();
     for (const [key, value] of Object.entries(params)) {
@@ -614,6 +614,12 @@ async function openBillingPortalMethod(params) {
   return res;
 }
 
+// src/libraries/react/client/clientProdMethods.ts
+async function listProductsMethod() {
+  const res = await this.get("/api/autumn/products");
+  return res;
+}
+
 // src/libraries/react/client/clientReferralMethods.ts
 async function createCode(params) {
   let snakeParams = toSnakeCase(params);
@@ -732,15 +738,17 @@ var AutumnClient = class {
     createCode: createCode.bind(this),
     redeemCode: redeemCode.bind(this)
   };
+  products = {
+    list: listProductsMethod.bind(this)
+  };
 };
 
 // src/libraries/react/AutumnContext.tsx
 var import_react2 = require("react");
 var AutumnContext = (0, import_react2.createContext)({
   initialized: false,
-  client: new AutumnClient({
-    backendUrl: process.env.NEXT_PUBLIC_AUTUMN_BACKEND_URL
-  }),
+  disableDialogs: false,
+  client: new AutumnClient({ backendUrl: "" }),
   paywallDialog: {
     props: null,
     setProps: () => {
@@ -751,7 +759,7 @@ var AutumnContext = (0, import_react2.createContext)({
     setComponent: () => {
     }
   },
-  prodChangeDialog: {
+  attachDialog: {
     props: null,
     setProps: () => {
     },
@@ -773,7 +781,355 @@ var useAutumnContext = ({
   return context;
 };
 
+// src/libraries/react/hooks/usePricingTableBase.tsx
+var import_swr = __toESM(require("swr"));
+var mergeProductDetails = (products, productDetails) => {
+  if (!products) {
+    return null;
+  }
+  if (!productDetails) {
+    return products;
+  }
+  let fetchedProducts = structuredClone(products);
+  let mergedProducts = [];
+  for (const overrideDetails of productDetails) {
+    if (!overrideDetails.id) {
+      let properties = {};
+      let overrideItems2 = overrideDetails.items?.map((item) => ({
+        display: {
+          primary_text: item.primaryText,
+          secondary_text: item.secondaryText
+        }
+      }));
+      let overridePrice2 = overrideDetails.price;
+      if (overrideDetails.price) {
+        properties.is_free = false;
+        overrideItems2 = [
+          {
+            display: {
+              primary_text: overridePrice2?.primaryText,
+              secondary_text: overridePrice2?.secondaryText
+            }
+          },
+          ...overrideItems2 || []
+        ];
+      }
+      mergedProducts.push({
+        name: overrideDetails.name || "",
+        display: {
+          description: overrideDetails.description,
+          button_text: overrideDetails.buttonText,
+          recommend_text: overrideDetails.recommendText,
+          everything_from: overrideDetails.everythingFrom,
+          button_url: overrideDetails.buttonUrl
+        },
+        items: overrideItems2,
+        properties
+      });
+      continue;
+    }
+    let fetchedProduct = fetchedProducts.find(
+      (p) => p.id === overrideDetails.id
+    );
+    if (!fetchedProduct) {
+      continue;
+    }
+    const originalIsFree = fetchedProduct.properties?.is_free;
+    let overrideProperties = fetchedProduct.properties || {};
+    let overrideItems = overrideDetails.items;
+    let overridePrice = overrideDetails.price;
+    let mergedItems = [];
+    if (overridePrice) {
+      overrideProperties.is_free = false;
+      if (originalIsFree || overrideItems !== void 0) {
+        mergedItems.push({
+          display: {
+            primary_text: overridePrice.primaryText,
+            secondary_text: overridePrice.secondaryText
+          }
+        });
+      } else {
+        fetchedProduct.items[0].display = {
+          primary_text: overridePrice.primaryText,
+          secondary_text: overridePrice.secondaryText
+        };
+      }
+    } else {
+      if (overrideItems && !originalIsFree) {
+        mergedItems.push(fetchedProduct.items[0]);
+      }
+    }
+    if (overrideItems) {
+      for (const overrideItem of overrideItems) {
+        if (!overrideItem.featureId) {
+          mergedItems.push({
+            display: {
+              primary_text: overrideItem.primaryText,
+              secondary_text: overrideItem.secondaryText
+            }
+          });
+        } else {
+          let fetchedItem = fetchedProduct.items.find(
+            (i) => i.feature_id === overrideItem.featureId
+          );
+          if (!fetchedItem) {
+            console.error(
+              `Feature with id ${overrideItem.featureId} not found for product ${fetchedProduct.id}`
+            );
+            continue;
+          }
+          mergedItems.push({
+            ...fetchedItem,
+            display: {
+              primary_text: overrideItem.primaryText || fetchedItem.display?.primary_text,
+              secondary_text: overrideItem.secondaryText || fetchedItem.display?.secondary_text
+            }
+          });
+        }
+      }
+    } else {
+      mergedItems = fetchedProduct.items;
+    }
+    const mergedProduct = {
+      ...fetchedProduct,
+      name: overrideDetails.name || fetchedProduct.name,
+      items: mergedItems,
+      properties: overrideProperties,
+      display: {
+        description: overrideDetails.description,
+        button_text: overrideDetails.buttonText,
+        recommend_text: overrideDetails.recommendText,
+        everything_from: overrideDetails.everythingFrom,
+        button_url: overrideDetails.buttonUrl
+      }
+      // description: overrideDetails.description,
+      // button_text: overrideDetails.buttonText,
+      // recommend_text: overrideDetails.recommendText,
+      // everything_from: overrideDetails.everythingFrom,
+    };
+    mergedProducts.push(mergedProduct);
+  }
+  return mergedProducts;
+};
+var usePricingTableBase = ({
+  AutumnContext: AutumnContext2,
+  params
+}) => {
+  const context = useAutumnContext({ AutumnContext: AutumnContext2, name: "usePricingTable" });
+  const fetcher = async () => {
+    try {
+      const { data: data2, error: error2 } = await context.client.products.list();
+      if (error2) throw error2;
+      return data2?.list || [];
+    } catch (error2) {
+      throw new AutumnError({
+        message: "Failed to fetch pricing table products",
+        code: "failed_to_fetch_pricing_table_products"
+      });
+    }
+  };
+  const { data, error, mutate } = (0, import_swr.default)(
+    "pricing-table",
+    fetcher
+  );
+  return {
+    products: mergeProductDetails(data || [], params?.productDetails),
+    // products: data || [],
+    isLoading: !error && !data,
+    error,
+    refetch: mutate
+  };
+};
+
+// src/libraries/react/hooks/useAutumnBase.tsx
+var useAutumnBase = ({
+  AutumnContext: AutumnContext2
+}) => {
+  const context = useAutumnContext({ AutumnContext: AutumnContext2, name: "useAutumn" });
+  const { attachDialog, paywallDialog } = context;
+  const client = context.client;
+  const { refetch: refetchPricingTable } = usePricingTableBase({
+    AutumnContext: AutumnContext2
+  });
+  let {
+    open: attachOpen,
+    setProps: setAttachProps,
+    setOpen: setAttachOpen,
+    setComponent: setAttachComponent
+  } = attachDialog;
+  let {
+    setProps: setCheckProps,
+    setOpen: setCheckOpen,
+    setComponent: setPaywallComponent
+  } = paywallDialog;
+  const attachWithoutDialog = async (params) => {
+    const result = await client.attach(params);
+    if (result.error) {
+      return result;
+    }
+    let data = result.data;
+    if (data?.checkout_url && typeof window !== "undefined") {
+      if (params.openInNewTab) {
+        window.open(data.checkout_url, "_blank");
+      } else {
+        window.location.href = data.checkout_url;
+      }
+    }
+    await refetchPricingTable();
+    if (setAttachOpen) {
+      setAttachOpen(false);
+    }
+    return result;
+  };
+  const attachWithDialog = async (params) => {
+    let { dialog, ...rest } = params;
+    const { productId, entityId, entityData } = params;
+    const checkRes = await client.check({
+      productId,
+      entityId,
+      entityData,
+      withPreview: true
+    });
+    if (checkRes.error) {
+      return checkRes;
+    }
+    let preview = checkRes.data.preview;
+    if (!preview) {
+      return await attachWithoutDialog(rest);
+    } else {
+      setAttachProps({ preview });
+      setAttachOpen(true);
+    }
+    return checkRes;
+  };
+  const attach = async (params) => {
+    const { dialog, openInNewTab } = params;
+    let finalDialog = dialog;
+    if (finalDialog && !attachOpen) {
+      setAttachComponent(finalDialog);
+      return await attachWithDialog(params);
+    }
+    return await attachWithoutDialog(params);
+  };
+  const cancel = async (params) => {
+    const res = await client.cancel(params);
+    if (res.error) {
+      return res;
+    }
+    return res;
+  };
+  const check = async (params) => {
+    let { dialog, withPreview } = params;
+    if (dialog) {
+      setPaywallComponent(dialog);
+    }
+    const res = await client.check({
+      ...params,
+      withPreview: withPreview || dialog ? true : false
+    });
+    if (res.error) {
+      return res;
+    }
+    let data = res.data;
+    if (data && data.preview && dialog) {
+      let preview = data.preview;
+      setCheckProps({ preview });
+      setCheckOpen(true);
+    }
+    return res;
+  };
+  const track = async (params) => {
+    const res = await client.track(params);
+    if (res.error) {
+      return res;
+    }
+    return res;
+  };
+  const openBillingPortal = async (params) => {
+    let defaultParams = {
+      openInNewTab: false
+    };
+    let finalParams = {
+      ...defaultParams,
+      ...params
+    };
+    const res = await client.openBillingPortal(finalParams);
+    if (res.error) {
+      return res;
+    }
+    let data = res.data;
+    if (data?.url && typeof window !== "undefined") {
+      if (finalParams.openInNewTab) {
+        window.open(data.url, "_blank");
+      } else {
+        window.open(data.url, "_self");
+      }
+      return res;
+    } else {
+      return res;
+    }
+  };
+  return {
+    attach,
+    check,
+    track,
+    cancel,
+    openBillingPortal
+  };
+};
+
+// src/libraries/react/hooks/handleAllowed.ts
+var getCusFeature = ({
+  customer,
+  featureId,
+  requiredBalance = 1
+}) => {
+  let creditSchema = Object.values(customer.features).find((f) => f.credit_schema && f.credit_schema.some((c) => c.feature_id === featureId));
+  if (creditSchema) {
+    let schemaItem = creditSchema.credit_schema?.find((c) => c.feature_id === featureId);
+    return {
+      feature: creditSchema,
+      requiredBalance: schemaItem.credit_amount * requiredBalance
+    };
+  }
+  return {
+    cusFeature: customer.features[featureId],
+    requiredBalance
+  };
+};
+var handleFeatureAllowed = ({ customer, params }) => {
+  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;
+  return (cusFeature.balance || 0) >= requiredBalance;
+};
+var handleAllowed = ({ customer, params }) => {
+  if (!customer) return false;
+  if (!params.featureId && !params.productId) {
+    throw new Error("allowed() requires either featureId or productId");
+  }
+  if (params.featureId) {
+    return handleFeatureAllowed({ customer, params });
+  }
+  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 false;
+};
+
 // src/libraries/react/hooks/useCustomerBase.tsx
+var emptyDefaultFunctions = {
+  attach: "",
+  check: "",
+  track: "",
+  cancel: "",
+  openBillingPortal: ""
+};
 var useCustomerBase = ({
   params,
   AutumnContext: AutumnContext2,
@@ -788,19 +1144,19 @@ var useCustomerBase = ({
     client = context.client;
   }
   const fetchCustomer = async () => {
-    const { data: data2, error: error2 } = await client.createCustomer({
+    const { data, error: error2 } = await client.createCustomer({
       errorOnNotFound: params?.errorOnNotFound,
       expand: params?.expand
     });
     if (error2) {
       throw error2;
     }
-    if (!data2) {
+    if (!data) {
       return null;
     }
-    return data2;
+    return data;
   };
-  const { data, error, isLoading, mutate } = (0, import_swr.default)(queryKey, fetchCustomer, {
+  const { data: customer, error, isLoading, mutate } = (0, import_swr2.default)(queryKey, fetchCustomer, {
     fallbackData: null,
     onErrorRetry: (error2, key, config) => {
       if (error2.code == "entity_not_found") {
@@ -809,14 +1165,20 @@ var useCustomerBase = ({
       return true;
     }
   });
+  let autumnFunctions = emptyDefaultFunctions;
+  if (AutumnContext2) {
+    autumnFunctions = useAutumnBase({ AutumnContext: AutumnContext2 });
+  }
   return {
-    customer: error ? null : data,
+    customer: error ? null : customer,
     isLoading,
     error,
     refetch: mutate,
+    ...autumnFunctions,
     createEntity: client.entities.create,
     createReferralCode: client.referrals.createCode,
-    redeemReferralCode: client.referrals.redeemCode
+    redeemReferralCode: client.referrals.redeemCode,
+    allowed: (params2) => handleAllowed({ customer, params: params2 })
   };
 };
 
@@ -825,7 +1187,8 @@ var import_jsx_runtime = require("react/jsx-runtime");
 function BaseAutumnProvider({
   client,
   children,
-  AutumnContext: AutumnContext2
+  AutumnContext: AutumnContext2,
+  disableDialogs = false
 }) {
   const [components, setComponents] = (0, import_react3.useState)({});
   const [paywallProps, setPaywallProps, paywallOpen, setPaywallOpen] = useDialog(components.paywallDialog);
@@ -842,6 +1205,7 @@ function BaseAutumnProvider({
       value: {
         initialized: true,
         client,
+        disableDialogs,
         paywallDialog: {
           props: paywallProps,
           setProps: setPaywallProps,
@@ -854,7 +1218,7 @@ function BaseAutumnProvider({
             });
           }
         },
-        prodChangeDialog: {
+        attachDialog: {
           props: productChangeProps,
           setProps: setProductChangeProps,
           open: productChangeOpen,

package/dist/libraries/react/BaseAutumnProvider.mjs

@@ -3,18 +3,22 @@
 "use client";
 import {
   BaseAutumnProvider
-} from "./chunk-NJFRQ6T4.mjs";
-import "./chunk-A6J237PD.mjs";
+} from "./chunk-QMIIDFRP.mjs";
 import "./chunk-4QPHNIQ7.mjs";
-import "./chunk-EOSHPHLH.mjs";
-import "./chunk-XDAZD5HF.mjs";
-import "./chunk-JNJ53ZW6.mjs";
-import "./chunk-CIBQ4BJU.mjs";
-import "./chunk-LS3NB4DU.mjs";
+import "./chunk-GTF7A5TG.mjs";
+import "./chunk-JFXBUWKA.mjs";
+import "./chunk-ZQ6LDLK5.mjs";
+import "./chunk-Q7CK32YT.mjs";
+import "./chunk-B7HGBQCO.mjs";
+import "./chunk-CE5BBB5H.mjs";
+import "./chunk-YUV2Y2RW.mjs";
 import "./chunk-TBCLSIC2.mjs";
+import "./chunk-EH2VPTFH.mjs";
+import "./chunk-CIBQ4BJU.mjs";
 import "./chunk-NZ5PEXT2.mjs";
 import "./chunk-TGX6UKKS.mjs";
 import "./chunk-4KKWHG2V.mjs";
+import "./chunk-LS3NB4DU.mjs";
 import "./chunk-ZNPQQ2WK.mjs";
 export {
   BaseAutumnProvider

package/dist/libraries/react/{ReactAutumnClient-EjsfCAgE.d.mts → ReactAutumnClient-4e3t4WTF.d.mts}

@@ -2,10 +2,28 @@ import { CreateReferralCodeParams, RedeemReferralCodeParams } from './client/typ
 import { CreateEntityParams, GetEntityParams } from './client/types/clientEntTypes.mjs';
 import { AttachParams, CancelParams, CheckParams, TrackParams, OpenBillingPortalParams } from './client/types/clientGenTypes.mjs';
 import { A as AutumnError } from './error-DHbclCVh.mjs';
-import { R as Result, A as AutumnPromise, a as AttachResult, C as CancelResult, b as CheckResult, T as TrackResult } from './response-By38xiUq.mjs';
-import { C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResponse } from './cusTypes-Cf-s9PYP.mjs';
-import { P as PricingTableProduct } from './componentTypes-HF9MRJPX.mjs';
-import { E as Entity, D as DeleteEntityResult } from './entTypes-CV-165S-.mjs';
+import { R as Result, A as AutumnPromise, a as AttachResult, C as CancelResult, b as CheckResult, T as TrackResult } from './response-ChCmaLBk.mjs';
+import { C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResult } from './cusTypes-DNx5bwlw.mjs';
+import { b as ProductItem, e as ProductScenario, P as Product } from './checkTypes-CyKIOmeF.mjs';
+import { E as Entity, D as DeleteEntityResult } from './entTypes-8gkfAi3g.mjs';
+
+interface PricingTableProduct {
+    id: string;
+    name: string;
+    description?: string;
+    button_text?: string;
+    recommend_text?: string;
+    everything_from?: string;
+    price: {
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem;
+    items: ({
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem)[];
+    scenario: ProductScenario;
+}
 
 interface CreateReferralCodeResult {
     code: string;
@@ -55,7 +73,7 @@ declare class AutumnClient {
     cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
     check: (params: CheckParams) => AutumnPromise<CheckResult>;
     track: (params: TrackParams) => AutumnPromise<TrackResult>;
-    openBillingPortal: (params?: OpenBillingPortalParams | undefined) => AutumnPromise<BillingPortalResponse>;
+    openBillingPortal: (params?: OpenBillingPortalParams | undefined) => AutumnPromise<BillingPortalResult>;
     entities: {
         create: (params: CreateEntityParams | CreateEntityParams[]) => AutumnPromise<Entity | Entity[]>;
         get: (entityId: string, params?: GetEntityParams | undefined) => AutumnPromise<Entity>;
@@ -65,6 +83,11 @@ declare class AutumnClient {
         createCode: (params: CreateReferralCodeParams) => AutumnPromise<CreateReferralCodeResult>;
         redeemCode: (params: RedeemReferralCodeParams) => AutumnPromise<RedeemReferralCodeResult>;
     };
+    products: {
+        list: () => AutumnPromise<{
+            list: Product[];
+        }>;
+    };
 }
 
-export { AutumnClient as A, type CreateReferralCodeResult as C, type ErrorResponse as E, type OmitCustomerType as O, type RedeemReferralCodeResult as R, type AutumnClientConfig as a };
+export { AutumnClient as A, type CreateReferralCodeResult as C, type ErrorResponse as E, type OmitCustomerType as O, type PricingTableProduct as P, type RedeemReferralCodeResult as R, type AutumnClientConfig as a };

package/dist/libraries/react/{ReactAutumnClient-BM8hrCEC.d.ts → ReactAutumnClient-B-lWmwRW.d.ts}

@@ -2,10 +2,28 @@ import { CreateReferralCodeParams, RedeemReferralCodeParams } from './client/typ
 import { CreateEntityParams, GetEntityParams } from './client/types/clientEntTypes.js';
 import { AttachParams, CancelParams, CheckParams, TrackParams, OpenBillingPortalParams } from './client/types/clientGenTypes.js';
 import { A as AutumnError } from './error-DHbclCVh.js';
-import { R as Result, A as AutumnPromise, a as AttachResult, C as CancelResult, b as CheckResult, T as TrackResult } from './response-B2MqTR7X.js';
-import { C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResponse } from './cusTypes-Cf-s9PYP.js';
-import { P as PricingTableProduct } from './componentTypes-HF9MRJPX.js';
-import { E as Entity, D as DeleteEntityResult } from './entTypes-BbIk0Toa.js';
+import { R as Result, A as AutumnPromise, a as AttachResult, C as CancelResult, b as CheckResult, T as TrackResult } from './response-9K8DyGXf.js';
+import { C as CustomerData, a as CreateCustomerParams, b as Customer, B as BillingPortalResult } from './cusTypes-DNx5bwlw.js';
+import { b as ProductItem, e as ProductScenario, P as Product } from './checkTypes-BDNI_s2B.js';
+import { E as Entity, D as DeleteEntityResult } from './entTypes-C8jD10M8.js';
+
+interface PricingTableProduct {
+    id: string;
+    name: string;
+    description?: string;
+    button_text?: string;
+    recommend_text?: string;
+    everything_from?: string;
+    price: {
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem;
+    items: ({
+        primary_text: string;
+        secondary_text?: string;
+    } & ProductItem)[];
+    scenario: ProductScenario;
+}
 
 interface CreateReferralCodeResult {
     code: string;
@@ -55,7 +73,7 @@ declare class AutumnClient {
     cancel: (params: CancelParams) => AutumnPromise<CancelResult>;
     check: (params: CheckParams) => AutumnPromise<CheckResult>;
     track: (params: TrackParams) => AutumnPromise<TrackResult>;
-    openBillingPortal: (params?: OpenBillingPortalParams | undefined) => AutumnPromise<BillingPortalResponse>;
+    openBillingPortal: (params?: OpenBillingPortalParams | undefined) => AutumnPromise<BillingPortalResult>;
     entities: {
         create: (params: CreateEntityParams | CreateEntityParams[]) => AutumnPromise<Entity | Entity[]>;
         get: (entityId: string, params?: GetEntityParams | undefined) => AutumnPromise<Entity>;
@@ -65,6 +83,11 @@ declare class AutumnClient {
         createCode: (params: CreateReferralCodeParams) => AutumnPromise<CreateReferralCodeResult>;
         redeemCode: (params: RedeemReferralCodeParams) => AutumnPromise<RedeemReferralCodeResult>;
     };
+    products: {
+        list: () => AutumnPromise<{
+            list: Product[];
+        }>;
+    };
 }
 
-export { AutumnClient as A, type CreateReferralCodeResult as C, type ErrorResponse as E, type OmitCustomerType as O, type RedeemReferralCodeResult as R, type AutumnClientConfig as a };
+export { AutumnClient as A, type CreateReferralCodeResult as C, type ErrorResponse as E, type OmitCustomerType as O, type PricingTableProduct as P, type RedeemReferralCodeResult as R, type AutumnClientConfig as a };

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

@@ -1,12 +1,13 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { C as CustomerData } from './cusTypes-Cf-s9PYP.mjs';
+import { C as CustomerData } from './cusTypes-DNx5bwlw.mjs';
 
-declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, }: {
+declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, disableDialogs, }: {
     children: React.ReactNode;
     getBearerToken?: () => Promise<string | null | undefined>;
     backendUrl?: string;
     customerData?: CustomerData;
     includeCredentials?: boolean;
+    disableDialogs?: boolean;
 }) => react_jsx_runtime.JSX.Element;
 
 export { ReactAutumnProvider };

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

@@ -1,12 +1,13 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { C as CustomerData } from './cusTypes-Cf-s9PYP.js';
+import { C as CustomerData } from './cusTypes-DNx5bwlw.js';
 
-declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, }: {
+declare const ReactAutumnProvider: ({ children, getBearerToken, backendUrl, customerData, includeCredentials, disableDialogs, }: {
     children: React.ReactNode;
     getBearerToken?: () => Promise<string | null | undefined>;
     backendUrl?: string;
     customerData?: CustomerData;
     includeCredentials?: boolean;
+    disableDialogs?: boolean;
 }) => react_jsx_runtime.JSX.Element;
 
 export { ReactAutumnProvider };