@betterstore/sdk 0.6.12 → 0.7.1

package/dist/index.mjs

@@ -1,618 +1,332 @@
-// src/_utils/axios.ts
-import axios from "axios";
-var API_BASE_URL = "https://v1.betterstore.io";
-var createApiClient = (apiKey, proxy) => {
-  const client = axios.create({
-    baseURL: proxy ?? API_BASE_URL,
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-      "Access-Control-Allow-Headers": "Content-Type, Authorization"
-    }
-  });
-  client.interceptors.response.use(
-    (response) => response.data,
-    (error) => {
-      const apiError = {
-        isError: true,
-        status: 500,
-        message: "An unexpected error occurred"
-      };
-      if (error.response) {
-        apiError.status = error.response.status;
-        apiError.message = error.response.data?.error || "Server error occurred";
-        apiError.code = error.response.data?.code;
-        apiError.details = error.response.data;
-      } else if (error.request) {
-        apiError.status = 503;
-        apiError.message = "Service unavailable - no response from server";
-        apiError.code = "SERVICE_UNAVAILABLE";
-        apiError.details = error;
-      } else {
-        apiError.status = 500;
-        apiError.message = "Request configuration error";
-        apiError.code = "REQUEST_SETUP_ERROR";
-        apiError.details = error;
-      }
-      console.error("API ERROR: ", apiError);
-      if (apiError.code === "REQUEST_SETUP_ERROR" || apiError.code === "SERVICE_UNAVAILABLE") {
-        throw apiError;
-      }
-      return apiError;
-    }
-  );
-  return client;
-};
-
-// src/auth/providers/otp.ts
-var OTP = class {
-  apiClient;
-  constructor(apiClient) {
-    this.apiClient = apiClient;
-  }
-  async signup(params) {
-    const data = await this.apiClient.post(
-      "/auth/otp/signup",
-      params
-    );
-    return data;
+// src/base-client.ts
+var BaseClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async get(path, params) {
+    const url = new URL(path, this.config.baseUrl);
+    if (params) {
+      Object.entries(params).forEach(([key, val]) => {
+        if (val !== void 0) url.searchParams.set(key, String(val));
+      });
+    }
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: this.config.headers
+    });
+    return this.handleResponse(res);
   }
