autumn-js 0.0.92 → 0.0.95

package/dist/libraries/react/ReactAutumnProvider.js

@@ -550,44 +550,96 @@ var Autumn = class {
   }
 };
 
-// src/sdk/general/genTypes.ts
+// src/sdk/customers/entities/entTypes.ts
 var import_zod = require("zod");
-var AttachParamsSchema = import_zod.z.object({
-  customer_id: import_zod.z.string(),
-  product_id: import_zod.z.string().optional(),
-  entity_id: import_zod.z.string().optional(),
-  options: import_zod.z.array(import_zod.z.object({
-    feature_id: import_zod.z.string(),
-    quantity: import_zod.z.number()
-  })).optional(),
-  product_ids: import_zod.z.array(import_zod.z.string()).optional(),
+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 AttachFeatureOptionsSchema = import_zod2.z.object({
+  feature_id: import_zod2.z.string(),
+  quantity: import_zod2.z.number()
+});
+var AttachParamsSchema = import_zod2.z.object({
+  customer_id: import_zod2.z.string(),
+  product_id: import_zod2.z.string().optional(),
+  entity_id: import_zod2.z.string().optional(),
+  options: import_zod2.z.array(
+    import_zod2.z.object({
+      feature_id: import_zod2.z.string(),
+      quantity: import_zod2.z.number()
+    })
+  ).optional(),
+  product_ids: import_zod2.z.array(import_zod2.z.string()).optional(),
   // If set, will attach multiple products to the customer (cannot be used with product_id)
-  free_trial: import_zod.z.boolean().optional(),
+  free_trial: import_zod2.z.boolean().optional(),
   // Default is true -- if set to false, will bypass product free trial
-  success_url: import_zod.z.string().optional(),
+  success_url: import_zod2.z.string().optional(),
   // Passed to Stripe
-  metadata: import_zod.z.record(import_zod.z.string()).optional(),
+  metadata: import_zod2.z.record(import_zod2.z.string()).optional(),
   // Passed to Stripe
-  force_checkout: import_zod.z.boolean().optional(),
+  force_checkout: import_zod2.z.boolean().optional(),
   // Default is false -- if set to true, will force the customer to checkout (not allowed for upgrades / downgrades)
-  customer_data: import_zod.z.any().optional(),
-  entity_data: import_zod.z.any().optional(),
-  checkout_session_params: import_zod.z.record(import_zod.z.any()).optional(),
+  customer_data: import_zod2.z.any().optional(),
+  entity_data: import_zod2.z.any().optional(),
+  checkout_session_params: import_zod2.z.record(import_zod2.z.any()).optional(),
   // Passed to Stripe
-  reward: import_zod.z.string().optional()
+  reward: import_zod2.z.string().optional()
+});
+var AttachResultSchema = import_zod2.z.object({
+  checkout_url: import_zod2.z.string().optional(),
+  customer_id: import_zod2.z.string(),
+  product_ids: import_zod2.z.array(import_zod2.z.string()),
+  code: import_zod2.z.string(),
+  message: import_zod2.z.string(),
+  customer_data: import_zod2.z.any().optional()
 });
-var AttachResultSchema = import_zod.z.object({
-  checkout_url: import_zod.z.string().optional(),
-  customer_id: import_zod.z.string(),
-  product_ids: import_zod.z.array(import_zod.z.string()),
-  code: import_zod.z.string(),
-  message: import_zod.z.string(),
-  customer_data: import_zod.z.any().optional()
+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/customers/cusEnums.ts
-var import_zod2 = require("zod");
-var CustomerExpandEnum = import_zod2.z.enum([
+var import_zod3 = require("zod");
+var CustomerExpandEnum = import_zod3.z.enum([
   "invoices",
   "rewards",
   "trials_used",
@@ -597,14 +649,28 @@ var CustomerExpandEnum = import_zod2.z.enum([
 ]);
 
 // src/sdk/customers/cusTypes.ts
-var import_zod3 = require("zod");
-var CreateCustomerParamsSchema = import_zod3.z.object({
-  id: import_zod3.z.string().nullish(),
-  email: import_zod3.z.string().nullish(),
-  name: import_zod3.z.string().nullish(),
-  fingerprint: import_zod3.z.string().nullish(),
-  metadata: import_zod3.z.record(import_zod3.z.any()).optional(),
-  expand: import_zod3.z.array(CustomerExpandEnum).optional()
+var import_zod4 = require("zod");
+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 BillingPortalParamsSchema = import_zod4.z.object({
+  return_url: import_zod4.z.string().optional()
+});
+
+// src/sdk/referrals/referralTypes.ts
+var import_zod5 = require("zod");
+var CreateReferralCodeParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  program_id: import_zod5.z.string()
+});
+var RedeemReferralCodeParamsSchema = import_zod5.z.object({
+  code: import_zod5.z.string(),
+  customer_id: import_zod5.z.string()
 });
 
 // src/libraries/react/errorUtils/logFetchError.ts
@@ -622,7 +688,7 @@ var logFetchError = ({
 
 // src/libraries/react/client/clientCompMethods.ts
 async function getPricingTableMethod() {
-  const res = await this.get("/api/autumn/components/pricing_table");
+  const res = await this.get(`${this.prefix}/components/pricing_table`);
   return res;
 }
 
@@ -631,7 +697,7 @@ var createCustomerMethod = async ({
   client,
   params
 }) => {
-  let result = await client.post("/api/autumn/customers", params);
+  let result = await client.post(`${client.prefix}/customers`, params);
   return result;
 };
 
@@ -667,17 +733,17 @@ var getEntityExpandStr = (expand) => {
 // src/libraries/react/client/clientEntityMethods.ts
 async function createEntityMethod(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/entities", snakeParams);
+  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(`/api/autumn/entities/${entityId}?${expand}`);
+  const res = await this.get(`${this.prefix}/entities/${entityId}?${expand}`);
   return res;
 }
 async function deleteEntityMethod(entityId) {
-  const res = await this.delete(`/api/autumn/entities/${entityId}`);
+  const res = await this.delete(`${this.prefix}/entities/${entityId}`);
   return res;
 }
 
@@ -685,51 +751,51 @@ async function deleteEntityMethod(entityId) {
 async function attachMethod(params) {
   let { dialog, ...rest } = params;
   let snakeParams = toSnakeCase(rest, ["checkoutSessionparams"]);
-  const res = await this.post("/api/autumn/attach", snakeParams);
+  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("/api/autumn/setup_payment", snakeParams);
+  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("/api/autumn/cancel", snakeParams);
+  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("/api/autumn/check", snakeParams);
+  const res = await this.post(`${this.prefix}/check`, snakeParams);
   return res;
 }
 async function trackMethod(params) {
   let snakeParams = toSnakeCase(params);
-  const res = await this.post("/api/autumn/track", snakeParams);
+  const res = await this.post(`${this.prefix}/track`, snakeParams);
   return res;
 }
 async function openBillingPortalMethod(params) {
   let snakeParams = toSnakeCase(params || {});
-  const res = await this.post("/api/autumn/billing_portal", snakeParams);
+  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("/api/autumn/products");
+  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("/api/autumn/referrals/code", snakeParams);
+  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("/api/autumn/referrals/redeem", snakeParams);
+  const res = await this.post(`${this.prefix}/referrals/redeem`, snakeParams);
   return res;
 }
 
@@ -739,23 +805,31 @@ var AutumnClient = class {
   getBearerToken;
   customerData;
   includeCredentials;
-  corsDetected;
-  corsSupportsCredentials;
+  prefix;
   constructor({
     backendUrl,
     getBearerToken,
     customerData,
-    includeCredentials
+    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, {
@@ -935,6 +1009,9 @@ var useAutumnContext = ({
   errorIfNotInitialized = true
 }) => {
   const context = (0, import_react2.useContext)(AutumnContext2);
+  if (!context.initialized && errorIfNotInitialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
+  }
   return context;
 };
 
@@ -1387,21 +1464,19 @@ var useCustomerBase = ({
   AutumnContext: AutumnContext2,
   client
 }) => {
-  const queryKey = ["customer", params?.expand];
   let context;
-  let authClientExists = !!params?.authClient;
   if (AutumnContext2) {
     context = useAutumnContext({
       AutumnContext: AutumnContext2,
-      name: "useCustomer",
-      errorIfNotInitialized: !authClientExists
+      name: "useCustomer"
+      // errorIfNotInitialized: !authClientExists,
     });
   }
-  if (authClientExists) {
-    client = params?.authClient?.autumn;
-  } else if (!client) {
+  if (!client) {
     client = context.client;
   }
+  let baseUrl = client?.backendUrl || "";
+  const queryKey = ["customer", baseUrl, params?.expand];
   const fetchCustomer = async () => {
     const { data, error: error2 } = await client.createCustomer({
       errorOnNotFound: params?.errorOnNotFound,
@@ -1425,10 +1500,9 @@ var useCustomerBase = ({
     ...params?.swrConfig
   });
   let autumnFunctions = emptyDefaultFunctions;
-  if (AutumnContext2 || params?.authClient) {
+  if (AutumnContext2) {
     autumnFunctions = useAutumnBase({
-      AutumnContext: AutumnContext2,
-      authClient: params?.authClient
+      AutumnContext: AutumnContext2
     });
   }
   return {
@@ -1531,13 +1605,14 @@ var ReactAutumnProvider = ({
   backendUrl,
   customerData,
   includeCredentials,
-  authClient
+  betterAuthUrl
 }) => {
   let client = new AutumnClient({
     backendUrl: getBackendUrl(backendUrl),
     getBearerToken,
     customerData,
-    includeCredentials
+    includeCredentials,
+    betterAuthUrl
   });
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(BaseAutumnProvider, { client, AutumnContext, children });
 };

package/dist/libraries/react/ReactAutumnProvider.mjs

@@ -2,24 +2,24 @@
 
 import {
   ReactAutumnProvider
-} from "./chunk-L3IZ2O3T.mjs";
-import "./chunk-DIJJCQ2N.mjs";
-import "./chunk-4QPHNIQ7.mjs";
-import "./chunk-6SDVW33H.mjs";
+} from "./chunk-AOJCMXVS.mjs";
+import "./chunk-DVMVIAZE.mjs";
+import "./chunk-T5PIJ4HG.mjs";
 import "./chunk-3JJC2VU5.mjs";
-import "./chunk-RZW3QO6B.mjs";
-import "./chunk-TCCWWPEC.mjs";
-import "./chunk-HL4JNKWK.mjs";
-import "./chunk-NCPXL3J2.mjs";
-import "./chunk-V5PKOA5A.mjs";
-import "./chunk-JNM4BLTM.mjs";
-import "./chunk-YUV2Y2RW.mjs";
-import "./chunk-3EYF7OI5.mjs";
-import "./chunk-KQT5G3HT.mjs";
+import "./chunk-LVDONEVF.mjs";
+import "./chunk-R4BYOLST.mjs";
+import "./chunk-4QPHNIQ7.mjs";
+import "./chunk-G3FBFZLU.mjs";
+import "./chunk-ALFXUHDD.mjs";
 import "./chunk-JVCOY7ZL.mjs";
 import "./chunk-CIBQ4BJU.mjs";
-import "./chunk-NZ5PEXT2.mjs";
-import "./chunk-TGX6UKKS.mjs";
+import "./chunk-V575SGOW.mjs";
+import "./chunk-ZV4RPZTM.mjs";
+import "./chunk-VTGR7VVK.mjs";
+import "./chunk-WFFVOEUG.mjs";
+import "./chunk-ZF2HUCN6.mjs";
+import "./chunk-VUBJ6JM3.mjs";
+import "./chunk-KQT5G3HT.mjs";
 export {
   ReactAutumnProvider
 };

package/dist/libraries/react/{chunk-LPJSRHPQ.mjs → chunk-5G3DYUNT.mjs}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-3JJC2VU5.mjs";
 import {
   useAutumnBase
-} from "./chunk-RZW3QO6B.mjs";
+} from "./chunk-LVDONEVF.mjs";
 
 // src/libraries/react/hooks/useEntityBase.tsx
 import useSWR from "swr";

package/dist/libraries/react/{chunk-VH4FTCAC.mjs → chunk-6CJ3FB74.mjs}

@@ -2,10 +2,10 @@
 
 import {
   useCustomerBase
-} from "./chunk-6SDVW33H.mjs";
+} from "./chunk-T5PIJ4HG.mjs";
 import {
   AutumnContext
-} from "./chunk-HL4JNKWK.mjs";
+} from "./chunk-G3FBFZLU.mjs";
 
 // src/libraries/react/hooks/useCustomer.tsx
 var useCustomer = (params) => {

package/dist/libraries/react/{chunk-NCPXL3J2.mjs → chunk-ALFXUHDD.mjs}

@@ -1,37 +1,37 @@
 "use client";
 
 import {
-  createEntityMethod,
-  deleteEntityMethod,
-  getEntityMethod
-} from "./chunk-V5PKOA5A.mjs";
+  logAuthError
+} from "./chunk-JVCOY7ZL.mjs";
 import {
-  attachMethod,
-  cancelMethod,
-  checkMethod,
-  openBillingPortalMethod,
-  setupPaymentMethod,
-  trackMethod
-} from "./chunk-JNM4BLTM.mjs";
+  logFetchError
+} from "./chunk-CIBQ4BJU.mjs";
 import {
   listProductsMethod
-} from "./chunk-YUV2Y2RW.mjs";
+} from "./chunk-V575SGOW.mjs";
 import {
   createCode,
   redeemCode
-} from "./chunk-3EYF7OI5.mjs";
-import {
-  logAuthError
-} from "./chunk-JVCOY7ZL.mjs";
-import {
-  logFetchError
-} from "./chunk-CIBQ4BJU.mjs";
+} from "./chunk-ZV4RPZTM.mjs";
 import {
   getPricingTableMethod
-} from "./chunk-NZ5PEXT2.mjs";
+} from "./chunk-VTGR7VVK.mjs";
 import {
   createCustomerMethod
-} from "./chunk-TGX6UKKS.mjs";
+} from "./chunk-WFFVOEUG.mjs";
+import {
+  createEntityMethod,
+  deleteEntityMethod,
+  getEntityMethod
+} from "./chunk-ZF2HUCN6.mjs";
+import {
+  attachMethod,
+  cancelMethod,
+  checkMethod,
+  openBillingPortalMethod,
+  setupPaymentMethod,
+  trackMethod
+} from "./chunk-VUBJ6JM3.mjs";
 
 // src/sdk/error.ts
 var AutumnError = class _AutumnError extends Error {
@@ -510,44 +510,96 @@ var Autumn = class {
   }
 };
 
-// src/sdk/general/genTypes.ts
+// src/sdk/customers/entities/entTypes.ts
 import { z } from "zod";
-var AttachParamsSchema = z.object({
-  customer_id: z.string(),
-  product_id: z.string().optional(),
-  entity_id: z.string().optional(),
-  options: z.array(z.object({
-    feature_id: z.string(),
-    quantity: z.number()
-  })).optional(),
-  product_ids: z.array(z.string()).optional(),
+var EntityDataSchema = z.object({
+  name: z.string().optional(),
+  feature_id: z.string()
+});
+
+// src/sdk/general/genTypes.ts
+import { z as z2 } from "zod";
+var AttachFeatureOptionsSchema = z2.object({
+  feature_id: z2.string(),
+  quantity: z2.number()
+});
+var AttachParamsSchema = z2.object({
+  customer_id: z2.string(),
+  product_id: z2.string().optional(),
+  entity_id: z2.string().optional(),
+  options: z2.array(
+    z2.object({
+      feature_id: z2.string(),
+      quantity: z2.number()
+    })
+  ).optional(),
+  product_ids: z2.array(z2.string()).optional(),
   // If set, will attach multiple products to the customer (cannot be used with product_id)
-  free_trial: z.boolean().optional(),
+  free_trial: z2.boolean().optional(),
   // Default is true -- if set to false, will bypass product free trial
-  success_url: z.string().optional(),
+  success_url: z2.string().optional(),
   // Passed to Stripe
-  metadata: z.record(z.string()).optional(),
+  metadata: z2.record(z2.string()).optional(),
   // Passed to Stripe
-  force_checkout: z.boolean().optional(),
+  force_checkout: z2.boolean().optional(),
   // Default is false -- if set to true, will force the customer to checkout (not allowed for upgrades / downgrades)
-  customer_data: z.any().optional(),
-  entity_data: z.any().optional(),
-  checkout_session_params: z.record(z.any()).optional(),
+  customer_data: z2.any().optional(),
+  entity_data: z2.any().optional(),
+  checkout_session_params: z2.record(z2.any()).optional(),
   // Passed to Stripe
-  reward: z.string().optional()
+  reward: z2.string().optional()
+});
+var AttachResultSchema = z2.object({
+  checkout_url: z2.string().optional(),
+  customer_id: z2.string(),
+  product_ids: z2.array(z2.string()),
+  code: z2.string(),
+  message: z2.string(),
+  customer_data: z2.any().optional()
+});
+var CancelParamsSchema = z2.object({
+  customer_id: z2.string(),
+  product_id: z2.string(),
+  entity_id: z2.string().optional(),
+  cancel_immediately: z2.boolean().optional()
+});
+var CancelResultSchema = z2.object({
+  success: z2.boolean(),
+  customer_id: z2.string(),
+  product_id: z2.string()
 });
-var AttachResultSchema = z.object({
-  checkout_url: z.string().optional(),
-  customer_id: z.string(),
-  product_ids: z.array(z.string()),
-  code: z.string(),
-  message: z.string(),
-  customer_data: z.any().optional()
+var TrackParamsSchema = z2.object({
+  customer_id: z2.string(),
+  value: z2.number().optional(),
+  feature_id: z2.string().optional(),
+  event_name: z2.string().optional(),
+  entity_id: z2.string().optional(),
+  customer_data: z2.any().optional(),
+  idempotency_key: z2.string().optional(),
+  entity_data: z2.any().optional()
+});
+var TrackResultSchema = z2.object({
+  id: z2.string(),
+  code: z2.string(),
+  customer_id: z2.string(),
+  feature_id: z2.string().optional(),
+  event_name: z2.string().optional()
+});
+var CheckParamsSchema = z2.object({
+  customer_id: z2.string(),
+  feature_id: z2.string().optional(),
+  product_id: z2.string().optional(),
+  entity_id: z2.string().optional(),
+  customer_data: z2.any().optional(),
+  required_balance: z2.number().optional(),
+  send_event: z2.boolean().optional(),
+  with_preview: z2.boolean().optional(),
+  entity_data: EntityDataSchema.optional()
 });
 
 // src/sdk/customers/cusEnums.ts
-import { z as z2 } from "zod";
-var CustomerExpandEnum = z2.enum([
+import { z as z3 } from "zod";
+var CustomerExpandEnum = z3.enum([
   "invoices",
   "rewards",
   "trials_used",
@@ -557,14 +609,28 @@ var CustomerExpandEnum = z2.enum([
 ]);
 
 // src/sdk/customers/cusTypes.ts
-import { z as z3 } from "zod";
-var CreateCustomerParamsSchema = z3.object({
-  id: z3.string().nullish(),
-  email: z3.string().nullish(),
-  name: z3.string().nullish(),
-  fingerprint: z3.string().nullish(),
-  metadata: z3.record(z3.any()).optional(),
-  expand: z3.array(CustomerExpandEnum).optional()
+import { z as z4 } from "zod";
+var CreateCustomerParamsSchema = z4.object({
+  id: z4.string().nullish(),
+  email: z4.string().nullish(),
+  name: z4.string().nullish(),
+  fingerprint: z4.string().nullish(),
+  metadata: z4.record(z4.any()).optional(),
+  expand: z4.array(CustomerExpandEnum).optional()
+});
+var BillingPortalParamsSchema = z4.object({
+  return_url: z4.string().optional()
+});
+
+// src/sdk/referrals/referralTypes.ts
+import { z as z5 } from "zod";
+var CreateReferralCodeParamsSchema = z5.object({
+  customer_id: z5.string(),
+  program_id: z5.string()
+});
+var RedeemReferralCodeParamsSchema = z5.object({
+  code: z5.string(),
+  customer_id: z5.string()
 });
 
 // src/libraries/react/client/ReactAutumnClient.tsx
@@ -573,23 +639,31 @@ var AutumnClient = class {
   getBearerToken;
   customerData;
   includeCredentials;
-  corsDetected;
-  corsSupportsCredentials;
+  prefix;
   constructor({
     backendUrl,
     getBearerToken,
     customerData,
-    includeCredentials
+    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, {