-  async login(params) {
-    const data = await this.apiClient.post(
-      "/auth/otp/login",
-      params
-    );
-    return data;
+  async post(path, body) {
+    const res = await fetch(`${this.config.baseUrl}${path}`, {
+      method: "POST",
+      headers: this.config.headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleResponse(res);
   }
-  async verify(params) {
-    const data = await this.apiClient.post(
-      "/auth/otp/verify",
-      params
-    );
-    return data;
+  async delete(path) {
+    const res = await fetch(`${this.config.baseUrl}${path}`, {
+      method: "DELETE",
+      headers: this.config.headers
+    });
+    return this.handleResponse(res);
   }
-};
-
-// src/auth/index.ts
-var Auth = class {
-  apiClient;
-  otp;
-  constructor(apiKey, proxy) {
-    this.apiClient = createApiClient(apiKey, proxy);
-    this.otp = new OTP(this.apiClient);
-  }
-  async retrieveSession(id) {
-    const data = await this.apiClient.get(
-      `/auth/session/${id}`
-    );
-    if ("isError" in data && data.isError || !data || !("token" in data)) {
-      console.error(`Customer session with id ${id} not found`);
-      return null;
+  async handleResponse(res) {
+    if (!res.ok) {
+      const error = await res.json().catch(() => ({ message: res.statusText }));
+      throw new Error(error.message || `HTTP ${res.status}`);
     }
-    return data;
+    return res.json();
   }
 };
-var auth_default = Auth;
 
-// src/checkout/index.ts
-var Checkout = class {
-  apiClient;
-  constructor(apiKey, proxy) {
-    this.apiClient = createApiClient(apiKey, proxy);
-  }
-  /**
-   * Create a new checkout session
-   */
-  async create(params) {
-    const data = await this.apiClient.post(
-      "/checkout",
-      params
+// src/namespaces/client/client-checkout.ts
+var ClientCheckoutNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(id) {
+    return this.client.get(
+      `/api/client/checkout/get/${id}`
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      throw new Error("Failed to create checkout session");
-    }
-    return data;
   }
-  /**
-   * Retrieve a checkout session by ID
-   */
-  async retrieve(checkoutId) {
-    const data = await this.apiClient.get(
-      `/checkout/${checkoutId}`
+  async update(id, data) {
+    return this.client.post(
+      `/api/client/checkout/update/${id}`,
+      data
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Checkout session with id ${checkoutId} not found`);
-      return null;
-    }
-    return data;
   }
-  /**
-   * Update a checkout session
-   */
-  async update(checkoutId, params) {
-    const data = await this.apiClient.put(
-      `/checkout/${checkoutId}`,
-      params
+  async getShippingRates(id) {
+    return this.client.get(
+      `/api/client/checkout/${id}/get-shipping-rates`
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Checkout session with id ${checkoutId} not found`);
-      return null;
-    }
-    return data;
   }
-  /**
-   * Apply a discount code to a checkout session
-   */
-  async applyDiscountCode(checkoutId, discountCode) {
-    const data = await this.apiClient.post(
-      `/checkout/${checkoutId}/discounts/apply`,
-      { code: discountCode }
+  async generatePaymentSecret(id) {
+    return this.client.post(
+      `/api/client/checkout/payment-secret/${id}`
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      throw new Error("Failed to apply discount code");
-    }
-    return data;
   }
-  /**
-   * Remove a discount  from a checkout session
-   */
-  async removeDiscount(checkoutId, discountId) {
-    const data = await this.apiClient.delete(
-      `/checkout/${checkoutId}/discounts/remove/${discountId}`
+  async revalidateDiscounts(id) {
+    return this.client.get(
+      `/api/client/checkout/${id}/discounts/revalidate`
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Checkout session with id ${checkoutId} not found`);
-      return null;
-    }
-    return data;
   }
-  /**
-   * Revalidate a checkout session
-   */
-  async revalidateDiscounts(checkoutId) {
-    const data = await this.apiClient.get(
-      `/checkout/${checkoutId}/discounts/revalidate`
+  async applyDiscount(id, data) {
+    return this.client.post(
+      `/api/client/checkout/${id}/discounts/apply`,
+      data
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Checkout session with id ${checkoutId} not found`);
-      return null;
-    }
-    return data;
   }
-  /**
-   * Get shipping rates for a checkout session
-   */
-  async getShippingRates(checkoutId) {
-    const data = await this.apiClient.get(
-      `/checkout/${checkoutId}/shipping/rates`
+  async removeDiscount(id, discountId) {
+    return this.client.delete(
+      `/api/client/checkout/${id}/discounts/remove/${discountId}`
     );
-    console.log("SHIPPING RATES DATA: ", data);
-    if ("isError" in data && data.isError || !data) {
-      console.error("Failed to get shipping rates: ", data);
-      return {};
-    }
-    return data;
-  }
-  /**
-   * Generate payment secret for a checkout session
-   */
-  async generatePaymentSecret(checkoutId) {
-    const data = await this.apiClient.post(`
-      /checkout/${checkoutId}/payment`);
-    if ("isError" in data && data.isError || !data || !("paymentSecret" in data)) {
-      throw new Error("Failed to generate payment secret");
-    }
-    return {
-      paymentSecret: data.paymentSecret,
-      publicKey: data.publicKey,
-      checkoutSession: data.checkoutSession
-    };
   }
 };
-var checkout_default = Checkout;
 
-// src/client/index.ts
-var Client = class {
-  proxy;
-  constructor(proxy) {
-    this.proxy = proxy;
+// src/namespaces/client/client-customers.ts
+var ClientCustomersNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async upsert(data) {
+    return this.client.post(
+      "/api/client/customers/upsert",
+      data
+    );
   }
-  /**
-   * Retrieve a checkout session by ID
-   */
-  async retrieveCheckout(clientSecret, checkoutId) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.get(
-      `/checkout/${checkoutId}`
+  async update(id, data) {
+    return this.client.post(
+      `/api/client/customers/update/${id}`,
+      data
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Checkout session with id ${checkoutId} not found`);
-      return null;
-    }
-    return data;
   }
-  /**
-   * Update a checkout session
-   */
-  async updateCheckout(clientSecret, checkoutId, params) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.put(
-      `/checkout/${checkoutId}`,
+};
+
+// src/namespaces/client/client-utils.ts
+var ClientUtilsNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getExchangeRates(currency) {
+    return this.client.get(`/api/client/utils/get-exchange-rates/${currency}`);
+  }
+  async autosuggestAddress(params) {
+    const { query, locale, latitude, longitude, countryCode } = params;
+    return this.client.get(`/api/client/utils/autosuggest-address`, {
+      query,
+      locale,
+      latitude,
+      longitude,
+      countryCode
+    });
+  }
+  async lookupAddressById(id, params = {}) {
+    return this.client.get(
+      `/api/client/utils/lookup-address-by-id/${id}`,
       params
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Checkout session with id ${checkoutId} not found`);
-      return null;
-    }
-    return data;
   }
-  /**
-   * Apply a discount code to a checkout session
-   */
-  async applyDiscountCode(clientSecret, checkoutId, discountCode) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.post(
-      `/checkout/${checkoutId}/discounts/apply`,
-      { code: discountCode }
-    );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      throw new Error("Failed to apply discount code");
+};
+
+// src/client-factory.ts
+function createBetterStoreClient(clientSecret, config) {
+  const baseClient = new BaseClient({
+    baseUrl: config?.proxy || "https://api.betterstore.com",
+    headers: {
+      Authorization: `Bearer ${clientSecret}`,
+      "Content-Type": "application/json"
     }
-    return data;
+  });
+  return {
+    checkout: new ClientCheckoutNamespace(baseClient),
+    customers: new ClientCustomersNamespace(baseClient),
+    utils: new ClientUtilsNamespace(baseClient)
+  };
+}
+
+// src/namespaces/auth.ts
+var AuthNamespace = class {
+  constructor(client) {
+    this.client = client;
   }
-  /**
-   * Remove a discount code from a checkout session
-   */
-  async removeDiscount(clientSecret, checkoutId, discountId) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.delete(
-      `/checkout/${checkoutId}/discounts/remove/${discountId}`
-    );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      throw new Error("Failed to remove discount code");
-    }
-    return data;
+  async loginCustomerOtp(params) {
+    return this.client.post("/api/auth/login-customer-otp", params);
   }
-  /**
-   * Revalidate a checkout session
-   */
-  async revalidateDiscounts(clientSecret, checkoutId) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.get(
-      `/checkout/${checkoutId}/discounts/revalidate`
-    );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Checkout session with id ${checkoutId} not found`);
-      return null;
-    }
-    return data;
+  async signupCustomerOtp(params) {
+    return this.client.post("/api/auth/signup-customer-otp", params);
   }
-  /**
-   * Get shipping rates for a checkout session
-   */
-  async getCheckoutShippingRates(clientSecret, checkoutId) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.get(
-      `/checkout/${checkoutId}/shipping/rates`
+  async verifyCustomerOtp(params) {
+    return this.client.post("/api/auth/verify-customer-otp", params);
+  }
+  async getCustomerSession(id) {
+    return this.client.get(`/api/auth/get-customer-session/${id}`);
+  }
+};
+
+// src/namespaces/checkout.ts
+var CheckoutNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(data) {
+    return this.client.post(
+      "/api/checkout/create",
+      data
     );
-    console.log("SHIPPING RATES DATA: ", data);
-    if ("isError" in data && data.isError || !data) {
-      console.error("Failed to get shipping rates: ", data);
-      return {};
-    }
-    return data;
   }
-  /**
-   * Generate payment secret for a checkout session
-   */
-  async generateCheckoutPaymentSecret(clientSecret, checkoutId) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.post(`/checkout/${checkoutId}/payment`);
-    if ("isError" in data && data.isError || !data || !("paymentSecret" in data)) {
-      throw new Error("Failed to generate payment secret");
-    }
-    return {
-      paymentSecret: data.paymentSecret,
-      publicKey: data.publicKey,
-      checkoutSession: data.checkoutSession
-    };
+  async get(id) {
+    return this.client.get(`/api/checkout/get/${id}`);
   }
-  /**
-   * Create a new customer
-   */
-  async createCustomer(clientSecret, params) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.post(
-      "/customer",
-      params
+  async update(id, data) {
+    return this.client.post(
+      `/api/checkout/update/${id}`,
+      data
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      throw new Error("Failed to create customer");
-    }
-    return data;
   }
-  /**
-   * Retrieve a customer by ID or email
-   */
-  async retrieveCustomer(clientSecret, idOrEmail) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.get(
-      `/customer/${idOrEmail}`
+  async getShippingRates(id) {
+    return this.client.get(
+      `/api/checkout/${id}/get-shipping-rates`
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Customer with id or email ${idOrEmail} not found`);
-      return null;
-    }
-    return data;
   }
-  /**
-   * Update a customer
-   */
-  async updateCustomer(clientSecret, customerId, params) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.put(
-      `/customer/${customerId}`,
-      params
+  async generatePaymentSecret(id) {
+    return this.client.post(
+      `/api/checkout/payment-secret/${id}`
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Customer with id ${customerId} not found`);
-      return null;
-    }
-    return data;
   }
-  /**
-   * Get exchange rate for a currency
-   */
-  async getExchangeRate(clientSecret, baseCurrency, targetCurrency) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const data = await apiClient.get(
-      `/helpers/rates/${baseCurrency}`
+  async revalidateDiscounts(id) {
+    return this.client.get(
+      `/api/checkout/${id}/discounts/revalidate`
     );
-    const rate = data.rates[targetCurrency];
-    if (!rate) {
-      throw new Error("Could not get exchange rate for target currency");
-    }
-    return rate;
   }
-  /**
-   * Get autosuggest address results
-   */
-  async getAutosuggestAddressResults(clientSecret, params) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const { data } = await apiClient.get("/helpers/address/autosuggest", {
-      params
-    });
-    return data ?? [];
+  async applyDiscount(id, data) {
+    return this.client.post(
+      `/api/checkout/${id}/discounts/apply`,
+      data
+    );
   }
-  async lookupAddress(clientSecret, params) {
-    const apiClient = createApiClient(clientSecret, this.proxy);
-    const { data } = await apiClient.get("/helpers/address/lookup", {
-      params
-    });
-    return data;
+  async removeDiscount(id, discountId) {
+    return this.client.delete(
+      `/api/checkout/${id}/discounts/remove/${discountId}`
+    );
   }
 };
-var client_default = Client;
 
-// src/collections/index.ts
-var Collections = class {
-  apiClient;
-  constructor(apiKey, proxy) {
-    this.apiClient = createApiClient(apiKey, proxy);
+// src/namespaces/collections.ts
+var CollectionsNamespace = class {
+  constructor(client) {
+    this.client = client;
   }
   async list(params) {
-    const data = await this.apiClient.post(`/collections`, params ?? {});
-    if (!data || "isError" in data && data.isError || !("collections" in data)) {
-      return [];
-    }
-    return data.collections;
+    return this.client.post(
+      "/api/collections/find-many",
+      params
+    );
   }
-  async retrieve(params) {
-    const data = await this.apiClient.post(`/collections/retrieve`, params);
-    if ("isError" in data && data.isError || !data || !("collection" in data)) {
-      console.error(`Collection not found`);
-      return null;
-    }
-    return data.collection;
+  async findFirst(params) {
+    return this.client.post(
+      "/api/collections/find-first",
+      params
+    );
   }
 };
-var collections_default = Collections;
 
-// src/customer/index.ts
-var Customer = class {
-  apiClient;
-  constructor(apiKey, proxy) {
-    this.apiClient = createApiClient(apiKey, proxy);
-  }
-  /**
-   * Create a new customer
-   */
-  async create(params) {
-    const data = await this.apiClient.post(
-      "/customer",
-      params
+// src/namespaces/customers.ts
+var CustomersNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async upsert(data) {
+    return this.client.post(
+      "/api/customers/upsert",
+      data
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      throw new Error("Failed to create customer");
-    }
-    return data;
   }
-  /**
-   * Retrieve a customer by ID or email
-   */
-  async retrieve(idOrEmail) {
-    const data = await this.apiClient.get(
-      `/customer/${idOrEmail}`
+  async findFirst(idOrEmail) {
+    return this.client.get(
+      `/api/customers/find-first/${idOrEmail}`
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Customer with id or email ${idOrEmail} not found`);
-      return null;
-    }
-    return data;
   }
-  /**
-   * Update a customer
-   */
-  async update(customerId, params) {
-    const data = await this.apiClient.put(
-      `/customer/${customerId}`,
-      params
+  async update(id, data) {
+    return this.client.post(
+      `/api/customers/update/${id}`,
+      data
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      console.error(`Customer with id ${customerId} not found`);
-      return null;
-    }
-    return data;
-  }
-  /**
-   * Delete a customer
-   */
-  async delete(customerId) {
-    await this.apiClient.delete(`/customer/${customerId}`);
   }
-  /**
-   * Update a customer subscription
-   */
-  async updateCustomerSubscription(stripeSubscriptionId, params) {
-    const data = await this.apiClient.put(
-      `/customer/subscription/${stripeSubscriptionId}`,
-      params
+  async delete(id) {
+    return this.client.delete(
+      `/api/customers/delete/${id}`
     );
-    if ("isError" in data && data.isError || !data || !("id" in data)) {
-      return null;
-    }
-    return data;
   }
 };
-var customer_default = Customer;
 
-// src/discounts/index.ts
-var Discounts = class {
-  apiClient;
-  constructor(apiKey, proxy) {
-    this.apiClient = createApiClient(apiKey, proxy);
+// src/namespaces/products.ts
+var ProductsNamespace = class {
+  constructor(client) {
+    this.client = client;
   }
+  /**
+   * List products with optional filtering, sorting, and pagination
+   */
   async list(params) {
-    const data = await this.apiClient.post(
-      "/discounts",
-      params ?? {}
+    return this.client.post(
+      "/api/products/find-many",
+      params
     );
-    if (!data || "isError" in data && data.isError || !("discounts" in data)) {
-      return [];
-    }
-    return data.discounts;
   }
-  async retrieve(params) {
-    const data = await this.apiClient.post(
-      `/discounts/retrieve`,
+  /**
+   * Find the first product matching the criteria
+   */
+  async findFirst(params) {
+    return this.client.post(
+      "/api/products/find-first",
       params
     );
-    if ("isError" in data && data.isError || !data || !("discount" in data)) {
-      console.error(`Discount not found`);
-      return null;
-    }
-    return data.discount;
   }
 };
-var discounts_default = Discounts;
 
-// src/products/index.ts
-var Products = class {
-  apiClient;
-  constructor(apiKey, proxy) {
-    this.apiClient = createApiClient(apiKey, proxy);
-  }
-  async list(params) {
-    const data = await this.apiClient.post(
-      "/products",
-      params ?? {}
-    );
-    if (!data || "isError" in data && data.isError || !("products" in data)) {
-      return [];
-    }
-    return data.products;
+// src/namespaces/utils.ts
+var UtilsNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getExchangeRates(currency) {
+    return this.client.get(`/api/utils/get-exchange-rates/${currency}`);
+  }
+  async autosuggestAddress(params) {
+    const { query, locale, latitude, longitude, countryCode } = params;
+    return this.client.get(`/api/utils/autosuggest-address`, {
+      query,
+      locale,
+      latitude,
+      longitude,
+      countryCode
+    });
   }
-  async retrieve(params) {
-    const data = await this.apiClient.post("/products/retrieve", params);
-    if ("isError" in data && data.isError || !data || !("product" in data)) {
-      console.error(`Product not found`);
-      return null;
-    }
-    return data.product;
+  async lookupAddressById(id, params = {}) {
+    return this.client.get(`/api/utils/lookup-address-by-id/${id}`, params);
   }
 };
-var products_default = Products;
 
-// src/types-and-methods.ts
-import { formatCurrency, formatPrice } from "@betterstore/bridge";
-
-// src/methods/cart-discounts.ts
-function getHighestDiscount(productId, priceInCents, discounts) {
-  const applicableDiscounts = discounts.filter(
-    (discount) => discount.allowedProductIDs.includes(productId)
-  );
-  const bestDiscount = applicableDiscounts.length > 1 ? applicableDiscounts.reduce((bestSoFar, currentDiscount) => {
-    let currentDiscountValueInCents = currentDiscount.value;
-    if (currentDiscount.valueType === "PERCENTAGE") {
-      currentDiscountValueInCents = currentDiscount.value / 100 * priceInCents;
-    } else if (currentDiscount.valueType === "FREE") {
-      currentDiscountValueInCents = priceInCents;
+// src/main-factory.ts
+function createBetterStore(secret, config) {
+  const baseClient = new BaseClient({
+    baseUrl: config?.proxy || "https://v1.betterstore.io",
+    headers: {
+      Authorization: `Bearer ${secret}`,
+      "Content-Type": "application/json"
     }
-    return (bestSoFar?.value ?? 0) > currentDiscountValueInCents ? bestSoFar : currentDiscount;
-  }, applicableDiscounts[0]) : applicableDiscounts[0];
-  return bestDiscount;
-}
-function calculateDiscountAmount(originalPrice, discount) {
-  let discountValueInCents = discount?.value;
-  const isFreeDiscount = discount?.valueType === "FREE";
-  if (discount?.valueType === "PERCENTAGE") {
-    discountValueInCents = discount.value / 100 * originalPrice;
-  } else if (discount?.valueType === "FREE") {
-    discountValueInCents = originalPrice;
-  }
-  const finalPrice = discountValueInCents ? Math.max(originalPrice - discountValueInCents, 0) : originalPrice;
-  const isDiscounted = discountValueInCents === 0;
-  return {
-    finalPrice,
-    discountAmount: discountValueInCents ?? 0,
-    originalPrice,
-    isFree: isFreeDiscount,
-    isDiscounted
-  };
-}
-function findAutomaticProductDiscount({
-  productId,
-  priceInCents,
-  discounts
-}) {
-  const discount = getHighestDiscount(productId, priceInCents, discounts);
-  const result = calculateDiscountAmount(priceInCents, discount);
-  return { ...result, discount };
-}
-
-// src/index.ts
-function createBetterStore(config) {
-  if (!config.apiKey) {
-    throw new Error("API key is required.");
-  }
+  });
   return {
-    checkout: new checkout_default(config.apiKey, config.proxy),
-    customer: new customer_default(config.apiKey, config.proxy),
-    discounts: new discounts_default(config.apiKey, config.proxy),
-    collections: new collections_default(config.apiKey, config.proxy),
-    products: new products_default(config.apiKey, config.proxy),
-    auth: new auth_default(config.apiKey, config.proxy)
+    products: new ProductsNamespace(baseClient),
+    collections: new CollectionsNamespace(baseClient),
+    customers: new CustomersNamespace(baseClient),
+    auth: new AuthNamespace(baseClient),
+    checkout: new CheckoutNamespace(baseClient),
+    utils: new UtilsNamespace(baseClient)
   };
 }
-function createStoreClient(config) {
-  return new client_default(config?.proxy);
-}
 export {
-  createStoreClient,
-  createBetterStore as default,
-  findAutomaticProductDiscount,
-  formatCurrency,
-  formatPrice
+  createBetterStore,
+  createBetterStoreClient
 };