@cimplify/sdk 0.16.3 → 0.17.0

package/dist/index.js

@@ -1,4425 +1,406 @@
 'use strict';
 
-var libphonenumberJs = require('libphonenumber-js');
+var chunkOITG2SEN_js = require('./chunk-OITG2SEN.js');
+var chunkS6TU55KP_js = require('./chunk-S6TU55KP.js');
+var chunkFLPI2VVJ_js = require('./chunk-FLPI2VVJ.js');
+var chunkREPTMTQ4_js = require('./chunk-REPTMTQ4.js');
+var chunkJ65U5SED_js = require('./chunk-J65U5SED.js');
 
-// src/types/common.ts
-function money(value) {
-  return typeof value === "string" ? parseFloat(value) || 0 : value;
-}
-function moneyFromNumber(value) {
-  return value;
-}
-var ZERO = 0;
-var SUPPORTED_CURRENCY_CODES = /* @__PURE__ */ new Set([
-  "USD",
-  "EUR",
-  "GBP",
-  "JPY",
-  "CNY",
-  "CHF",
-  "CAD",
-  "AUD",
-  "GHS",
-  "NGN",
-  "KES",
-  "ZAR",
-  "XOF",
-  "XAF",
-  "EGP",
-  "TZS",
-  "UGX",
-  "RWF",
-  "ETB",
-  "ZMW",
-  "BWP",
-  "MUR",
-  "NAD",
-  "MWK",
-  "AOA",
-  "CDF",
-  "GMD",
-  "GNF",
-  "LRD",
-  "SLL",
-  "MZN",
-  "BIF",
-  "INR",
-  "BRL",
-  "MXN",
-  "KRW",
-  "TRY",
-  "THB",
-  "MYR",
-  "PHP",
-  "IDR",
-  "VND",
-  "SGD",
-  "HKD",
-  "TWD",
-  "AED",
-  "SAR",
-  "ILS"
-]);
-function isSupportedCurrency(code) {
-  return SUPPORTED_CURRENCY_CODES.has(code);
-}
-function currencyCode(value) {
-  return value;
-}
-var ErrorCode = {
-  UNKNOWN_ERROR: "UNKNOWN_ERROR",
-  NETWORK_ERROR: "NETWORK_ERROR",
-  TIMEOUT: "TIMEOUT",
-  UNAUTHORIZED: "UNAUTHORIZED",
-  FORBIDDEN: "FORBIDDEN",
-  NOT_FOUND: "NOT_FOUND",
-  VALIDATION_ERROR: "VALIDATION_ERROR",
-  CART_EMPTY: "CART_EMPTY",
-  CART_EXPIRED: "CART_EXPIRED",
-  CART_NOT_FOUND: "CART_NOT_FOUND",
-  ITEM_UNAVAILABLE: "ITEM_UNAVAILABLE",
-  VARIANT_NOT_FOUND: "VARIANT_NOT_FOUND",
-  VARIANT_OUT_OF_STOCK: "VARIANT_OUT_OF_STOCK",
-  ADDON_REQUIRED: "ADDON_REQUIRED",
-  ADDON_MAX_EXCEEDED: "ADDON_MAX_EXCEEDED",
-  CHECKOUT_VALIDATION_FAILED: "CHECKOUT_VALIDATION_FAILED",
-  DELIVERY_ADDRESS_REQUIRED: "DELIVERY_ADDRESS_REQUIRED",
-  CUSTOMER_INFO_REQUIRED: "CUSTOMER_INFO_REQUIRED",
-  QUOTE_NOT_FOUND: "QUOTE_NOT_FOUND",
-  QUOTE_EXPIRED: "QUOTE_EXPIRED",
-  QUOTE_CONSUMED: "QUOTE_CONSUMED",
-  QUOTE_STORAGE_UNAVAILABLE: "QUOTE_STORAGE_UNAVAILABLE",
-  PAYMENT_FAILED: "PAYMENT_FAILED",
-  PAYMENT_CANCELLED: "PAYMENT_CANCELLED",
-  INSUFFICIENT_FUNDS: "INSUFFICIENT_FUNDS",
-  CARD_DECLINED: "CARD_DECLINED",
-  INVALID_OTP: "INVALID_OTP",
-  OTP_EXPIRED: "OTP_EXPIRED",
-  AUTHORIZATION_FAILED: "AUTHORIZATION_FAILED",
-  PAYMENT_ACTION_NOT_COMPLETED: "PAYMENT_ACTION_NOT_COMPLETED",
-  SLOT_UNAVAILABLE: "SLOT_UNAVAILABLE",
-  BOOKING_CONFLICT: "BOOKING_CONFLICT",
-  SERVICE_NOT_FOUND: "SERVICE_NOT_FOUND",
-  OUT_OF_STOCK: "OUT_OF_STOCK",
-  INSUFFICIENT_QUANTITY: "INSUFFICIENT_QUANTITY"
-};
-var DOCS_ERROR_BASE_URL = "https://docs.cimplify.io/reference/error-codes";
-function docsUrlForCode(code) {
-  return `${DOCS_ERROR_BASE_URL}#${code.toLowerCase().replace(/_/g, "-")}`;
-}
-var ERROR_SUGGESTIONS = {
-  UNKNOWN_ERROR: "An unexpected error occurred. Capture the request/response payload and retry with exponential backoff.",
-  NETWORK_ERROR: "Check the shopper's connection and retry. If this persists, inspect CORS, DNS, and API reachability.",
-  TIMEOUT: "The request exceeded the timeout. Retry once, then poll order status before charging again.",
-  UNAUTHORIZED: "Authentication is missing or expired. Ensure a valid access token is set and refresh the session if needed.",
-  FORBIDDEN: "The key/session lacks permission for this resource. Verify business ownership and API key scope.",
-  NOT_FOUND: "The requested resource does not exist or is not visible in this environment.",
-  VALIDATION_ERROR: "One or more fields are invalid. Validate required fields and enum values before retrying.",
-  CART_EMPTY: "The cart has no items. Redirect back to menu/catalogue and require at least one line item.",
-  CART_EXPIRED: "This cart is no longer active. Recreate a new cart and re-add shopper selections.",
-  CART_NOT_FOUND: "Cart could not be located. It may have expired or belongs to a different key/location.",
-  ITEM_UNAVAILABLE: "The selected item is unavailable at this location/time. Prompt the shopper to pick an alternative.",
-  VARIANT_NOT_FOUND: "The requested variant no longer exists. Refresh product data and require re-selection.",
-  VARIANT_OUT_OF_STOCK: "The selected variant is out of stock. Show in-stock variants and block checkout for this line.",
-  ADDON_REQUIRED: "A required add-on is missing. Ensure required modifier groups are completed before add-to-cart.",
-  ADDON_MAX_EXCEEDED: "Too many add-ons were selected. Enforce max selections client-side before submission.",
-  CHECKOUT_VALIDATION_FAILED: "Checkout payload failed validation. Verify customer, order type, and address fields are complete.",
-  DELIVERY_ADDRESS_REQUIRED: "Delivery orders require an address. Collect and pass address info before processing checkout.",
-  CUSTOMER_INFO_REQUIRED: "Customer details are required. Ensure name/email/phone are available before checkout.",
-  QUOTE_NOT_FOUND: "Quote could not be found. Refresh pricing and create a new quote before checkout.",
-  QUOTE_EXPIRED: "Quote has expired. Re-fetch pricing to generate a new quote with a valid expiry window.",
-  QUOTE_CONSUMED: "Quote has already been used. Request a fresh quote to prevent duplicate checkout attempts.",
-  QUOTE_STORAGE_UNAVAILABLE: "Quote storage is temporarily unavailable. Retry shortly and avoid charging until quote fetch succeeds.",
-  PAYMENT_FAILED: "Payment provider rejected or failed processing. Show retry/change-method options to the shopper.",
-  PAYMENT_CANCELLED: "Payment was cancelled by the shopper or provider flow. Allow a safe retry path.",
-  INSUFFICIENT_FUNDS: "Payment method has insufficient funds. Prompt shopper to use another method.",
-  CARD_DECLINED: "Card was declined. Ask shopper to retry or switch payment method.",
-  INVALID_OTP: "Authorization code is invalid. Let shopper re-enter OTP/PIN and retry.",
-  OTP_EXPIRED: "Authorization code expired. Request a new OTP and re-submit authorization.",
-  AUTHORIZATION_FAILED: "Additional payment authorization failed. Retry authorization or change payment method.",
-  PAYMENT_ACTION_NOT_COMPLETED: "Required payment action was not completed. Resume provider flow and poll for status.",
-  SLOT_UNAVAILABLE: "Selected schedule slot is unavailable. Refresh available slots and ask shopper to reselect.",
-  BOOKING_CONFLICT: "The requested booking conflicts with an existing reservation. Pick another slot/resource.",
-  SERVICE_NOT_FOUND: "Requested service no longer exists. Refresh service catalogue and retry selection.",
-  OUT_OF_STOCK: "Inventory is depleted for this item. Remove it or reduce quantity before checkout.",
-  INSUFFICIENT_QUANTITY: "Requested quantity exceeds available inventory. Reduce quantity and retry.",
-  BUSINESS_ID_REQUIRED: "Business context could not be resolved. Verify the public key and business bootstrap call.",
-  INVALID_CART: "Cart is invalid for checkout. Sync cart state, ensure items exist, then retry.",
-  ORDER_TYPE_REQUIRED: "Order type is required. Provide one of delivery, pickup, or dine_in before checkout.",
-  NO_PAYMENT_ELEMENT: "PaymentElement is required for processCheckout(). Mount it before triggering checkout.",
-  PAYMENT_NOT_MOUNTED: "PaymentElement iframe is not mounted. Mount it in the DOM before processCheckout().",
-  AUTH_INCOMPLETE: "AuthElement has not completed authentication. Wait for AUTHENTICATED before checkout.",
-  AUTH_LOST: "Session was cleared during checkout. Re-authenticate and restart checkout safely.",
-  ALREADY_PROCESSING: "Checkout is already in progress. Disable duplicate submits until completion.",
-  CHECKOUT_NOT_READY: "Checkout elements are still initializing. Wait for readiness before submit.",
-  CANCELLED: "Checkout was cancelled. Preserve cart state and allow shopper to retry.",
-  REQUEST_TIMEOUT: "Provider call timed out. Poll payment/order status before issuing another charge attempt.",
-  POPUP_BLOCKED: "Browser blocked provider popup. Ask shopper to enable popups and retry.",
-  FX_QUOTE_FAILED: "Failed to lock FX quote. Retry currency quote or fallback to base currency."
-};
-var ERROR_HINTS = Object.fromEntries(
-  Object.entries(ERROR_SUGGESTIONS).map(([code, suggestion]) => [
-    code,
-    {
-      docs_url: docsUrlForCode(code),
-      suggestion
-    }
-  ])
-);
-var CimplifyError = class extends Error {
-  constructor(code, message, retryable = false, docs_url, suggestion) {
-    super(message);
-    this.code = code;
-    this.retryable = retryable;
-    this.docs_url = docs_url;
-    this.suggestion = suggestion;
-    this.name = "CimplifyError";
-  }
-  get userMessage() {
-    return this.message;
-  }
-};
-function isCimplifyError(error) {
-  return error instanceof CimplifyError;
-}
-function getErrorHint(code) {
-  return ERROR_HINTS[code];
-}
-function enrichError(error, options = {}) {
-  const hint = getErrorHint(error.code);
-  if (hint) {
-    if (!error.docs_url) {
-      error.docs_url = hint.docs_url;
-    }
-    if (!error.suggestion) {
-      error.suggestion = hint.suggestion;
-    }
-  } else if (!error.docs_url) {
-    error.docs_url = docsUrlForCode(error.code || ErrorCode.UNKNOWN_ERROR);
-  }
-  if (options.isTestMode && !error.message.includes("pk_test_")) {
-    error.message = `${error.message}
 
-\u2139 Your API key is a test-mode key (pk_test_...). Verify test data/session before retrying.`;
-  }
-  return error;
-}
-function isRetryableError(error) {
-  if (isCimplifyError(error)) {
-    return error.retryable;
-  }
-  if (error instanceof Error) {
-    const msg = error.message.toLowerCase();
-    return msg.includes("network") || msg.includes("timeout") || msg.includes("fetch");
-  }
-  return false;
-}
 
-// src/types/result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-function isOk(result) {
-  return result.ok === true;
-}
-function isErr(result) {
-  return result.ok === false;
-}
-function mapResult(result, fn) {
-  return result.ok ? ok(fn(result.value)) : result;
-}
-function mapError(result, fn) {
-  return result.ok ? result : err(fn(result.error));
-}
-function flatMap(result, fn) {
-  return result.ok ? fn(result.value) : result;
-}
-function getOrElse(result, defaultFn) {
-  return result.ok ? result.value : defaultFn();
-}
-function unwrap(result) {
-  if (result.ok) {
-    return result.value;
-  }
-  throw result.error;
-}
-function toNullable(result) {
-  return result.ok ? result.value : void 0;
-}
-async function fromPromise(promise, mapError2) {
-  try {
-    const value = await promise;
-    return ok(value);
-  } catch (error) {
-    return err(mapError2(error));
-  }
-}
-function tryCatch(fn, mapError2) {
-  try {
-    return ok(fn());
-  } catch (error) {
-    return err(mapError2(error));
-  }
-}
-function combine(results) {
-  const values = [];
-  for (const result of results) {
-    if (!result.ok) {
-      return result;
-    }
-    values.push(result.value);
-  }
-  return ok(values);
-}
-function combineObject(results) {
-  const values = {};
-  for (const [key, result] of Object.entries(results)) {
-    if (!result.ok) {
-      return result;
-    }
-    values[key] = result.value;
-  }
-  return ok(values);
-}
-
-// src/internal/safe.ts
-function toCimplifyError(error) {
-  if (error instanceof CimplifyError) return enrichError(error);
-  if (error instanceof Error) {
-    return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, error.message, false));
-  }
-  return enrichError(new CimplifyError(ErrorCode.UNKNOWN_ERROR, String(error), false));
-}
-async function safe(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError(error));
-  }
-}
-
-// src/catalogue.ts
-function withQuery(path, params) {
-  const query2 = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value === void 0) continue;
-    query2.set(key, String(value));
-  }
-  const queryString = query2.toString();
-  return queryString ? `${path}?${queryString}` : path;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function readFinalPrice(value) {
-  if (!isRecord(value)) return void 0;
-  const finalPrice = value.final_price;
-  if (typeof finalPrice === "string" || typeof finalPrice === "number") {
-    return finalPrice;
-  }
-  return void 0;
-}
-function normalizeAddOnPayload(addOn) {
-  if (!isRecord(addOn)) return addOn;
-  const normalizedAddOn = { ...addOn };
-  const options = normalizedAddOn["options"];
-  if (!Array.isArray(options)) return normalizedAddOn;
-  normalizedAddOn["options"] = options.map((option) => {
-    if (!isRecord(option)) return option;
-    const normalizedOption = { ...option };
-    const optionPrice = normalizedOption["default_price"];
-    if (optionPrice === void 0 || optionPrice === null || optionPrice === "") {
-      normalizedOption["default_price"] = readFinalPrice(normalizedOption["default_price_info"]) || readFinalPrice(normalizedOption["price_info"]) || "0";
-    }
-    return normalizedOption;
-  });
-  return normalizedAddOn;
-}
-function normalizeCatalogueProductPayload(product) {
-  const normalized = { ...product };
-  const defaultPrice = normalized["default_price"];
-  if (defaultPrice === void 0 || defaultPrice === null || defaultPrice === "") {
-    const derivedDefaultPrice = readFinalPrice(normalized["default_price_info"]) || readFinalPrice(normalized["price_info"]) || (typeof normalized["final_price"] === "string" || typeof normalized["final_price"] === "number" ? normalized["final_price"] : void 0);
-    normalized["default_price"] = derivedDefaultPrice ?? "0";
-  }
-  const addOns = normalized["add_ons"];
-  if (Array.isArray(addOns)) {
-    normalized["add_ons"] = addOns.map((addOn) => normalizeAddOnPayload(addOn));
-  }
-  return normalized;
-}
-function toFiniteNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  return void 0;
-}
-function normalizePagination(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const totalCount = toFiniteNumber(value.total_count);
-  const currentPage = toFiniteNumber(value.current_page);
-  const pageSize = toFiniteNumber(value.page_size);
-  const totalPages = toFiniteNumber(value.total_pages);
-  if (totalCount === void 0 || currentPage === void 0 || pageSize === void 0 || totalPages === void 0) {
-    return void 0;
-  }
-  return {
-    total_count: totalCount,
-    current_page: currentPage,
-    page_size: pageSize,
-    total_pages: totalPages,
-    has_more: value.has_more === true,
-    next_cursor: typeof value.next_cursor === "string" ? value.next_cursor : void 0
-  };
-}
-function normalizeCatalogueResult(payload) {
-  if (Array.isArray(payload)) {
-    return {
-      items: payload.map((product) => normalizeCatalogueProductPayload(product)),
-      is_complete: true
-    };
-  }
-  if (!isRecord(payload)) {
-    return {
-      items: [],
-      is_complete: true
-    };
-  }
-  const rawItems = Array.isArray(payload.products) ? payload.products : Array.isArray(payload.items) ? payload.items : [];
-  return {
-    items: rawItems.map((product) => normalizeCatalogueProductPayload(product)),
-    is_complete: typeof payload.is_complete === "boolean" ? payload.is_complete : true,
-    total_available: toFiniteNumber(payload.total_available),
-    pagination: normalizePagination(payload.pagination)
-  };
-}
-function normalizeCatalogueSnapshot(payload) {
-  if (Array.isArray(payload)) {
-    return {
-      categories: [],
-      products: payload.map((product) => normalizeCatalogueProductPayload(product)),
-      add_ons: [],
-      is_complete: true
-    };
-  }
-  if (!isRecord(payload)) {
-    return {
-      categories: [],
-      products: [],
-      add_ons: [],
-      is_complete: true
-    };
-  }
-  const rawProducts = Array.isArray(payload.products) ? payload.products : Array.isArray(payload.items) ? payload.items : [];
-  const rawCategories = Array.isArray(payload.categories) ? payload.categories : [];
-  const rawAddOns = Array.isArray(payload.add_ons) ? payload.add_ons : [];
-  return {
-    categories: rawCategories,
-    products: rawProducts.map((product) => normalizeCatalogueProductPayload(product)),
-    add_ons: rawAddOns.map((addOn) => normalizeAddOnPayload(addOn)),
-    is_complete: typeof payload.is_complete === "boolean" ? payload.is_complete : true,
-    total_available: toFiniteNumber(payload.total_available),
-    pagination: normalizePagination(payload.pagination)
-  };
-}
-var CatalogueQueries = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getCatalogue() {
-    const result = await safe(this.client.get("/api/v1/catalogue"));
-    if (!result.ok) return result;
-    return ok(normalizeCatalogueSnapshot(result.value));
-  }
-  async getProducts(options) {
-    const path = withQuery("/api/v1/catalogue/products", {
-      category_id: options?.category,
-      taxonomy_id: options?.taxonomy,
-      search: options?.search,
-      page: options?.page,
-      tags: options?.tags?.join(","),
-      featured: options?.featured,
-      in_stock: options?.in_stock,
-      min_price: options?.min_price,
-      max_price: options?.max_price,
-      sort_by: options?.sort_by,
-      sort_order: options?.sort_order,
-      limit: options?.limit,
-      offset: options?.offset,
-      cursor: options?.cursor
-    });
-    const result = await safe(this.client.get(path));
-    if (!result.ok) return result;
-    return ok(normalizeCatalogueResult(result.value));
-  }
-  async getProduct(id) {
-    const encodedId = encodeURIComponent(id);
-    const result = await safe(this.client.get(`/api/v1/catalogue/products/${encodedId}`));
-    if (!result.ok) return result;
-    return ok(normalizeCatalogueProductPayload(result.value));
-  }
-  async getProductBySlug(slug) {
-    const encodedSlug = encodeURIComponent(slug);
-    const result = await safe(this.client.get(`/api/v1/catalogue/products/slug/${encodedSlug}`));
-    if (!result.ok) return result;
-    return ok(normalizeCatalogueProductPayload(result.value));
-  }
-  async getVariants(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/variants`));
-  }
-  async getVariantAxes(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/variant-axes`));
-  }
-  async getVariantByAxisSelections(productId, selections) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(
-      this.client.post(
-        `/api/v1/catalogue/products/${encodedId}/variants/find`,
-        { axis_selections: selections }
-      )
-    );
-  }
-  async getVariantById(productId, variantId) {
-    const encodedProductId = encodeURIComponent(productId);
-    const encodedVariantId = encodeURIComponent(variantId);
-    return safe(
-      this.client.get(
-        `/api/v1/catalogue/products/${encodedProductId}/variants/${encodedVariantId}`
-      )
-    );
-  }
-  async getAddOns(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/add-ons`));
-  }
-  async getCategories() {
-    return safe(this.client.get("/api/v1/catalogue/categories"));
-  }
-  async getCategory(id) {
-    const encodedId = encodeURIComponent(id);
-    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}`));
-  }
-  async getCategoryBySlug(slug) {
-    const encodedSlug = encodeURIComponent(slug);
-    return safe(this.client.get(`/api/v1/catalogue/categories/slug/${encodedSlug}`));
-  }
-  async getCategoryProducts(categoryId) {
-    const encodedId = encodeURIComponent(categoryId);
-    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}/products`));
-  }
-  async getCollections() {
-    return safe(this.client.get("/api/v1/catalogue/collections"));
-  }
-  async getCollection(id) {
-    const encodedId = encodeURIComponent(id);
-    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}`));
-  }
-  async getCollectionBySlug(slug) {
-    const encodedSlug = encodeURIComponent(slug);
-    return safe(this.client.get(`/api/v1/catalogue/collections/slug/${encodedSlug}`));
-  }
-  async getCollectionProducts(collectionId) {
-    const encodedId = encodeURIComponent(collectionId);
-    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}/products`));
-  }
-  async searchCollections(query2, limit = 20) {
-    const path = withQuery("/api/v1/catalogue/collections", { search: query2, limit });
-    return safe(this.client.get(path));
-  }
-  async getBundles() {
-    return safe(this.client.get("/api/v1/catalogue/bundles"));
-  }
-  async searchBundles(query2, limit = 20) {
-    const path = withQuery("/api/v1/catalogue/bundles", { search: query2, limit });
-    return safe(this.client.get(path));
-  }
-  async getComposites(options) {
-    const path = withQuery("/api/v1/catalogue/composites", { limit: options?.limit });
-    return safe(this.client.get(path));
-  }
-  async calculateCompositePrice(compositeId, selections, locationId) {
-    const encodedId = encodeURIComponent(compositeId);
-    return safe(
-      this.client.post(
-        `/api/v1/catalogue/composites/${encodedId}/calculate-price`,
-        {
-          selections,
-          location_id: locationId
-        }
-      )
-    );
-  }
-  async fetchQuote(input) {
-    return safe(this.client.post("/api/v1/catalogue/quotes", input));
-  }
-  async getQuote(quoteId) {
-    const encodedQuoteId = encodeURIComponent(quoteId);
-    return safe(this.client.get(`/api/v1/catalogue/quotes/${encodedQuoteId}`));
-  }
-  async refreshQuote(input) {
-    const encodedQuoteId = encodeURIComponent(input.quote_id);
-    return safe(
-      this.client.post(
-        `/api/v1/catalogue/quotes/${encodedQuoteId}/refresh`,
-        input
-      )
-    );
-  }
-  async getTaxonomies(parentId) {
-    const path = withQuery("/api/v1/catalogue/taxonomies", { parent_id: parentId });
-    return safe(this.client.get(path));
-  }
-  async getTaxonomy(id) {
-    const encodedId = encodeURIComponent(id);
-    return safe(this.client.get(`/api/v1/catalogue/taxonomies/${encodedId}`));
-  }
-  async getTaxonomyPath(id) {
-    const encodedId = encodeURIComponent(id);
-    return safe(this.client.get(`/api/v1/catalogue/taxonomies/${encodedId}/path`));
-  }
-  async searchTaxonomies(query2, limit) {
-    const path = withQuery("/api/v1/catalogue/taxonomies/search", { q: query2, limit });
-    return safe(this.client.get(path));
-  }
-  async getProductSchedules(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/schedules`));
-  }
-  async checkProductAvailableNow(productId, locationId) {
-    const encodedId = encodeURIComponent(productId);
-    const path = withQuery(`/api/v1/catalogue/products/${encodedId}/available-now`, { location_id: locationId });
-    return safe(this.client.get(path));
-  }
-  async getDeals(locationId) {
-    const path = withQuery("/api/v1/catalogue/deals", { location_id: locationId });
-    return safe(this.client.get(path));
-  }
-  async getProductsOnSale() {
-    return safe(this.client.get("/api/v1/catalogue/deals/on-sale"));
-  }
-  async getProductDeals(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/deals`));
-  }
-  async getCategoryDeals(categoryId) {
-    const encodedId = encodeURIComponent(categoryId);
-    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}/deals`));
-  }
-  async getCollectionDeals(collectionId) {
-    const encodedId = encodeURIComponent(collectionId);
-    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}/deals`));
-  }
-  async validateDiscountCode(code, orderSubtotal, locationId) {
-    return safe(
-      this.client.post("/api/v1/catalogue/deals/validate", {
-        discount_code: code,
-        order_subtotal: orderSubtotal,
-        location_id: locationId
-      })
-    );
-  }
-  async search(query2, options) {
-    const result = await this.getProducts({
-      search: query2,
-      category: options?.category,
-      limit: options?.limit ?? 20
-    });
-    if (!result.ok) return result;
-    return ok(result.value.items);
-  }
-  async searchProducts(query2, options) {
-    return this.search(query2, options);
-  }
-  async getMenu(options) {
-    const path = withQuery("/api/v1/catalogue/menu", {
-      category_id: options?.category,
-      limit: options?.limit
-    });
-    return safe(this.client.get(path));
-  }
-  async getMenuCategory(categoryId) {
-    const encodedId = encodeURIComponent(categoryId);
-    return safe(this.client.get(`/api/v1/catalogue/menu/categories/${encodedId}`));
-  }
-  async getMenuItem(itemId) {
-    const encodedId = encodeURIComponent(itemId);
-    return safe(this.client.get(`/api/v1/catalogue/menu/items/${encodedId}`));
-  }
-  async getTags(options) {
-    const path = withQuery("/api/v1/catalogue/tags", {
-      tag_group: options?.tag_group,
-      search: options?.search,
-      min_usage: options?.min_usage,
-      limit: options?.limit,
-      offset: options?.offset
-    });
-    return safe(this.client.get(path));
-  }
-};
-
-// src/cart.ts
-function isUICartResponse(value) {
-  return "cart" in value;
-}
-function unwrapEnrichedCart(value) {
-  return isUICartResponse(value) ? value.cart : value;
-}
-var CartOperations = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async get() {
-    const result = await safe(this.client.get("/api/v1/cart"));
-    if (!result.ok) return result;
-    return ok(unwrapEnrichedCart(result.value));
-  }
-  async getRaw() {
-    return safe(this.client.get("/api/v1/cart"));
-  }
-  async getItems() {
-    return safe(this.client.get("/api/v1/cart/items"));
-  }
-  async getCount() {
-    return safe(this.client.get("/api/v1/cart/count"));
-  }
-  async getTotal() {
-    return safe(this.client.get("/api/v1/cart/total"));
-  }
-  async getSummary() {
-    const cartResult = await this.get();
-    if (!cartResult.ok) return cartResult;
-    const cart = cartResult.value;
-    return ok({
-      item_count: cart.items.length,
-      total_items: cart.items.reduce((sum, item) => sum + item.quantity, 0),
-      subtotal: cart.pricing.subtotal,
-      discount_amount: cart.pricing.total_discounts,
-      tax_amount: cart.pricing.tax_amount,
-      total: cart.pricing.total_price,
-      currency: cart.pricing.currency
-    });
-  }
-  async addItem(input) {
-    return safe(this.client.post("/api/v1/cart/items", input));
-  }
-  async updateItem(cartItemId, updates) {
-    if (typeof updates.quantity === "number") {
-      return this.updateQuantity(cartItemId, updates.quantity);
-    }
-    const encodedId = encodeURIComponent(cartItemId);
-    return safe(this.client.patch(`/api/v1/cart/items/${encodedId}`, updates));
-  }
-  async updateQuantity(cartItemId, quantity) {
-    const encodedId = encodeURIComponent(cartItemId);
-    return safe(
-      this.client.patch(`/api/v1/cart/items/${encodedId}`, {
-        quantity
-      })
-    );
-  }
-  async removeItem(cartItemId) {
-    const encodedId = encodeURIComponent(cartItemId);
-    return safe(this.client.delete(`/api/v1/cart/items/${encodedId}`));
-  }
-  async clear() {
-    return safe(this.client.delete("/api/v1/cart"));
-  }
-  async applyCoupon(code) {
-    return safe(
-      this.client.post("/api/v1/cart/coupons", {
-        coupon_code: code
-      })
-    );
-  }
-  async removeCoupon() {
-    return safe(this.client.delete("/api/v1/cart/coupons/current"));
-  }
-  async isEmpty() {
-    const countResult = await this.getCount();
-    if (!countResult.ok) return countResult;
-    return ok(countResult.value === 0);
-  }
-  async hasItem(productId, variantId) {
-    const itemsResult = await this.getItems();
-    if (!itemsResult.ok) return itemsResult;
-    const found = itemsResult.value.some((item) => {
-      const matchesProduct = item.item_id === productId;
-      if (!variantId) return matchesProduct;
-      const config = item.configuration;
-      if ("variant" in config && config.variant) {
-        return matchesProduct && config.variant.variant_id === variantId;
-      }
-      return matchesProduct;
-    });
-    return ok(found);
-  }
-  async findItem(productId, variantId) {
-    const itemsResult = await this.getItems();
-    if (!itemsResult.ok) return itemsResult;
-    const found = itemsResult.value.find((item) => {
-      const matchesProduct = item.item_id === productId;
-      if (!variantId) return matchesProduct;
-      const config = item.configuration;
-      if ("variant" in config && config.variant) {
-        return matchesProduct && config.variant.variant_id === variantId;
-      }
-      return matchesProduct;
-    });
-    return ok(found);
-  }
-};
-
-// src/constants.ts
-var CHECKOUT_MODE = {
-  LINK: "link",
-  GUEST: "guest"
-};
-var ORDER_TYPE = {
-  DELIVERY: "delivery",
-  PICKUP: "pickup",
-  DINE_IN: "dine-in",
-  WALK_IN: "walk-in"
-};
-var PAYMENT_METHOD = {
-  MOBILE_MONEY: "mobile_money",
-  CARD: "card"
-};
-var CHECKOUT_STEP = {
-  AUTHENTICATION: "authentication",
-  ORDER_DETAILS: "order_details",
-  PAYMENT_METHOD: "payment_method",
-  PAYMENT: "payment",
-  CONFIRMATION: "confirmation"
-};
-var PAYMENT_STATE = {
-  INITIAL: "initial",
-  PREPARING: "preparing",
-  PROCESSING: "processing",
-  VERIFYING: "verifying",
-  AWAITING_AUTHORIZATION: "awaiting_authorization",
-  SUCCESS: "success",
-  ERROR: "error",
-  TIMEOUT: "timeout"
-};
-var PICKUP_TIME_TYPE = {
-  ASAP: "asap",
-  SCHEDULED: "scheduled"
-};
-var MOBILE_MONEY_PROVIDER = {
-  MTN: "mtn",
-  VODAFONE: "vodafone",
-  AIRTEL: "airtel"
-};
-var AUTHORIZATION_TYPE = {
-  OTP: "otp",
-  PIN: "pin",
-  PHONE: "phone",
-  BIRTHDAY: "birthday",
-  ADDRESS: "address"
-};
-var DEVICE_TYPE = {
-  MOBILE: "mobile",
-  DESKTOP: "desktop",
-  TABLET: "tablet"
-};
-var CONTACT_TYPE = {
-  PHONE: "phone",
-  EMAIL: "email"
-};
-var LINK_QUERY = {
-  DATA: "link.data",
-  ADDRESSES: "link.addresses",
-  MOBILE_MONEY: "link.mobile_money",
-  PREFERENCES: "link.preferences",
-  SESSIONS: "link.sessions"
-};
-var LINK_MUTATION = {
-  CHECK_STATUS: "link.check_status",
-  ENROLL: "link.enroll",
-  ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order",
-  UPDATE_PREFERENCES: "link.update_preferences",
-  CREATE_ADDRESS: "link.create_address",
-  UPDATE_ADDRESS: "link.update_address",
-  DELETE_ADDRESS: "link.delete_address",
-  SET_DEFAULT_ADDRESS: "link.set_default_address",
-  TRACK_ADDRESS_USAGE: "link.track_address_usage",
-  CREATE_MOBILE_MONEY: "link.create_mobile_money",
-  DELETE_MOBILE_MONEY: "link.delete_mobile_money",
-  SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money",
-  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
-  VERIFY_MOBILE_MONEY: "link.verify_mobile_money",
-  REVOKE_SESSION: "link.revoke_session",
-  REVOKE_ALL_SESSIONS: "link.revoke_all_sessions"
-};
-var AUTH_MUTATION = {
-  REQUEST_OTP: "auth.request_otp",
-  VERIFY_OTP: "auth.verify_otp"
-};
-var CHECKOUT_MUTATION = {
-  PROCESS: "checkout.process"
-};
-var PAYMENT_MUTATION = {
-  SUBMIT_AUTHORIZATION: "payment.submit_authorization",
-  CHECK_STATUS: "order.poll_payment_status"
-};
-var ORDER_MUTATION = {
-  UPDATE_CUSTOMER: "order.update_order_customer"
-};
-var DEFAULT_CURRENCY = "GHS";
-var DEFAULT_COUNTRY = "GHA";
-
-// src/utils/price.ts
-var CURRENCY_SYMBOLS = {
-  USD: "$",
-  EUR: "\u20AC",
-  GBP: "\xA3",
-  JPY: "\xA5",
-  CNY: "\xA5",
-  CHF: "CHF",
-  CAD: "C$",
-  AUD: "A$",
-  NZD: "NZ$",
-  HKD: "HK$",
-  SGD: "S$",
-  INR: "\u20B9",
-  BRL: "R$",
-  MXN: "MX$",
-  KRW: "\u20A9",
-  RUB: "\u20BD",
-  TRY: "\u20BA",
-  THB: "\u0E3F",
-  PLN: "z\u0142",
-  SEK: "kr",
-  NOK: "kr",
-  DKK: "kr",
-  CZK: "K\u010D",
-  HUF: "Ft",
-  ILS: "\u20AA",
-  AED: "\u062F.\u0625",
-  SAR: "\uFDFC",
-  MYR: "RM",
-  PHP: "\u20B1",
-  IDR: "Rp",
-  VND: "\u20AB",
-  TWD: "NT$",
-  GHS: "GH\u20B5",
-  NGN: "\u20A6",
-  KES: "KSh",
-  ZAR: "R",
-  XOF: "CFA",
-  XAF: "FCFA",
-  EGP: "E\xA3",
-  MAD: "MAD",
-  TZS: "TSh",
-  UGX: "USh",
-  RWF: "FRw",
-  ETB: "Br",
-  ZMW: "ZK",
-  BWP: "P",
-  MUR: "\u20A8",
-  SCR: "\u20A8",
-  NAD: "N$",
-  SZL: "E",
-  LSL: "L",
-  MWK: "MK",
-  AOA: "Kz",
-  CDF: "FC",
-  GMD: "D",
-  GNF: "FG",
-  LRD: "L$",
-  SLL: "Le",
-  MZN: "MT",
-  SDG: "SDG",
-  SSP: "SSP",
-  SOS: "Sh.So.",
-  DJF: "Fdj",
-  ERN: "Nfk",
-  CVE: "$",
-  STN: "Db",
-  KMF: "CF",
-  BIF: "FBu"
-};
-function getCurrencySymbol(currencyCode3) {
-  return CURRENCY_SYMBOLS[currencyCode3.toUpperCase()] || currencyCode3;
-}
-function formatNumberCompact(value, decimals = 1) {
-  const absValue = Math.abs(value);
-  const sign = value < 0 ? "-" : "";
-  if (absValue >= 1e9) {
-    return `${sign}${(absValue / 1e9).toFixed(decimals)}B`;
-  }
-  if (absValue >= 1e6) {
-    return `${sign}${(absValue / 1e6).toFixed(decimals)}M`;
-  }
-  if (absValue >= 1e3) {
-    return `${sign}${(absValue / 1e3).toFixed(decimals)}K`;
-  }
-  return `${sign}${absValue.toFixed(decimals)}`;
-}
-function formatPrice(amount, currency = "GHS", locale = "en-US") {
-  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
-  if (isNaN(numAmount)) {
-    return `${getCurrencySymbol(currency)}0.00`;
-  }
-  try {
-    return new Intl.NumberFormat(locale, {
-      style: "currency",
-      currency: currency.toUpperCase(),
-      minimumFractionDigits: 2,
-      maximumFractionDigits: 2
-    }).format(numAmount);
-  } catch {
-    return `${getCurrencySymbol(currency)}${numAmount.toFixed(2)}`;
-  }
-}
-function formatPriceAdjustment(amount, currency = "GHS", locale = "en-US") {
-  const formatted = formatPrice(Math.abs(amount), currency, locale);
-  if (amount > 0) {
-    return `+${formatted}`;
-  } else if (amount < 0) {
-    return `-${formatted}`;
-  }
-  return formatted;
-}
-function formatPriceCompact(amount, currency = "GHS", decimals = 1) {
-  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
-  if (isNaN(numAmount)) {
-    return `${getCurrencySymbol(currency)}0`;
-  }
-  const symbol = getCurrencySymbol(currency);
-  if (Math.abs(numAmount) < 1e3) {
-    return `${symbol}${numAmount.toFixed(2)}`;
-  }
-  return `${symbol}${formatNumberCompact(numAmount, decimals)}`;
-}
-function formatMoney(amount, currency = "GHS") {
-  const symbol = getCurrencySymbol(currency);
-  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
-  if (isNaN(numAmount)) {
-    return `${symbol}0.00`;
-  }
-  return `${symbol}${numAmount.toFixed(2)}`;
-}
-function parsePrice(value) {
-  if (value === void 0 || value === null) {
-    return 0;
-  }
-  if (typeof value === "number") {
-    return isNaN(value) ? 0 : value;
-  }
-  const cleaned = value.replace(/[^\d.-]/g, "");
-  const parsed = parseFloat(cleaned);
-  return isNaN(parsed) ? 0 : parsed;
-}
-function hasTaxInfo(priceInfo) {
-  return priceInfo.tax_info !== void 0 && priceInfo.tax_info !== null;
-}
-function getTaxAmount(priceInfo) {
-  return parsePrice(priceInfo.tax_info?.tax_amount);
-}
-function isTaxInclusive(priceInfo) {
-  return priceInfo.tax_info?.is_inclusive === true;
-}
-function formatPriceWithTax(priceInfo, currency = "GHS") {
-  const finalPrice = formatPrice(priceInfo.final_price, currency);
-  if (!hasTaxInfo(priceInfo)) {
-    return finalPrice;
-  }
-  if (isTaxInclusive(priceInfo)) {
-    return `${finalPrice} (incl. tax)`;
-  }
-  return `${finalPrice} + ${formatPrice(getTaxAmount(priceInfo), currency)} tax`;
-}
-function getDisplayPrice(product) {
-  if (product.price_info) {
-    return parsePrice(product.price_info.final_price);
-  }
-  if (product.final_price !== void 0 && product.final_price !== null) {
-    return parsePrice(product.final_price);
-  }
-  if (product.default_price !== void 0 && product.default_price !== null) {
-    return parsePrice(product.default_price);
-  }
-  return 0;
-}
-function getBasePrice(product) {
-  if (product.price_info) {
-    return parsePrice(product.price_info.base_price);
-  }
-  if (product.base_price !== void 0 && product.base_price !== null) {
-    return parsePrice(product.base_price);
-  }
-  if (product.default_price !== void 0 && product.default_price !== null) {
-    return parsePrice(product.default_price);
-  }
-  return 0;
-}
-function isOnSale(product) {
-  const basePrice = getBasePrice(product);
-  const finalPrice = getDisplayPrice(product);
-  return basePrice > finalPrice && basePrice > 0;
-}
-function getDiscountPercentage(product) {
-  const basePrice = getBasePrice(product);
-  const finalPrice = getDisplayPrice(product);
-  if (basePrice > finalPrice && basePrice > 0) {
-    return Math.round((basePrice - finalPrice) / basePrice * 100);
-  }
-  return 0;
-}
-function getMarkupPercentage(product) {
-  const basePrice = getBasePrice(product);
-  const finalPrice = getDisplayPrice(product);
-  if (finalPrice > basePrice && basePrice > 0) {
-    return Math.round((finalPrice - basePrice) / basePrice * 100);
-  }
-  return 0;
-}
-function getProductCurrency(product) {
-  if (product.price_info?.currency) {
-    return product.price_info.currency;
-  }
-  if (product.currency) {
-    return product.currency;
-  }
-  return "GHS";
-}
-function formatProductPrice(product, locale = "en-US") {
-  const price = getDisplayPrice(product);
-  const currency = getProductCurrency(product);
-  return formatPrice(price, currency, locale);
-}
-
-// src/utils/payment.ts
-function categorizePaymentError(error, errorCode) {
-  let message = "An unexpected error occurred during payment processing. Please try again or contact support.";
-  let recoverable = true;
-  let code = errorCode || "PAYMENT_ERROR";
-  const technical = error.stack;
-  const errorMessage = error.message?.toLowerCase() || "";
-  if (errorCode === "INSUFFICIENT_FUNDS" || errorMessage.includes("insufficient") || errorMessage.includes("funds")) {
-    code = "INSUFFICIENT_FUNDS";
-    message = "Your payment method has insufficient funds. Please try another payment method.";
-  } else if (errorCode === "CARD_DECLINED" || errorMessage.includes("declined")) {
-    code = "CARD_DECLINED";
-    message = "Your card was declined. Please try another card or payment method.";
-  } else if (errorMessage.includes("cancelled") || errorMessage.includes("canceled") || errorCode === "PAYMENT_CANCELLED") {
-    code = "PAYMENT_CANCELLED";
-    message = "Payment was cancelled. You can try again when ready.";
-  } else if (errorMessage.includes("network") || errorMessage.includes("connection") || errorCode === "NETWORK_ERROR") {
-    code = "NETWORK_ERROR";
-    message = "Network connection issue. Please check your internet connection and try again.";
-  } else if (errorMessage.includes("timeout") || errorCode === "TIMEOUT") {
-    code = "TIMEOUT";
-    message = "Payment processing timed out. Please try again.";
-  } else if (errorCode === "PAYMENT_ACTION_NOT_COMPLETED") {
-    code = "PAYMENT_ACTION_NOT_COMPLETED";
-    message = "Payment action was not completed. Please try again.";
-  } else if (errorCode === "AUTHORIZATION_FAILED") {
-    code = "AUTHORIZATION_FAILED";
-    message = "Authorization failed. Please check your code and try again.";
-  } else if (errorCode === "INVALID_OTP") {
-    code = "INVALID_OTP";
-    message = "Invalid verification code. Please check and try again.";
-  }
-  return { code, message, recoverable, technical };
-}
-function isQuickPaymentResponse(response) {
-  return response !== null && typeof response === "object" && "payment" in response && typeof response.payment === "object";
-}
-function isWebPaymentResponse(response) {
-  return response !== null && typeof response === "object" && "transaction" in response && typeof response.transaction === "object";
-}
-function normalizePaymentResponse(response) {
-  if (!response) {
-    return {
-      method: "unknown",
-      provider: "unknown",
-      requires_action: false,
-      metadata: {}
-    };
-  }
-  if (isQuickPaymentResponse(response)) {
-    return {
-      method: response.payment.type?.toLowerCase() || "unknown",
-      provider: response.payment.provider?.toLowerCase() || "unknown",
-      requires_action: !!response.payment.redirect_url || !!response.payment.access_code,
-      public_key: response.payment.public_key,
-      client_secret: response.payment.access_code,
-      access_code: response.payment.access_code,
-      redirect_url: response.payment.redirect_url,
-      transaction_id: response.payment.reference,
-      order_id: response.order_id,
-      reference: response.payment.reference,
-      instructions: response.payment.instructions,
-      metadata: response.payment.metadata
-    };
-  }
-  if (isWebPaymentResponse(response)) {
-    const objectAuthType = response.authorization_type && typeof response.authorization_type === "object" && "address" in response.authorization_type ? "address" : void 0;
-    const authType = typeof response.authorization_type === "string" ? response.authorization_type.trim().toLowerCase().replace(/[\s-]+/g, "_") : void 0;
-    const validStringAuthTypes = ["otp", "pin", "phone", "birthday", "address"];
-    const safeAuthType = objectAuthType || (authType && validStringAuthTypes.includes(authType) ? authType : void 0);
-    return {
-      provider: response.transaction.provider_type?.toLowerCase() || "unknown",
-      requires_action: response.requires_action || false,
-      public_key: response.public_key,
-      client_secret: response.client_secret,
-      redirect_url: response.authorization_url,
-      transaction_id: response.transaction.id,
-      order_id: response.transaction.order_id,
-      reference: response.transaction.provider_reference,
-      metadata: response.transaction.metadata,
-      method: response.transaction.payment_method?.toLowerCase() || "unknown",
-      instructions: response.display_text,
-      display_text: response.display_text,
-      requires_authorization: response.requires_authorization,
-      authorization_type: safeAuthType,
-      provider_payment_id: response.provider_payment_id || response.transaction.provider_reference
-    };
-  }
-  return {
-    method: "unknown",
-    provider: "unknown",
-    requires_action: false,
-    metadata: {}
-  };
-}
-var PAYMENT_SUCCESS_STATUSES = /* @__PURE__ */ new Set([
-  "success",
-  "succeeded",
-  "paid",
-  "captured",
-  "completed",
-  "authorized"
-]);
-var PAYMENT_FAILURE_STATUSES = /* @__PURE__ */ new Set([
-  "failed",
-  "declined",
-  "cancelled",
-  "voided",
-  "error",
-  "abandoned"
-]);
-var PAYMENT_REQUIRES_ACTION_STATUSES = /* @__PURE__ */ new Set([
-  "requires_action",
-  "requires_payment_method",
-  "requires_capture"
-]);
-var PAYMENT_STATUS_ALIAS_MAP = {
-  ok: "success",
-  done: "success",
-  paid: "paid",
-  paid_in_full: "paid",
-  paid_successfully: "paid",
-  succeeded: "success",
-  captured: "captured",
-  completed: "completed",
-  pending_confirmation: "pending_confirmation",
-  requires_authorization: "requires_action",
-  requires_action: "requires_action",
-  requires_payment_method: "requires_payment_method",
-  requires_capture: "requires_capture",
-  partially_paid: "partially_paid",
-  partially_refunded: "partially_refunded",
-  card_declined: "declined",
-  canceled: "cancelled",
-  authorized: "authorized",
-  cancelled: "cancelled",
-  unresolved: "pending"
-};
-var KNOWN_PAYMENT_STATUSES = /* @__PURE__ */ new Set([
-  "initialized",
-  "pending",
-  "processing",
-  "authorized",
-  "captured",
-  "failed",
-  "cancelled",
-  "refunded",
-  "unknown",
-  "voided",
-  "requires_action",
-  "abandoned",
-  "reversed",
-  "disputed",
-  "refund_pending",
-  "created",
-  "pending_confirmation",
-  "success",
-  "succeeded",
-  "declined",
-  "partially_refunded",
-  "partially_paid",
-  "paid",
-  "unpaid",
-  "requires_payment_method",
-  "requires_capture",
-  "completed",
-  "error"
-]);
-function normalizeStatusToken(status) {
-  return status?.trim().toLowerCase().replace(/[\s-]+/g, "_") ?? "";
-}
-function normalizePaymentStatusValue(status) {
-  const normalized = normalizeStatusToken(status);
-  if (Object.prototype.hasOwnProperty.call(PAYMENT_STATUS_ALIAS_MAP, normalized)) {
-    return PAYMENT_STATUS_ALIAS_MAP[normalized];
-  }
-  return KNOWN_PAYMENT_STATUSES.has(normalized) ? normalized : "unknown";
-}
-function isPaymentStatusSuccess(status) {
-  const normalizedStatus = normalizePaymentStatusValue(status);
-  return PAYMENT_SUCCESS_STATUSES.has(normalizedStatus);
-}
-function isPaymentStatusFailure(status) {
-  const normalizedStatus = normalizePaymentStatusValue(status);
-  return PAYMENT_FAILURE_STATUSES.has(normalizedStatus);
-}
-function isPaymentStatusRequiresAction(status) {
-  const normalizedStatus = normalizePaymentStatusValue(status);
-  return PAYMENT_REQUIRES_ACTION_STATUSES.has(normalizedStatus);
-}
-function normalizeStatusResponse(response) {
-  if (!response || typeof response !== "object") {
-    return {
-      status: "pending",
-      paid: false,
-      amount: moneyFromNumber(0),
-      currency: "",
-      message: "No status available"
-    };
-  }
-  const res = response;
-  const normalizedStatus = normalizePaymentStatusValue(res.status ?? void 0);
-  const normalizedAmount = typeof res.amount === "string" ? money(res.amount) : typeof res.amount === "number" && Number.isFinite(res.amount) ? moneyFromNumber(res.amount) : moneyFromNumber(0);
-  const normalizedCurrency = typeof res.currency === "string" && res.currency.trim().length > 0 ? res.currency : "";
-  const paidValue = res.paid === true;
-  const derivedPaid = paidValue || [
-    "success",
-    "succeeded",
-    "paid",
-    "captured",
-    "authorized",
-    "completed"
-  ].includes(normalizedStatus);
-  return {
-    status: normalizedStatus,
-    paid: derivedPaid,
-    amount: normalizedAmount,
-    currency: normalizedCurrency,
-    reference: res.reference,
-    message: res.message || ""
-  };
-}
-var MOBILE_MONEY_PROVIDERS = {
-  mtn: { name: "MTN Mobile Money", prefix: ["024", "054", "055", "059"] },
-  vodafone: { name: "Vodafone Cash", prefix: ["020", "050"] },
-  airtel: { name: "AirtelTigo Money", prefix: ["027", "057", "026", "056"] }
-};
-function detectMobileMoneyProvider(phoneNumber) {
-  const cleaned = phoneNumber.replace(/\D/g, "");
-  const prefix = cleaned.slice(-9, -6);
-  for (const [provider, info] of Object.entries(MOBILE_MONEY_PROVIDERS)) {
-    if (info.prefix.some((p) => prefix.startsWith(p.slice(1)))) {
-      return provider;
-    }
-  }
-  return null;
-}
-
-// src/utils/paystack.ts
-async function openPaystackPopup(options, signal) {
-  if (typeof window === "undefined") {
-    return { success: false, error: "PROVIDER_UNAVAILABLE" };
-  }
-  let PaystackPop;
-  try {
-    const imported = await import('@paystack/inline-js');
-    PaystackPop = imported.default;
-  } catch {
-    return { success: false, error: "PROVIDER_UNAVAILABLE" };
-  }
-  return new Promise((resolve) => {
-    let settled = false;
-    const resolveOnce = (result) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (signal) {
-        signal.removeEventListener("abort", onAbort);
-      }
-      resolve(result);
-    };
-    const onAbort = () => {
-      resolveOnce({ success: false, error: "CANCELLED" });
-    };
-    if (signal?.aborted) {
-      resolveOnce({ success: false, error: "CANCELLED" });
-      return;
-    }
-    if (signal) {
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-    try {
-      const popup = new PaystackPop();
-      popup.newTransaction({
-        key: options.key,
-        email: options.email,
-        amount: options.amount,
-        currency: options.currency,
-        reference: options.reference,
-        accessCode: options.accessCode,
-        onSuccess: (transaction) => {
-          resolveOnce({
-            success: true,
-            reference: transaction.reference ?? options.reference
-          });
-        },
-        onCancel: () => {
-          resolveOnce({ success: false, error: "PAYMENT_CANCELLED" });
-        },
-        onError: (error) => {
-          resolveOnce({
-            success: false,
-            error: error?.message || "PAYMENT_FAILED"
-          });
-        }
-      });
-    } catch {
-      resolveOnce({ success: false, error: "POPUP_BLOCKED" });
-    }
-  });
-}
-
-// src/utils/checkout-resolver.ts
-var DEFAULT_POLL_INTERVAL_MS = 3e3;
-var DEFAULT_MAX_POLL_ATTEMPTS = 60;
-var MAX_CONSECUTIVE_NETWORK_ERRORS = 5;
-var CARD_PROVIDER_PAYSTACK = "paystack";
-var NEXT_ACTION_NONE = "none";
-var NEXT_ACTION_CARD_POPUP = "card_popup";
-var NEXT_ACTION_REDIRECT = "redirect";
-var NEXT_ACTION_AUTHORIZATION = "authorization";
-function normalizeCardPopupError(error) {
-  if (!error || error === "PAYMENT_CANCELLED" || error === "CANCELLED") {
-    return "PAYMENT_CANCELLED";
-  }
-  if (error === "PROVIDER_UNAVAILABLE") {
-    return "PROVIDER_UNAVAILABLE";
-  }
-  if (error === "POPUP_BLOCKED") {
-    return "POPUP_BLOCKED";
-  }
-  return "PAYMENT_FAILED";
-}
-function normalizeCardProvider(value) {
-  const normalized = value?.trim().toLowerCase();
-  return normalized && normalized.length > 0 ? normalized : CARD_PROVIDER_PAYSTACK;
-}
-async function openCardPopup(provider, checkoutResult, email, currency, signal) {
-  if (typeof window === "undefined") {
-    return { success: false, error: "PROVIDER_UNAVAILABLE" };
-  }
-  if (provider === CARD_PROVIDER_PAYSTACK) {
-    return openPaystackPopup(
-      {
-        key: checkoutResult.public_key || "",
-        email,
-        accessCode: checkoutResult.client_secret,
-        reference: checkoutResult.payment_reference || checkoutResult.client_secret,
-        currency
-      },
-      signal
-    );
-  }
-  return { success: false, error: "PROVIDER_UNAVAILABLE" };
-}
-var VALID_MOBILE_MONEY_PROVIDERS = new Set(Object.values(MOBILE_MONEY_PROVIDER));
-function isValidMobileMoneyProvider(value) {
-  return VALID_MOBILE_MONEY_PROVIDERS.has(value);
-}
-function normalizeAuthorizationType(value) {
-  if (value && typeof value === "object" && "address" in value) {
-    return "address";
-  }
-  if (typeof value !== "string") return void 0;
-  const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
-  if (normalized === "otp" || normalized === "pin") return normalized;
-  if (normalized === "phone" || normalized === "birthday" || normalized === "address") {
-    return normalized;
-  }
-  return void 0;
-}
-function formatMoney2(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value.toFixed(2);
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    return value;
-  }
-  return "0.00";
-}
-function createAbortError() {
-  const error = new Error("CANCELLED");
-  error.name = "AbortError";
-  return error;
-}
-function isAbortError(error) {
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return true;
-  }
-  return error instanceof Error && (error.name === "AbortError" || error.message === "CANCELLED");
-}
-var CheckoutResolver = class {
-  constructor(options) {
-    this.client = options.client;
-    this.checkoutData = options.checkoutData;
-    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-    this.maxPollAttempts = options.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS;
-    this.onStatusChange = options.onStatusChange;
-    this.onAuthorizationRequired = options.onAuthorizationRequired;
-    this.signal = options.signal;
-    this.returnUrl = options.returnUrl;
-    this.enrollInLink = options.enrollInLink !== false;
-    this.businessId = options.businessId;
-    this.addressData = options.addressData;
-    this.paymentData = options.paymentData;
-    this.orderType = options.orderType;
-    this.cartTotal = options.cartTotal;
-    this.cartCurrency = options.cartCurrency;
-    this.allowPopups = options.allowPopups ?? typeof window !== "undefined";
-  }
-  async resolve(checkoutResult) {
-    try {
-      this.ensureNotAborted();
-      if (!checkoutResult.order_id) {
-        return this.fail("CHECKOUT_FAILED", "Checkout did not return an order ID.", false);
-      }
-      if (checkoutResult.next_action) {
-        return this.resolveNextAction(checkoutResult);
-      }
-      let latestCheckoutResult = checkoutResult;
-      let authorizationType = normalizeAuthorizationType(checkoutResult.authorization_type);
-      let paymentReference = checkoutResult.payment_reference;
-      if (this.isSuccessfulStatus(checkoutResult.payment_status)) {
-        return this.finalizeSuccess(checkoutResult);
-      }
-      if (checkoutResult.client_secret && checkoutResult.public_key) {
-        const provider = normalizeCardProvider(checkoutResult.provider);
-        this.emit("awaiting_authorization", {
-          display_text: "Complete payment in the card authorization popup.",
-          order_id: checkoutResult.order_id,
-          order_number: checkoutResult.order_number
-        });
-        if (!this.allowPopups) {
-          return this.fail(
-            "PROVIDER_UNAVAILABLE",
-            "Card payment popup is unavailable in this environment.",
-            false
-          );
-        }
-        const popupResult = await openCardPopup(
-          provider,
-          checkoutResult,
-          this.checkoutData.customer.email || "customer@cimplify.io",
-          this.getOrderCurrency(checkoutResult),
-          this.signal
-        );
-        if (!popupResult.success) {
-          const popupError = normalizeCardPopupError(popupResult.error);
-          if (popupError === "POPUP_BLOCKED") {
-            return this.fail(
-              "POPUP_BLOCKED",
-              "Unable to open card payment popup. Please allow popups and try again.",
-              true
-            );
-          }
-          if (popupError === "PROVIDER_UNAVAILABLE") {
-            return this.fail(
-              "PROVIDER_UNAVAILABLE",
-              "Card payment provider is unavailable.",
-              false
-            );
-          }
-          return this.fail(
-            "PAYMENT_CANCELLED",
-            "Card payment was cancelled before completion.",
-            true
-          );
-        }
-        paymentReference = popupResult.reference || paymentReference;
-      }
-      if (checkoutResult.authorization_url) {
-        if (typeof window !== "undefined" && this.returnUrl) {
-          window.location.assign(checkoutResult.authorization_url);
-          return this.fail(
-            "REDIRECT_REQUIRED",
-            "Redirecting to complete payment authorization.",
-            true
-          );
-        }
-        if (typeof window !== "undefined") {
-          const popup = window.open(
-            checkoutResult.authorization_url,
-            "cimplify-auth",
-            "width=520,height=760,noopener,noreferrer"
-          );
-          if (!popup) {
-            return this.fail(
-              "POPUP_BLOCKED",
-              "Authorization popup was blocked. Please allow popups and retry.",
-              true
-            );
-          }
-        }
-      }
-      if (checkoutResult.requires_authorization || isPaymentStatusRequiresAction(checkoutResult.payment_status)) {
-        const authorization = await this.handleAuthorization({
-          authorizationType,
-          paymentReference,
-          displayText: checkoutResult.display_text,
-          provider: checkoutResult.provider
-        });
-        if (!authorization.ok) {
-          return authorization.result;
-        }
-        if (authorization.value) {
-          latestCheckoutResult = authorization.value;
-          paymentReference = authorization.value.payment_reference || paymentReference;
-          authorizationType = normalizeAuthorizationType(authorization.value.authorization_type) || authorizationType;
-          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
-            return this.finalizeSuccess(authorization.value);
-          }
-          if (this.isFailureStatus(authorization.value.payment_status)) {
-            return this.fail(
-              "AUTHORIZATION_FAILED",
-              authorization.value.display_text || "Payment authorization failed.",
-              false
-            );
-          }
-        }
-      }
-      return this.pollUntilTerminal({
-        orderId: checkoutResult.order_id,
-        latestCheckoutResult,
-        paymentReference,
-        authorizationType
-      });
-    } catch (error) {
-      if (isAbortError(error)) {
-        return this.fail("CANCELLED", "Checkout was cancelled.", true);
-      }
-      const message = error instanceof Error ? error.message : "Checkout failed unexpectedly.";
-      return this.fail("CHECKOUT_FAILED", message, true);
-    }
-  }
-  async resolveNextAction(checkoutResult) {
-    const action = checkoutResult.next_action;
-    if (this.isSuccessfulStatus(checkoutResult.payment_status)) {
-      return this.finalizeSuccess(checkoutResult);
-    }
-    let latestCheckoutResult = checkoutResult;
-    let paymentReference = checkoutResult.payment_reference;
-    switch (action.type) {
-      case NEXT_ACTION_NONE:
-        return this.finalizeSuccess(checkoutResult);
-      case NEXT_ACTION_CARD_POPUP: {
-        const provider = normalizeCardProvider(action.provider);
-        this.emit("awaiting_authorization", {
-          display_text: "Complete payment in the card authorization popup.",
-          order_id: checkoutResult.order_id,
-          order_number: checkoutResult.order_number
-        });
-        if (!this.allowPopups) {
-          return this.fail(
-            "PROVIDER_UNAVAILABLE",
-            "Card payment popup is unavailable in this environment.",
-            false
-          );
-        }
-        const popupResult = await openCardPopup(
-          provider,
-          checkoutResult,
-          this.checkoutData.customer.email || "customer@cimplify.io",
-          this.getOrderCurrency(checkoutResult),
-          this.signal
-        );
-        if (!popupResult.success) {
-          const popupError = normalizeCardPopupError(popupResult.error);
-          if (popupError === "POPUP_BLOCKED") {
-            return this.fail(
-              "POPUP_BLOCKED",
-              "Unable to open card payment popup. Please allow popups and try again.",
-              true
-            );
-          }
-          if (popupError === "PROVIDER_UNAVAILABLE") {
-            return this.fail("PROVIDER_UNAVAILABLE", "Card payment provider is unavailable.", false);
-          }
-          return this.fail("PAYMENT_CANCELLED", "Card payment was cancelled before completion.", true);
-        }
-        paymentReference = popupResult.reference || paymentReference;
-        break;
-      }
-      case NEXT_ACTION_REDIRECT: {
-        if (typeof window !== "undefined" && this.returnUrl) {
-          window.location.assign(action.authorization_url);
-          return this.fail("REDIRECT_REQUIRED", "Redirecting to complete payment authorization.", true);
-        }
-        if (typeof window !== "undefined") {
-          const popup = window.open(
-            action.authorization_url,
-            "cimplify-auth",
-            "width=520,height=760,noopener,noreferrer"
-          );
-          if (!popup) {
-            return this.fail(
-              "POPUP_BLOCKED",
-              "Authorization popup was blocked. Please allow popups and retry.",
-              true
-            );
-          }
-        }
-        break;
-      }
-      case NEXT_ACTION_AUTHORIZATION: {
-        const authType = normalizeAuthorizationType(action.authorization_type);
-        const authorization = await this.handleAuthorization({
-          authorizationType: authType,
-          paymentReference,
-          displayText: action.display_text,
-          provider: checkoutResult.provider
-        });
-        if (!authorization.ok) {
-          return authorization.result;
-        }
-        if (authorization.value) {
-          latestCheckoutResult = authorization.value;
-          paymentReference = authorization.value.payment_reference || paymentReference;
-          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
-            return this.finalizeSuccess(authorization.value);
-          }
-          if (this.isFailureStatus(authorization.value.payment_status)) {
-            return this.fail(
-              "AUTHORIZATION_FAILED",
-              authorization.value.display_text || "Payment authorization failed.",
-              false
-            );
-          }
-        }
-        break;
-      }
-    }
-    return this.pollUntilTerminal({
-      orderId: checkoutResult.order_id,
-      latestCheckoutResult,
-      paymentReference,
-      authorizationType: normalizeAuthorizationType(checkoutResult.authorization_type)
-    });
-  }
-  async pollUntilTerminal(input) {
-    let consecutiveErrors = 0;
-    let latestCheckoutResult = input.latestCheckoutResult;
-    let paymentReference = input.paymentReference;
-    let authorizationType = input.authorizationType;
-    for (let attempt = 0; attempt < this.maxPollAttempts; attempt++) {
-      this.ensureNotAborted();
-      this.emit("polling", {
-        poll_attempt: attempt,
-        max_poll_attempts: this.maxPollAttempts,
-        order_id: input.orderId,
-        order_number: latestCheckoutResult.order_number
-      });
-      const statusResult = await this.client.checkout.pollPaymentStatus(input.orderId);
-      if (!statusResult.ok) {
-        consecutiveErrors += 1;
-        if (consecutiveErrors >= MAX_CONSECUTIVE_NETWORK_ERRORS) {
-          return this.fail(
-            "NETWORK_ERROR",
-            "Unable to confirm payment due to repeated network errors.",
-            true
-          );
-        }
-        await this.wait(this.pollIntervalMs);
-        continue;
-      }
-      consecutiveErrors = 0;
-      if (statusResult.value.reference) {
-        paymentReference = statusResult.value.reference;
-      }
-      const normalized = normalizeStatusResponse(statusResult.value);
-      if (normalized.paid || isPaymentStatusSuccess(normalized.status)) {
-        return this.finalizeSuccess(latestCheckoutResult);
-      }
-      if (isPaymentStatusFailure(normalized.status)) {
-        return this.fail(
-          normalized.status ? normalized.status.toUpperCase() : "PAYMENT_FAILED",
-          normalized.message || "Payment failed during confirmation.",
-          false
-        );
-      }
-      if (isPaymentStatusRequiresAction(normalized.status)) {
-        const authorization = await this.handleAuthorization({
-          authorizationType,
-          paymentReference,
-          displayText: normalized.message || latestCheckoutResult.display_text,
-          provider: latestCheckoutResult.provider
-        });
-        if (!authorization.ok) {
-          return authorization.result;
-        }
-        if (authorization.value) {
-          latestCheckoutResult = authorization.value;
-          paymentReference = authorization.value.payment_reference || paymentReference;
-          authorizationType = normalizeAuthorizationType(authorization.value.authorization_type) || authorizationType;
-          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
-            return this.finalizeSuccess(authorization.value);
-          }
-          if (this.isFailureStatus(authorization.value.payment_status)) {
-            return this.fail(
-              "AUTHORIZATION_FAILED",
-              authorization.value.display_text || "Payment authorization failed.",
-              false
-            );
-          }
-        }
-      }
-      await this.wait(this.pollIntervalMs);
-    }
-    try {
-      const finalResult = await this.client.checkout.pollPaymentStatus(input.orderId);
-      if (finalResult.ok) {
-        const normalized = normalizeStatusResponse(finalResult.value);
-        if (normalized.paid || isPaymentStatusSuccess(normalized.status)) {
-          return this.finalizeSuccess(latestCheckoutResult);
-        }
-      }
-    } catch {
-    }
-    return this.fail(
-      "PAYMENT_TIMEOUT",
-      "Payment confirmation timed out. Please retry checkout.",
-      true
-    );
-  }
-  async handleAuthorization(input) {
-    const authorizationType = input.authorizationType;
-    const paymentReference = input.paymentReference;
-    if (!authorizationType || !paymentReference) {
-      return { ok: true };
-    }
-    this.emit("awaiting_authorization", {
-      authorization_type: authorizationType,
-      display_text: input.displayText,
-      provider: input.provider
-    });
-    let authorizationResult;
-    const submit = async (code) => {
-      this.ensureNotAborted();
-      const trimmedCode = code.trim();
-      if (!trimmedCode) {
-        throw new Error("Authorization code is required.");
-      }
-      const submitResult = await this.client.checkout.submitAuthorization({
-        reference: paymentReference,
-        auth_type: authorizationType,
-        value: trimmedCode
-      });
-      if (!submitResult.ok) {
-        throw new Error(submitResult.error.message || "Authorization failed.");
-      }
-      authorizationResult = submitResult.value;
-    };
-    try {
-      if (this.onAuthorizationRequired) {
-        await this.onAuthorizationRequired(authorizationType, submit);
-      } else {
-        return {
-          ok: false,
-          result: this.fail(
-            "AUTHORIZATION_REQUIRED",
-            "Authorization callback is required in headless checkout mode.",
-            false
-          )
-        };
-      }
-    } catch (error) {
-      if (isAbortError(error)) {
-        return {
-          ok: false,
-          result: this.fail("CANCELLED", "Checkout was cancelled.", true)
-        };
-      }
-      const message = error instanceof Error ? error.message : "Payment authorization failed.";
-      return {
-        ok: false,
-        result: this.fail("AUTHORIZATION_FAILED", message, true)
-      };
-    }
-    return {
-      ok: true,
-      value: authorizationResult
-    };
-  }
-  async finalizeSuccess(checkoutResult) {
-    this.emit("finalizing", {
-      order_id: checkoutResult.order_id,
-      order_number: checkoutResult.order_number
-    });
-    const enrolledInLink = await this.maybeEnrollInLink(checkoutResult.order_id);
-    this.emit("success", {
-      order_id: checkoutResult.order_id,
-      order_number: checkoutResult.order_number
-    });
-    return {
-      success: true,
-      order: {
-        id: checkoutResult.order_id,
-        order_number: checkoutResult.order_number || checkoutResult.order_id,
-        status: checkoutResult.payment_status || "paid",
-        total: this.getOrderTotal(checkoutResult),
-        currency: this.getOrderCurrency(checkoutResult)
-      },
-      enrolled_in_link: enrolledInLink
-    };
-  }
-  async maybeEnrollInLink(orderId) {
-    if (!this.enrollInLink || !orderId) {
-      return false;
-    }
-    let businessId = this.businessId;
-    if (!businessId) {
-      const businessResult = await this.client.business.getInfo();
-      if (!businessResult.ok || !businessResult.value?.id) {
-        return false;
-      }
-      businessId = businessResult.value.id;
-    }
-    const address = this.getEnrollmentAddress();
-    const mobileMoney = this.getEnrollmentMobileMoney();
-    try {
-      const enrollment = await this.client.link.enrollAndLinkOrder({
-        order_id: orderId,
-        business_id: businessId,
-        order_type: this.orderType || this.checkoutData.order_type,
-        address,
-        mobile_money: mobileMoney
-      });
-      return enrollment.ok && enrollment.value.success;
-    } catch {
-      return false;
-    }
-  }
-  getEnrollmentAddress() {
-    const source = this.addressData ?? this.checkoutData.address_info;
-    if (!source?.street_address) {
-      return void 0;
-    }
-    return {
-      label: "Default",
-      street_address: source.street_address,
-      apartment: source.apartment || void 0,
-      city: source.city || "",
-      region: source.region || "",
-      delivery_instructions: source.delivery_instructions || void 0,
-      phone_for_delivery: source.phone_for_delivery || void 0
-    };
-  }
-  getEnrollmentMobileMoney() {
-    if (this.paymentData?.type === "mobile_money" && this.paymentData.phone_number && this.paymentData.provider && isValidMobileMoneyProvider(this.paymentData.provider)) {
-      return {
-        phone_number: this.paymentData.phone_number,
-        provider: this.paymentData.provider,
-        label: this.paymentData.label || "Mobile Money"
-      };
-    }
-    if (this.checkoutData.mobile_money_details?.phone_number) {
-      return {
-        phone_number: this.checkoutData.mobile_money_details.phone_number,
-        provider: this.checkoutData.mobile_money_details.provider,
-        label: "Mobile Money"
-      };
-    }
-    return void 0;
-  }
-  getOrderTotal(checkoutResult) {
-    if (checkoutResult.fx?.pay_amount !== void 0) {
-      return formatMoney2(checkoutResult.fx.pay_amount);
-    }
-    if (this.cartTotal !== void 0) {
-      return formatMoney2(this.cartTotal);
-    }
-    return "0.00";
-  }
-  getOrderCurrency(checkoutResult) {
-    if (checkoutResult.fx?.pay_currency) {
-      return checkoutResult.fx.pay_currency;
-    }
-    if (this.cartCurrency) {
-      return this.cartCurrency;
-    }
-    if (this.checkoutData.pay_currency) {
-      return this.checkoutData.pay_currency;
-    }
-    return "GHS";
-  }
-  emit(status, context = {}) {
-    if (!this.onStatusChange) {
-      return;
-    }
-    try {
-      this.onStatusChange(status, context);
-    } catch {
-    }
-  }
-  fail(code, message, recoverable) {
-    this.emit("failed", {
-      display_text: message
-    });
-    return {
-      success: false,
-      error: {
-        code,
-        message,
-        recoverable
-      }
-    };
-  }
-  isSuccessfulStatus(status) {
-    const normalized = normalizeStatusResponse({ status, paid: false });
-    return normalized.paid || isPaymentStatusSuccess(normalized.status);
-  }
-  isFailureStatus(status) {
-    const normalized = normalizeStatusResponse({ status, paid: false });
-    return isPaymentStatusFailure(normalized.status);
-  }
-  ensureNotAborted() {
-    if (this.signal?.aborted) {
-      throw createAbortError();
-    }
-  }
-  wait(ms) {
-    this.ensureNotAborted();
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        if (this.signal) {
-          this.signal.removeEventListener("abort", onAbort);
-        }
-        resolve();
-      }, ms);
-      const onAbort = () => {
-        clearTimeout(timer);
-        reject(createAbortError());
-      };
-      if (this.signal) {
-        this.signal.addEventListener("abort", onAbort, { once: true });
-      }
-    });
-  }
-};
-
-// src/checkout.ts
-function toTerminalFailure(code, message, recoverable) {
-  return {
-    success: false,
-    error: {
-      code,
-      message,
-      recoverable
-    }
-  };
-}
-function generateIdempotencyKey() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return `idem_${crypto.randomUUID()}`;
-  }
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 15);
-  return `idem_${timestamp}_${random}`;
-}
-var CheckoutService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  orderTokenParam(orderId) {
-    const token = this.client.getOrderToken(orderId);
-    return token ? `?token=${encodeURIComponent(token)}` : "";
-  }
-  async process(data) {
-    const checkoutData = {
-      ...data,
-      idempotency_key: data.idempotency_key || generateIdempotencyKey()
-    };
-    const result = await safe(
-      this.client.post("/api/v1/checkout", {
-        checkout_data: checkoutData
-      })
-    );
-    if (result.ok && result.value.bill_token) {
-      this.client.setOrderToken(result.value.order_id, result.value.bill_token);
-    }
-    return result;
-  }
-  async initializePayment(_orderId, _method) {
-    return err(
-      new CimplifyError(
-        "NOT_IMPLEMENTED",
-        "initializePayment is not available in REST mode.",
-        false
-      )
-    );
-  }
-  async submitAuthorization(input) {
-    return safe(this.client.post("/api/v1/payments/authorization", input));
-  }
-  async pollPaymentStatus(orderId) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(this.client.get(`/api/v1/orders/${encodedId}/payment-status${tokenParam}`));
-  }
-  async updateOrderCustomer(orderId, customer) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(this.client.post(`/api/v1/orders/${encodedId}/customer${tokenParam}`, customer));
-  }
-  async verifyPayment(orderId) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(this.client.post(`/api/v1/orders/${encodedId}/verify-payment${tokenParam}`));
-  }
-  async processAndResolve(data) {
-    data.on_status_change?.("preparing", {});
-    if (!data.cart_id) {
-      return ok(
-        toTerminalFailure(
-          "INVALID_CART",
-          "A valid cart is required before checkout can start.",
-          false
-        )
-      );
-    }
-    const cartResult = await this.client.cart.get();
-    if (!cartResult.ok || !cartResult.value?.id) {
-      return ok(
-        toTerminalFailure(
-          "INVALID_CART",
-          "Unable to load cart for checkout.",
-          false
-        )
-      );
-    }
-    const cart = cartResult.value;
-    if (cart.id !== data.cart_id || cart.items.length === 0) {
-      return ok(
-        toTerminalFailure(
-          "INVALID_CART",
-          "Cart is empty or no longer valid. Please refresh and try again.",
-          false
-        )
-      );
-    }
-    const checkoutData = {
-      cart_id: data.cart_id,
-      location_id: data.location_id,
-      customer: data.customer,
-      order_type: data.order_type,
-      address_info: data.address_info,
-      payment_method: data.payment_method,
-      mobile_money_details: data.mobile_money_details,
-      special_instructions: data.special_instructions,
-      link_address_id: data.link_address_id,
-      link_payment_method_id: data.link_payment_method_id,
-      idempotency_key: data.idempotency_key || generateIdempotencyKey(),
-      metadata: data.metadata,
-      pay_currency: data.pay_currency,
-      fx_quote_id: data.fx_quote_id
-    };
-    const baseCurrency = currencyCode(
-      (cart.pricing.currency || checkoutData.pay_currency || "GHS").toUpperCase()
-    );
-    const payCurrency = data.pay_currency?.trim().toUpperCase();
-    const payCurrencyCode = payCurrency ? currencyCode(payCurrency) : void 0;
-    const cartTotalAmount = typeof cart.pricing.total_price === "number" ? cart.pricing.total_price : Number.parseFloat(cart.pricing.total_price || "0");
-    if (payCurrencyCode && payCurrencyCode !== baseCurrency && !checkoutData.fx_quote_id && Number.isFinite(cartTotalAmount) && cartTotalAmount > 0) {
-      const fxQuoteResult = await this.client.fx.lockQuote({
-        from: baseCurrency,
-        to: payCurrencyCode,
-        amount: cart.pricing.total_price
-      });
-      if (!fxQuoteResult.ok) {
-        return ok(
-          toTerminalFailure(
-            "FX_QUOTE_FAILED",
-            fxQuoteResult.error.message || "Unable to lock FX quote for checkout.",
-            true
-          )
-        );
-      }
-      checkoutData.pay_currency = payCurrencyCode;
-      checkoutData.fx_quote_id = fxQuoteResult.value.id;
-    }
-    data.on_status_change?.("processing", {});
-    const processResult = await this.process(checkoutData);
-    if (!processResult.ok) {
-      return ok(
-        toTerminalFailure(
-          processResult.error.code || "CHECKOUT_FAILED",
-          processResult.error.message || "Unable to process checkout.",
-          processResult.error.retryable ?? true
-        )
-      );
-    }
-    const resolver = new CheckoutResolver({
-      client: this.client,
-      checkoutData,
-      pollIntervalMs: data.poll_interval_ms,
-      maxPollAttempts: data.max_poll_attempts,
-      onStatusChange: data.on_status_change,
-      onAuthorizationRequired: data.on_authorization_required,
-      signal: data.signal,
-      returnUrl: data.return_url,
-      enrollInLink: data.enroll_in_link,
-      cartTotal: cart.pricing.total_price,
-      cartCurrency: checkoutData.pay_currency || cart.pricing.currency || "GHS",
-      orderType: checkoutData.order_type,
-      allowPopups: data.allow_popups
-    });
-    const resolved = await resolver.resolve(processResult.value);
-    return ok(resolved);
-  }
-};
-
-// src/orders.ts
-var OrderQueries = class {
-  constructor(client) {
-    this.client = client;
-  }
-  orderTokenParam(orderId) {
-    const token = this.client.getOrderToken(orderId);
-    return token ? `?token=${encodeURIComponent(token)}` : "";
-  }
-  async list(options) {
-    const params = new URLSearchParams();
-    if (options?.status) params.set("status", options.status);
-    if (options?.limit) params.set("limit", String(options.limit));
-    if (options?.offset) params.set("offset", String(options.offset));
-    const path = params.toString() ? `/api/v1/orders?${params.toString()}` : "/api/v1/orders";
-    return safe(this.client.get(path));
-  }
-  async get(orderId) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(this.client.get(`/api/v1/orders/${encodedId}${tokenParam}`));
-  }
-  async getRecent(limit = 5) {
-    return this.list({ limit });
-  }
-  async getByStatus(status) {
-    return this.list({ status });
-  }
-  async cancel(orderId, reason) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(
-      this.client.post(`/api/v1/orders/${encodedId}/cancel${tokenParam}`, {
-        reason
-      })
-    );
-  }
-};
-
-// src/link.ts
-function encodePathSegment(value) {
-  return encodeURIComponent(value);
-}
-function toCreateAddressPayload(input) {
-  return {
-    label: input.label,
-    street_address: input.address_line1,
-    apartment: input.address_line2,
-    city: input.city,
-    region: input.state ?? "",
-    postal_code: input.postal_code,
-    country: input.country
-  };
-}
-function toUpdateAddressPayload(input) {
-  return {
-    label: input.label,
-    street_address: input.address_line1,
-    apartment: input.address_line2,
-    city: input.city,
-    region: input.state,
-    postal_code: input.postal_code,
-    country: input.country
-  };
-}
-function toCreateMobileMoneyPayload(input) {
-  return {
-    phone_number: input.phone_number,
-    provider: input.provider,
-    label: input.account_name
-  };
-}
-var LinkService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getProfile() {
-    return safe(this.client.linkGet("/v1/link/profile"));
-  }
-  async requestOtp(input) {
-    return safe(this.client.linkPost("/v1/link/auth/request-otp", input));
-  }
-  async verifyOtp(input) {
-    const result = await safe(
-      this.client.linkPost("/v1/link/auth/verify-otp", input)
-    );
-    if (result.ok && result.value.session_token) {
-      this.client.setAccessToken(result.value.session_token);
-    }
-    return result;
-  }
-  async logout() {
-    const result = await safe(this.client.linkPost("/v1/link/auth/logout"));
-    if (result.ok) {
-      this.client.clearSession();
-    }
-    return result;
-  }
-  async checkStatus(contact) {
-    return safe(this.client.linkPost("/v1/link/check-status", { contact }));
-  }
-  async getLinkData() {
-    return safe(this.client.linkGet("/v1/link/data"));
-  }
-  async getAddresses() {
-    return safe(this.client.linkGet("/v1/link/addresses"));
-  }
-  async getMobileMoney() {
-    return safe(this.client.linkGet("/v1/link/mobile-money"));
-  }
-  async getPreferences() {
-    return safe(this.client.linkGet("/v1/link/preferences"));
-  }
-  async enroll(data) {
-    return safe(this.client.linkPost("/v1/link/enroll", data));
-  }
-  async enrollAndLinkOrder(data) {
-    return safe(
-      this.client.linkPost("/v1/link/enroll-and-link-order", data)
-    );
-  }
-  async updatePreferences(preferences) {
-    return safe(this.client.linkPost("/v1/link/preferences", preferences));
-  }
-  async createAddress(input) {
-    return safe(
-      this.client.linkPost("/v1/link/addresses", toCreateAddressPayload(input))
-    );
-  }
-  async updateAddress(input) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/addresses/${encodePathSegment(input.address_id)}`,
-        toUpdateAddressPayload(input)
-      )
-    );
-  }
-  async deleteAddress(addressId) {
-    return safe(
-      this.client.linkDelete(`/v1/link/addresses/${encodePathSegment(addressId)}`)
-    );
-  }
-  async setDefaultAddress(addressId) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/addresses/${encodePathSegment(addressId)}/default`
-      )
-    );
-  }
-  async trackAddressUsage(addressId) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/addresses/${encodePathSegment(addressId)}/track-usage`
-      )
-    );
-  }
-  async createMobileMoney(input) {
-    return safe(
-      this.client.linkPost(
-        "/v1/link/mobile-money",
-        toCreateMobileMoneyPayload(input)
-      )
-    );
-  }
-  async deleteMobileMoney(mobileMoneyId) {
-    return safe(
-      this.client.linkDelete(
-        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}`
-      )
-    );
-  }
-  async setDefaultMobileMoney(mobileMoneyId) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/default`
-      )
-    );
-  }
-  async trackMobileMoneyUsage(mobileMoneyId) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/track-usage`
-      )
-    );
-  }
-  async verifyMobileMoney(mobileMoneyId) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/verify`
-      )
-    );
-  }
-  async getSessions() {
-    return safe(this.client.linkGet("/v1/link/sessions"));
-  }
-  async revokeSession(sessionId) {
-    return safe(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
-  }
-  async revokeAllSessions() {
-    return safe(this.client.linkDelete("/v1/link/sessions"));
-  }
-};
-
-// src/auth.ts
-var AuthService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getStatus() {
-    return safe(this.client.get("/api/v1/auth/status"));
-  }
-  async getCurrentUser() {
-    const result = await this.getStatus();
-    if (!result.ok) return result;
-    return ok(result.value.customer || null);
-  }
-  async isAuthenticated() {
-    const result = await this.getStatus();
-    if (!result.ok) return result;
-    return ok(result.value.is_authenticated);
-  }
-  async requestOtp(contact, contactType) {
-    return safe(
-      this.client.post("/api/v1/auth/request-otp", {
-        contact,
-        contact_type: contactType
-      })
-    );
-  }
-  async verifyOtp(code, contact) {
-    return safe(
-      this.client.post("/api/v1/auth/verify-otp", {
-        otp_code: code,
-        contact
-      })
-    );
-  }
-  async logout() {
-    return safe(this.client.post("/api/v1/auth/logout"));
-  }
-  async updateProfile(input) {
-    return safe(this.client.post("/api/v1/auth/profile", input));
-  }
-};
-
-// src/business.ts
-var BusinessService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getInfo() {
-    return safe(this.client.get("/api/v1/business"));
-  }
-  async getByHandle(handle) {
-    const encodedHandle = encodeURIComponent(handle);
-    return safe(this.client.get(`/api/v1/business/by-handle/${encodedHandle}`));
-  }
-  async getByDomain(domain) {
-    const encodedDomain = encodeURIComponent(domain);
-    return safe(this.client.get(`/api/v1/business/by-domain?domain=${encodedDomain}`));
-  }
-  async getSettings() {
-    return safe(this.client.get("/api/v1/business/settings"));
-  }
-  async getLocations() {
-    return safe(this.client.get("/api/v1/business/locations"));
-  }
-  async getLocation(locationId) {
-    const result = await this.getLocations();
-    if (!result.ok) return err(result.error);
-    const location = result.value.find((item) => item.id === locationId);
-    if (!location) {
-      return err(new CimplifyError(ErrorCode.NOT_FOUND, `Location not found: ${locationId}`, false));
-    }
-    return ok(location);
-  }
-  async getHours() {
-    return safe(this.client.get("/api/v1/business/hours"));
-  }
-  async getLocationHours(locationId) {
-    const result = await this.getHours();
-    if (!result.ok) return result;
-    return ok(result.value.filter((hour) => hour.location_id === locationId));
-  }
-  async getBootstrap() {
-    return safe(this.client.get("/api/v1/bootstrap"));
-  }
-};
-
-// src/inventory.ts
-var InventoryService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  withQuery(path, params) {
-    const searchParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-      if (value === void 0) continue;
-      searchParams.set(key, String(value));
-    }
-    const query2 = searchParams.toString();
-    return query2 ? `${path}?${query2}` : path;
-  }
-  async getProductStock(productId, locationId) {
-    const encodedId = encodeURIComponent(productId);
-    const path = this.withQuery(`/api/v1/inventory/products/${encodedId}/stock`, {
-      location_id: locationId
-    });
-    return safe(this.client.get(path));
-  }
-  async getVariantStock(variantId, locationId) {
-    const encodedId = encodeURIComponent(variantId);
-    const path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/stock`, {
-      location_id: locationId
-    });
-    return safe(this.client.get(path));
-  }
-  async checkProductAvailability(productId, quantity, locationId) {
-    const encodedId = encodeURIComponent(productId);
-    const path = this.withQuery(`/api/v1/inventory/products/${encodedId}/availability`, {
-      quantity,
-      location_id: locationId
-    });
-    return safe(this.client.get(path));
-  }
-  async checkVariantAvailability(variantId, quantity, locationId) {
-    const encodedId = encodeURIComponent(variantId);
-    const path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/availability`, {
-      quantity,
-      location_id: locationId
-    });
-    return safe(this.client.get(path));
-  }
-  async checkMultipleAvailability(items, locationId) {
-    const results = await Promise.all(
-      items.map(
-        (item) => item.variant_id ? this.checkVariantAvailability(item.variant_id, item.quantity, locationId) : this.checkProductAvailability(item.product_id, item.quantity, locationId)
-      )
-    );
-    for (const result of results) {
-      if (!result.ok) return result;
-    }
-    return ok(results.map((r) => r.value));
-  }
-  async isInStock(productId, locationId) {
-    const result = await this.checkProductAvailability(productId, 1, locationId);
-    if (!result.ok) return result;
-    return ok(result.value.is_available);
-  }
-  async getAvailableQuantity(productId, locationId) {
-    const result = await this.getProductStock(productId, locationId);
-    if (!result.ok) return result;
-    return ok(result.value.available_quantity);
-  }
-};
-
-// src/scheduling.ts
-function withQuery2(path, params) {
-  const searchParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value === void 0) continue;
-    searchParams.set(key, String(value));
-  }
-  const query2 = searchParams.toString();
-  return query2 ? `${path}?${query2}` : path;
-}
-function firstScheduledTime(booking) {
-  return booking.service_items.find((item) => typeof item.scheduled_start === "string")?.scheduled_start || booking.created_at;
-}
-var SchedulingService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getServices() {
-    return safe(this.client.get("/api/v1/scheduling/services"));
-  }
-  async getService(serviceId) {
-    const encodedId = encodeURIComponent(serviceId);
-    return safe(this.client.get(`/api/v1/scheduling/services/${encodedId}`));
-  }
-  async getAvailableSlots(input) {
-    const path = withQuery2("/api/v1/scheduling/slots", {
-      service_id: input.service_id,
-      date: input.date,
-      participant_count: input.participant_count,
-      duration_minutes: input.duration_minutes
-    });
-    return safe(this.client.get(path));
-  }
-  async checkSlotAvailability(input) {
-    const path = withQuery2("/api/v1/scheduling/slots/check", {
-      service_id: input.service_id,
-      slot_time: input.slot_time,
-      duration_minutes: input.duration_minutes,
-      participant_count: input.participant_count
-    });
-    return safe(this.client.get(path));
-  }
-  async getServiceAvailability(params) {
-    const path = withQuery2("/api/v1/scheduling/availability", {
-      service_id: params.service_id,
-      start_date: params.start_date,
-      end_date: params.end_date,
-      location_id: params.location_id,
-      participant_count: params.participant_count
-    });
-    return safe(this.client.get(path));
-  }
-  async getBooking(bookingId) {
-    const encodedId = encodeURIComponent(bookingId);
-    return safe(this.client.get(`/api/v1/scheduling/bookings/${encodedId}`));
-  }
-  async getCustomerBookings(customerId) {
-    const path = withQuery2("/api/v1/scheduling/bookings", {
-      customer_id: customerId
-    });
-    return safe(this.client.get(path));
-  }
-  async getUpcomingBookings() {
-    const result = await this.getCustomerBookings();
-    if (!result.ok) return result;
-    const upcoming = result.value.filter((booking) => {
-      const status = String(booking.status).toLowerCase();
-      return status !== "completed" && status !== "cancelled";
-    }).sort((a, b) => firstScheduledTime(a).localeCompare(firstScheduledTime(b)));
-    return ok(upcoming);
-  }
-  async getPastBookings(limit = 10) {
-    const result = await this.getCustomerBookings();
-    if (!result.ok) return result;
-    const past = result.value.filter((booking) => String(booking.status).toLowerCase() === "completed").sort((a, b) => firstScheduledTime(b).localeCompare(firstScheduledTime(a))).slice(0, Math.max(0, limit));
-    return ok(past);
-  }
-  async cancelBooking(input) {
-    const encodedId = encodeURIComponent(input.booking_id);
-    return safe(
-      this.client.post(`/api/v1/scheduling/bookings/${encodedId}/cancel`, {
-        reason: input.reason
-      })
-    );
-  }
-  async rescheduleBooking(input) {
-    return safe(
-      this.client.post("/api/v1/scheduling/bookings/reschedule", input)
-    );
-  }
-  async getNextAvailableSlot(serviceId, fromDate) {
-    const date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const result = await this.getAvailableSlots({
-      service_id: serviceId,
-      date
-    });
-    if (!result.ok) return result;
-    return ok(result.value.find((slot) => slot.is_available) || null);
-  }
-  async hasAvailabilityOn(serviceId, date) {
-    const result = await this.getAvailableSlots({
-      service_id: serviceId,
-      date
-    });
-    if (!result.ok) return result;
-    return ok(result.value.some((slot) => slot.is_available));
-  }
-};
-
-// src/lite.ts
-var LiteService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getBootstrap() {
-    return safe(this.client.get("/api/v1/lite/bootstrap"));
-  }
-  async getTable(tableId) {
-    const encodedId = encodeURIComponent(tableId);
-    return safe(this.client.get(`/api/v1/lite/tables/${encodedId}`));
-  }
-  async getMenu() {
-    return safe(this.client.get("/api/v1/lite/menu"));
-  }
-  async getMenuByCategory(categoryId) {
-    const encodedId = encodeURIComponent(categoryId);
-    return safe(this.client.get(`/api/v1/lite/menu/categories/${encodedId}`));
-  }
-};
-
-// src/fx.ts
-var FxService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getRate(from, to) {
-    const path = `/api/v1/fx/rate?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`;
-    return safe(this.client.get(path));
-  }
-  async lockQuote(request) {
-    return safe(this.client.post("/api/v1/fx/quotes", request));
-  }
-};
-
-// src/activity.ts
-var ActivityService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  trackProductView(productId, options = {}) {
-    const event = {
-      type: "product_view",
-      product_id: productId,
-      product_name: options.productName,
-      category_id: options.categoryId,
-      price: options.price,
-      page_path: options.pagePath ?? currentPath()
-    };
-    this.sendEvents([event]);
-  }
-  trackCategoryView(categoryId, options = {}) {
-    const event = {
-      type: "category_view",
-      category_id: categoryId,
-      category_name: options.categoryName,
-      page_path: options.pagePath ?? currentPath()
-    };
-    this.sendEvents([event]);
-  }
-  sendEvents(events) {
-    try {
-      this.client.post("/api/v1/activity/events", { events }).catch(() => {
-      });
-    } catch {
-    }
-  }
-};
-function currentPath() {
-  if (typeof window !== "undefined") {
-    return window.location.pathname;
-  }
-  return void 0;
-}
-
-// src/types/elements.ts
-var ELEMENT_TYPES = {
-  AUTH: "auth",
-  ADDRESS: "address",
-  PAYMENT: "payment",
-  CHECKOUT: "checkout"
-};
-var MESSAGE_TYPES = {
-  INIT: "init",
-  SET_TOKEN: "set_token",
-  SET_CART: "set_cart",
-  GET_DATA: "get_data",
-  REFRESH_TOKEN: "refresh_token",
-  LOGOUT: "logout",
-  PROCESS_CHECKOUT: "process_checkout",
-  ABORT_CHECKOUT: "abort_checkout",
-  READY: "ready",
-  HEIGHT_CHANGE: "height_change",
-  AUTHENTICATED: "authenticated",
-  REQUIRES_OTP: "requires_otp",
-  ERROR: "error",
-  ADDRESS_CHANGED: "address_changed",
-  ADDRESS_SELECTED: "address_selected",
-  PAYMENT_METHOD_SELECTED: "payment_method_selected",
-  TOKEN_REFRESHED: "token_refreshed",
-  LOGOUT_COMPLETE: "logout_complete",
-  CONTACT_PROVIDED: "contact_provided",
-  CHECKOUT_STATUS: "checkout_status",
-  CHECKOUT_COMPLETE: "checkout_complete",
-  ORDER_TYPE_CHANGED: "order_type_changed",
-  REQUEST_SUBMIT: "request_submit"
-};
-var EVENT_TYPES = {
-  READY: "ready",
-  AUTHENTICATED: "authenticated",
-  REQUIRES_OTP: "requires_otp",
-  ERROR: "error",
-  CHANGE: "change",
-  BLUR: "blur",
-  FOCUS: "focus",
-  ORDER_TYPE_CHANGED: "order_type_changed",
-  REQUEST_SUBMIT: "request_submit"
-};
-
-// src/elements.ts
-function toCheckoutError(code, message, recoverable) {
-  const hint = getErrorHint(code);
-  return {
-    success: false,
-    error: {
-      code,
-      message,
-      recoverable,
-      docs_url: hint?.docs_url,
-      suggestion: hint?.suggestion
-    }
-  };
-}
-var DEFAULT_LINK_URL = "https://link.cimplify.io";
-function generateNonce() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID().replace(/-/g, "").slice(0, 16);
-  }
-  return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
-}
-function isAllowedOrigin(origin) {
-  try {
-    const url = new URL(origin);
-    const hostname = url.hostname;
-    if (hostname === "localhost" || hostname === "127.0.0.1") {
-      return true;
-    }
-    if (url.protocol !== "https:") {
-      return false;
-    }
-    return hostname === "cimplify.io" || hostname.endsWith(".cimplify.io");
-  } catch {
-    return false;
-  }
-}
-function parseIframeMessage(data) {
-  if (!data || typeof data !== "object") {
-    return null;
-  }
-  const maybeType = data.type;
-  if (typeof maybeType !== "string") {
-    return null;
-  }
-  return data;
-}
-var CimplifyElements = class {
-  constructor(client, businessId, options = {}) {
-    this.elements = /* @__PURE__ */ new Map();
-    this.accessToken = null;
-    this.accountId = null;
-    this.customerId = null;
-    this.customerData = null;
-    this.addressData = null;
-    this.paymentData = null;
-    this.checkoutInProgress = false;
-    this.activeCheckoutAbort = null;
-    this.businessIdResolvePromise = null;
-    this.client = client;
-    this.businessId = businessId ?? null;
-    this.linkUrl = options.linkUrl || DEFAULT_LINK_URL;
-    this.options = options;
-    this.boundHandleMessage = this.handleMessage.bind(this);
-    if (typeof window !== "undefined") {
-      window.addEventListener("message", this.boundHandleMessage);
-    }
-  }
-  debug(...args) {
-    if (this.client.isTestMode()) {
-      console.debug(...args);
-    }
-  }
-  create(type, options = {}) {
-    const existing = this.elements.get(type);
-    if (existing) return existing;
-    const element = new CimplifyElement(type, this.businessId, this.linkUrl, options, this);
-    this.elements.set(type, element);
-    return element;
-  }
-  getElement(type) {
-    return this.elements.get(type);
-  }
-  _removeElement(type, instance) {
-    const current = this.elements.get(type);
-    if (current === instance) {
-      this.elements.delete(type);
-    }
-  }
-  destroy() {
-    this.elements.forEach((element) => element.destroy());
-    this.elements.clear();
-    if (typeof window !== "undefined") {
-      window.removeEventListener("message", this.boundHandleMessage);
-    }
-  }
-  async submitCheckout(data) {
-    const result = await this.processCheckout({
-      cart_id: data.cart_id,
-      order_type: data.order_type ?? "delivery",
-      location_id: data.location_id,
-      notes: data.notes,
-      scheduled_time: data.scheduled_time,
-      tip_amount: data.tip_amount,
-      enroll_in_link: true
-    });
-    if (result.success) {
-      return {
-        success: true,
-        order: {
-          id: result.order?.id || "",
-          status: result.order?.status || "unknown",
-          total: result.order?.total || ""
-        }
-      };
-    }
-    return {
-      success: false,
-      error: {
-        code: result.error?.code || "CHECKOUT_FAILED",
-        message: result.error?.message || "Checkout failed"
-      }
-    };
-  }
-  processCheckout(options) {
-    let abortFn = null;
-    const task = (async () => {
-      this.debug("[cimplify:checkout] processCheckout called", { cart_id: options.cart_id, order_type: options.order_type, location_id: options.location_id });
-      if (this.checkoutInProgress) {
-        this.debug("[cimplify:checkout] BLOCKED: already processing");
-        return toCheckoutError(
-          "ALREADY_PROCESSING",
-          "Checkout is already in progress.",
-          false
-        );
-      }
-      this.checkoutInProgress = true;
-      if (!options.cart_id) {
-        this.debug("[cimplify:checkout] BLOCKED: no cart_id");
-        this.checkoutInProgress = false;
-        return toCheckoutError(
-          "INVALID_CART",
-          "A valid cart is required before checkout can start.",
-          false
-        );
-      }
-      if (!options.order_type) {
-        this.debug("[cimplify:checkout] BLOCKED: no order_type");
-        this.checkoutInProgress = false;
-        return toCheckoutError(
-          "ORDER_TYPE_REQUIRED",
-          "Order type is required before checkout can start.",
-          false
-        );
-      }
-      const checkoutElement = this.elements.get(ELEMENT_TYPES.CHECKOUT) || this.elements.get(ELEMENT_TYPES.PAYMENT);
-      if (!checkoutElement) {
-        this.debug("[cimplify:checkout] BLOCKED: no checkout element");
-        this.checkoutInProgress = false;
-        return toCheckoutError(
-          "NO_PAYMENT_ELEMENT",
-          "Checkout element must be mounted before checkout.",
-          false
-        );
-      }
-      if (!checkoutElement.isMounted()) {
-        this.debug("[cimplify:checkout] BLOCKED: checkout element not mounted");
-        this.checkoutInProgress = false;
-        return toCheckoutError(
-          "PAYMENT_NOT_MOUNTED",
-          "Checkout element must be mounted before checkout.",
-          false
-        );
-      }
-      const isUnifiedCheckout = this.elements.has(ELEMENT_TYPES.CHECKOUT);
-      if (!isUnifiedCheckout) {
-        const authElement = this.elements.get(ELEMENT_TYPES.AUTH);
-        if (authElement && !this.accessToken) {
-          this.debug("[cimplify:checkout] BLOCKED: auth incomplete");
-          this.checkoutInProgress = false;
-          return toCheckoutError(
-            "AUTH_INCOMPLETE",
-            "Authentication must complete before checkout can start.",
-            true
-          );
-        }
-        const addressElement = this.elements.get(ELEMENT_TYPES.ADDRESS);
-        if (addressElement) {
-          this.debug("[cimplify:checkout] getting address data...");
-          await addressElement.getData();
-          this.debug("[cimplify:checkout] address data resolved", this.addressData);
-        }
-        await this.hydrateCustomerData();
-      }
-      this.debug("[cimplify:checkout] customer data hydrated", { customerData: this.customerData, accountId: this.accountId, isUnifiedCheckout });
-      const processMessage = {
-        type: MESSAGE_TYPES.PROCESS_CHECKOUT,
-        cart_id: options.cart_id,
-        order_type: options.order_type,
-        location_id: options.location_id,
-        notes: options.notes,
-        scheduled_time: options.scheduled_time,
-        tip_amount: options.tip_amount,
-        pay_currency: options.pay_currency,
-        enroll_in_link: options.enroll_in_link ?? true,
-        address: isUnifiedCheckout ? void 0 : this.addressData ?? void 0,
-        customer: isUnifiedCheckout ? void 0 : this.customerData ? {
-          name: this.customerData.name,
-          email: this.customerData.email,
-          phone: this.customerData.phone
-        } : null,
-        account_id: this.accountId ?? void 0,
-        customer_id: this.customerId ?? void 0
-      };
-      const timeoutMs = options.timeout_ms ?? 18e4;
-      const paymentWindow = checkoutElement.getContentWindow();
-      return new Promise((resolve) => {
-        let settled = false;
-        const cleanup = () => {
-          if (typeof window !== "undefined") {
-            window.removeEventListener("message", handleCheckoutMessage);
-          }
-          clearTimeout(timeout);
-          this.checkoutInProgress = false;
-          this.activeCheckoutAbort = null;
-        };
-        const settle = (result) => {
-          if (settled) {
-            return;
-          }
-          settled = true;
-          cleanup();
-          resolve(result);
-        };
-        const timeout = setTimeout(() => {
-          settle(
-            toCheckoutError(
-              "TIMEOUT",
-              "Checkout timed out before receiving a terminal response.",
-              true
-            )
-          );
-        }, timeoutMs);
-        const handleCheckoutMessage = (event) => {
-          if (!isAllowedOrigin(event.origin)) {
-            return;
-          }
-          const message = parseIframeMessage(event.data);
-          if (!message) {
-            return;
-          }
-          if (message.type === MESSAGE_TYPES.LOGOUT_COMPLETE) {
-            checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
-            settle(
-              toCheckoutError(
-                "AUTH_LOST",
-                "Authentication was cleared during checkout.",
-                true
-              )
-            );
-            return;
-          }
-          if (paymentWindow && event.source && event.source !== paymentWindow) {
-            return;
-          }
-          if (message.type === MESSAGE_TYPES.CHECKOUT_STATUS) {
-            options.on_status_change?.(message.status, message.context);
-            return;
-          }
-          if (message.type === MESSAGE_TYPES.CHECKOUT_COMPLETE) {
-            this.debug("[cimplify:checkout] received checkout_complete", { success: message.success, error: message.error });
-            settle({
-              success: message.success,
-              order: message.order,
-              error: message.error,
-              enrolled_in_link: message.enrolled_in_link
-            });
-          }
-        };
-        if (typeof window !== "undefined") {
-          window.addEventListener("message", handleCheckoutMessage);
-        }
-        abortFn = () => {
-          checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
-          settle(
-            toCheckoutError(
-              "CANCELLED",
-              "Checkout was cancelled.",
-              true
-            )
-          );
-        };
-        this.activeCheckoutAbort = abortFn;
-        this.debug("[cimplify:checkout] sending process_checkout to checkout iframe", { cart_id: processMessage.cart_id, order_type: processMessage.order_type, hasCustomer: !!processMessage.customer, hasAddress: !!processMessage.address, isUnifiedCheckout });
-        checkoutElement.sendMessage(processMessage);
-        this.debug("[cimplify:checkout] postMessage sent, waiting for checkout_complete...");
-      });
-    })();
-    const abortable = task;
-    abortable.abort = () => {
-      if (abortFn) {
-        abortFn();
-      }
-    };
-    return abortable;
-  }
-  isAuthenticated() {
-    return this.accessToken !== null;
-  }
-  getAccessToken() {
-    return this.accessToken;
-  }
-  getPublicKey() {
-    return this.client.getPublicKey();
-  }
-  getBusinessId() {
-    return this.businessId;
-  }
-  async resolveBusinessId() {
-    if (this.businessId) {
-      return this.businessId;
-    }
-    if (this.businessIdResolvePromise) {
-      return this.businessIdResolvePromise;
-    }
-    this.businessIdResolvePromise = this.client.resolveBusinessId().then((resolvedBusinessId) => {
-      this.businessId = resolvedBusinessId;
-      return resolvedBusinessId;
-    }).catch(() => null).finally(() => {
-      this.businessIdResolvePromise = null;
-    });
-    return this.businessIdResolvePromise;
-  }
-  getAppearance() {
-    return this.options.appearance;
-  }
-  async hydrateCustomerData() {
-    if (!this.accessToken || this.customerData) {
-      return;
-    }
-    if (!this.client.getAccessToken()) {
-      this.client.setAccessToken(this.accessToken);
-    }
-    const linkDataResult = await this.client.link.getLinkData();
-    if (!linkDataResult.ok || !linkDataResult.value?.customer) {
-      return;
-    }
-    const customer = linkDataResult.value.customer;
-    this.customerData = {
-      name: customer.name || "",
-      email: customer.email || null,
-      phone: customer.phone || null
-    };
-  }
-  handleMessage(event) {
-    if (!isAllowedOrigin(event.origin)) {
-      return;
-    }
-    const message = parseIframeMessage(event.data);
-    if (!message) return;
-    switch (message.type) {
-      case MESSAGE_TYPES.AUTHENTICATED:
-        const customer = message.customer ?? {
-          name: "",
-          email: null,
-          phone: null
-        };
-        this.accessToken = message.token;
-        this.accountId = message.accountId;
-        this.customerId = message.customerId;
-        this.customerData = customer;
-        this.client.setAccessToken(message.token);
-        this.elements.forEach((element, type) => {
-          if (type !== ELEMENT_TYPES.AUTH && type !== ELEMENT_TYPES.CHECKOUT) {
-            element.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token: message.token });
-          }
-        });
-        break;
-      case MESSAGE_TYPES.TOKEN_REFRESHED:
-        this.accessToken = message.token;
-        break;
-      case MESSAGE_TYPES.ADDRESS_CHANGED:
-      case MESSAGE_TYPES.ADDRESS_SELECTED:
-        this.addressData = message.address;
-        break;
-      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
-        this.paymentData = message.method;
-        break;
-      case MESSAGE_TYPES.CONTACT_PROVIDED:
-        if (!this.customerData) {
-          this.customerData = { name: "", email: null, phone: null };
-        }
-        if (message.contactType === "email") {
-          this.customerData.email = message.contact;
-        } else {
-          this.customerData.phone = message.contact;
-        }
-        break;
-      case MESSAGE_TYPES.LOGOUT_COMPLETE:
-        if (this.checkoutInProgress && this.activeCheckoutAbort) {
-          this.activeCheckoutAbort();
-        }
-        this.accessToken = null;
-        this.accountId = null;
-        this.customerId = null;
-        this.customerData = null;
-        this.addressData = null;
-        this.paymentData = null;
-        this.client.clearSession();
-        break;
-    }
-  }
-  _setAddressData(data) {
-    this.addressData = data;
-  }
-  _setPaymentData(data) {
-    this.paymentData = data;
-  }
-  _setGuestContact(contact, contactType) {
-    if (!this.customerData) {
-      this.customerData = { name: "", email: null, phone: null };
-    }
-    if (contactType === "email") {
-      this.customerData.email = contact;
-    } else {
-      this.customerData.phone = contact;
-    }
-  }
-};
-var CimplifyElement = class {
-  constructor(type, businessId, linkUrl, options, parent) {
-    this.iframe = null;
-    this.container = null;
-    this.mounted = false;
-    this.pendingInit = null;
-    this.eventHandlers = /* @__PURE__ */ new Map();
-    this.resolvers = /* @__PURE__ */ new Map();
-    this.listening = false;
-    this.type = type;
-    this.businessId = businessId;
-    this.linkUrl = linkUrl;
-    this.options = options;
-    this.parent = parent;
-    this.nonce = generateNonce();
-    this.boundHandleMessage = this.handleMessage.bind(this);
-    if (typeof window !== "undefined") {
-      window.addEventListener("message", this.boundHandleMessage);
-      this.listening = true;
-    }
-  }
-  mount(container) {
-    if (this.mounted) {
-      console.warn(`Element ${this.type} is already mounted`);
-      return;
-    }
-    const target = typeof container === "string" ? document.querySelector(container) : container;
-    if (!target) {
-      console.error(`Container not found: ${container}`);
-      return;
-    }
-    this.container = target;
-    this.mounted = true;
-    if (!this.listening && typeof window !== "undefined") {
-      window.addEventListener("message", this.boundHandleMessage);
-      this.listening = true;
-    }
-    void this.createIframe();
-  }
-  destroy() {
-    if (this.iframe) {
-      this.iframe.remove();
-      this.iframe = null;
-    }
-    this.container = null;
-    this.mounted = false;
-    this.eventHandlers.clear();
-    this.resolvers.forEach((entry) => clearTimeout(entry.timeoutId));
-    this.resolvers.clear();
-    if (this.listening && typeof window !== "undefined") {
-      window.removeEventListener("message", this.boundHandleMessage);
-      this.listening = false;
-    }
-    this.parent._removeElement(this.type, this);
-  }
-  on(event, handler) {
-    if (!this.eventHandlers.has(event)) {
-      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.eventHandlers.get(event).add(handler);
-  }
-  off(event, handler) {
-    this.eventHandlers.get(event)?.delete(handler);
-  }
-  async getData() {
-    if (!this.isMounted()) {
-      return null;
-    }
-    return new Promise((resolve) => {
-      const id = Math.random().toString(36).slice(2);
-      const timeoutId = setTimeout(() => {
-        const entry = this.resolvers.get(id);
-        if (!entry) {
-          return;
-        }
-        this.resolvers.delete(id);
-        entry.resolve(null);
-      }, 5e3);
-      this.resolvers.set(id, { resolve, timeoutId });
-      this.sendMessage({ type: MESSAGE_TYPES.GET_DATA });
-    });
-  }
-  setCart(cart) {
-    this.sendMessage({ type: MESSAGE_TYPES.SET_CART, cart });
-  }
-  sendMessage(message) {
-    if (this.iframe?.contentWindow) {
-      this.iframe.contentWindow.postMessage(message, this.linkUrl);
-    } else {
-      console.warn("[cimplify:checkout] sendMessage DROPPED \u2014 no contentWindow", { type: message.type, hasIframe: !!this.iframe, isConnected: this.iframe?.isConnected });
-    }
-  }
-  getContentWindow() {
-    return this.iframe?.contentWindow ?? null;
-  }
-  isMounted() {
-    return this.mounted && Boolean(this.iframe) && this.iframe?.isConnected === true;
-  }
-  async createIframe() {
-    if (!this.container) return;
-    const resolvedBusinessId = this.businessId ?? await this.parent.resolveBusinessId();
-    if (!resolvedBusinessId || !this.container || !this.mounted) {
-      console.error("Unable to mount element without a resolved business ID");
-      this.emit(EVENT_TYPES.ERROR, {
-        code: "BUSINESS_ID_REQUIRED",
-        message: "Unable to initialize checkout without a business ID."
-      });
-      return;
-    }
-    this.businessId = resolvedBusinessId;
-    const iframe = document.createElement("iframe");
-    const url = new URL(`${this.linkUrl}/elements/${this.type}`);
-    url.searchParams.set("businessId", resolvedBusinessId);
-    url.searchParams.set("nonce", this.nonce);
-    if (this.options.prefillEmail) url.searchParams.set("email", this.options.prefillEmail);
-    if (this.options.mode) url.searchParams.set("mode", this.options.mode);
-    iframe.src = url.toString();
-    iframe.style.border = "none";
-    iframe.style.width = "100%";
-    iframe.style.minHeight = "200px";
-    iframe.style.display = "block";
-    iframe.style.overflow = "hidden";
-    iframe.style.background = "transparent";
-    iframe.setAttribute("allowtransparency", "true");
-    iframe.setAttribute("frameborder", "0");
-    iframe.setAttribute("allow", "geolocation");
-    iframe.setAttribute(
-      "sandbox",
-      "allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox"
-    );
-    this.iframe = iframe;
-    this.container.appendChild(iframe);
-    this.pendingInit = {
-      businessId: resolvedBusinessId,
-      publicKey: this.parent.getPublicKey()
-    };
-  }
-  handleMessage(event) {
-    if (!isAllowedOrigin(event.origin)) {
-      return;
-    }
-    const data = event.data;
-    if (data?.nonce) {
-      if (data.nonce !== this.nonce) return;
-    } else {
-      const iframeWindow = this.iframe?.contentWindow;
-      if (iframeWindow && event.source && event.source !== iframeWindow) {
-        return;
-      }
-    }
-    const message = parseIframeMessage(event.data);
-    if (!message) return;
-    switch (message.type) {
-      case MESSAGE_TYPES.READY:
-        if (this.iframe && message.height) this.iframe.style.height = `${message.height}px`;
-        if (this.pendingInit) {
-          const { publicKey } = this.pendingInit;
-          this.sendMessage({
-            type: MESSAGE_TYPES.INIT,
-            businessId: this.pendingInit.businessId,
-            publicKey,
-            demoMode: publicKey.length === 0,
-            prefillEmail: this.options.prefillEmail,
-            appearance: this.parent.getAppearance(),
-            orderTypes: this.options.orderTypes,
-            defaultOrderType: this.options.defaultOrderType,
-            renderSubmitButton: true,
-            submitLabel: this.options.submitLabel
-          });
-          const token = this.parent.getAccessToken();
-          if (token && this.type !== ELEMENT_TYPES.AUTH) {
-            this.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token });
-          }
-          this.pendingInit = null;
-        }
-        this.emit(EVENT_TYPES.READY, { height: message.height });
-        break;
-      case MESSAGE_TYPES.HEIGHT_CHANGE:
-        if (this.iframe) this.iframe.style.height = `${message.height}px`;
-        break;
-      case MESSAGE_TYPES.AUTHENTICATED:
-        const customer = message.customer ?? {
-          name: "",
-          email: null,
-          phone: null
-        };
-        this.emit(EVENT_TYPES.AUTHENTICATED, {
-          accountId: message.accountId,
-          customerId: message.customerId,
-          token: message.token,
-          customer
-        });
-        break;
-      case MESSAGE_TYPES.REQUIRES_OTP:
-        this.emit(EVENT_TYPES.REQUIRES_OTP, { contactMasked: message.contactMasked });
-        break;
-      case MESSAGE_TYPES.ERROR:
-        this.emit(EVENT_TYPES.ERROR, { code: message.code, message: message.message });
-        break;
-      case MESSAGE_TYPES.ADDRESS_CHANGED:
-      case MESSAGE_TYPES.ADDRESS_SELECTED:
-        this.parent._setAddressData(message.address);
-        this.emit(EVENT_TYPES.CHANGE, { address: message.address });
-        this.resolveData(message.address);
-        break;
-      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
-        this.parent._setPaymentData(message.method);
-        this.emit(EVENT_TYPES.CHANGE, { paymentMethod: message.method });
-        this.resolveData(message.method);
-        break;
-      case MESSAGE_TYPES.CONTACT_PROVIDED:
-        this.parent._setGuestContact(message.contact, message.contactType);
-        break;
-      case MESSAGE_TYPES.ORDER_TYPE_CHANGED:
-        this.emit(EVENT_TYPES.ORDER_TYPE_CHANGED, { orderType: message.orderType });
-        break;
-      case MESSAGE_TYPES.REQUEST_SUBMIT:
-        this.emit(EVENT_TYPES.REQUEST_SUBMIT, {});
-        break;
-    }
-  }
-  emit(event, data) {
-    this.eventHandlers.get(event)?.forEach((handler) => handler(data));
-  }
-  resolveData(data) {
-    this.resolvers.forEach((entry) => {
-      clearTimeout(entry.timeoutId);
-      entry.resolve(data);
-    });
-    this.resolvers.clear();
-  }
-};
-function createElements(client, businessId, options) {
-  return new CimplifyElements(client, businessId, options);
-}
-
-// src/client.ts
-var ACCESS_TOKEN_STORAGE_KEY = "cimplify_access_token";
-var SESSION_TOKEN_STORAGE_KEY = "cimplify_session_token";
-var ORDER_TOKEN_PREFIX = "cimplify_ot_";
-var SESSION_TOKEN_HEADER = "x-session-token";
-var ORDER_TOKEN_TTL_MS = 24 * 60 * 60 * 1e3;
-var DEFAULT_TIMEOUT_MS = 3e4;
-var DEFAULT_MAX_RETRIES = 3;
-var DEFAULT_RETRY_DELAY_MS = 1e3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isRetryable(error) {
-  if (error instanceof TypeError && error.message.includes("fetch")) {
-    return true;
-  }
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return true;
-  }
-  if (error instanceof CimplifyError) {
-    return error.retryable;
-  }
-  return false;
-}
-function toNetworkError(error, isTestMode) {
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return enrichError(
-      new CimplifyError(
-        ErrorCode.TIMEOUT,
-        "Request timed out. Please check your connection and try again.",
-        true
-      ),
-      { isTestMode }
-    );
-  }
-  if (error instanceof TypeError && error.message.includes("fetch")) {
-    return enrichError(
-      new CimplifyError(
-        ErrorCode.NETWORK_ERROR,
-        "Network error. Please check your internet connection.",
-        true
-      ),
-      { isTestMode }
-    );
-  }
-  if (error instanceof CimplifyError) {
-    return enrichError(error, { isTestMode });
-  }
-  return enrichError(
-    new CimplifyError(
-      ErrorCode.UNKNOWN_ERROR,
-      error instanceof Error ? error.message : "An unknown error occurred",
-      false
-    ),
-    { isTestMode }
-  );
-}
-function deriveUrls() {
-  const hostname = typeof window !== "undefined" ? window.location.hostname : "";
-  if (hostname === "localhost" || hostname === "127.0.0.1") {
-    const protocol = window.location.protocol;
-    return {
-      baseUrl: `${protocol}//${hostname}:8082`,
-      linkApiUrl: `${protocol}//${hostname}:8080`
-    };
-  }
-  return {
-    baseUrl: "https://storefronts.cimplify.io",
-    linkApiUrl: "https://api.cimplify.io"
-  };
-}
-function normalizeUrl(url) {
-  const trimmed = url.trim();
-  if (!trimmed) return trimmed;
-  return trimmed.replace(/\/+$/, "");
-}
-function getEnvPublicKey() {
-  try {
-    const env = globalThis.process;
-    return env?.env.NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY || void 0;
-  } catch {
-    return void 0;
-  }
-}
-var CimplifyClient = class {
-  constructor(config = {}) {
-    this.accessToken = null;
-    this.sessionToken = null;
-    this.context = {};
-    this.businessId = null;
-    this.businessIdResolvePromise = null;
-    this.inflightRequests = /* @__PURE__ */ new Map();
-    this.publicKey = config.publicKey || getEnvPublicKey() || "";
-    const urls = deriveUrls();
-    this.baseUrl = config.baseUrl ? normalizeUrl(config.baseUrl) : urls.baseUrl;
-    this.linkApiUrl = config.linkApiUrl ? normalizeUrl(config.linkApiUrl) : urls.linkApiUrl;
-    this.credentials = config.credentials || "include";
-    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
-    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
-    this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
-    this.hooks = config.hooks ?? {};
-    this.accessToken = this.loadAccessToken();
-    this.sessionToken = this.loadSessionToken();
-    if (!this.publicKey && !config.suppressPublicKeyWarning) {
-      console.warn(
-        '[Cimplify] No public key found. Set NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY in your environment, or pass { publicKey: "pk_..." } to createCimplifyClient().'
-      );
-    }
-  }
-  buildUrl(base, path) {
-    const url = `${base}${path}`;
-    const locationId = this.context.location_id;
-    if (!locationId) return url;
-    const separator = url.includes("?") ? "&" : "?";
-    return `${url}${separator}location_id=${encodeURIComponent(locationId)}`;
-  }
-  getAccessToken() {
-    return this.accessToken;
-  }
-  getPublicKey() {
-    return this.publicKey;
-  }
-  isTestMode() {
-    return this.publicKey.trim().startsWith("pk_test_");
-  }
-  setAccessToken(token) {
-    const previous = this.accessToken;
-    this.accessToken = token;
-    this.saveAccessToken(token);
-    this.hooks.onSessionChange?.({
-      previousToken: previous,
-      newToken: token,
-      source: "manual"
-    });
-  }
-  clearSession() {
-    const previous = this.accessToken;
-    this.accessToken = null;
-    this.sessionToken = null;
-    this.saveAccessToken(null);
-    if (typeof window !== "undefined" && window.localStorage) {
-      localStorage.removeItem(SESSION_TOKEN_STORAGE_KEY);
-    }
-    this.hooks.onSessionChange?.({
-      previousToken: previous,
-      newToken: null,
-      source: "clear"
-    });
-  }
-  setOrderToken(orderId, token) {
-    if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        const entry = JSON.stringify({ token, storedAt: Date.now() });
-        localStorage.setItem(`${ORDER_TOKEN_PREFIX}${orderId}`, entry);
-      } catch {
-      }
-    }
-  }
-  getOrderToken(orderId) {
-    if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        const raw = localStorage.getItem(`${ORDER_TOKEN_PREFIX}${orderId}`);
-        if (!raw) return null;
-        const entry = JSON.parse(raw);
-        if (Date.now() - entry.storedAt > ORDER_TOKEN_TTL_MS) {
-          localStorage.removeItem(`${ORDER_TOKEN_PREFIX}${orderId}`);
-          return null;
-        }
-        return entry.token;
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-  clearOrderTokens() {
-    if (typeof window !== "undefined" && window.localStorage) {
-      const keysToRemove = [];
-      for (let i = 0; i < localStorage.length; i++) {
-        const key = localStorage.key(i);
-        if (key?.startsWith(ORDER_TOKEN_PREFIX)) {
-          keysToRemove.push(key);
-        }
-      }
-      keysToRemove.forEach((k) => localStorage.removeItem(k));
-    }
-  }
-  setLocationId(locationId) {
-    if (locationId) {
-      this.context.location_id = locationId;
-    } else {
-      delete this.context.location_id;
-    }
-  }
-  getLocationId() {
-    return this.context.location_id ?? null;
-  }
-  setBusinessId(businessId) {
-    const normalized = businessId.trim();
-    if (!normalized) {
-      return;
-    }
-    this.businessId = normalized;
-  }
-  getBusinessId() {
-    return this.businessId;
-  }
-  async resolveBusinessId() {
-    if (this.businessId) {
-      return this.businessId;
-    }
-    if (this.businessIdResolvePromise) {
-      return this.businessIdResolvePromise;
-    }
-    this.businessIdResolvePromise = (async () => {
-      const result = await this.business.getInfo();
-      if (!result.ok || !result.value?.id) {
-        throw new CimplifyError(
-          ErrorCode.NOT_FOUND,
-          "Unable to resolve business ID from the current public key.",
-          true
-        );
-      }
-      this.businessId = result.value.id;
-      return result.value.id;
-    })();
-    try {
-      return await this.businessIdResolvePromise;
-    } finally {
-      this.businessIdResolvePromise = null;
-    }
-  }
-  loadAccessToken() {
-    if (typeof window !== "undefined" && window.localStorage) {
-      return localStorage.getItem(ACCESS_TOKEN_STORAGE_KEY);
-    }
-    return null;
-  }
-  saveAccessToken(token) {
-    if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        if (token) {
-          localStorage.setItem(ACCESS_TOKEN_STORAGE_KEY, token);
-        } else {
-          localStorage.removeItem(ACCESS_TOKEN_STORAGE_KEY);
-        }
-      } catch {
-      }
-    }
-  }
-  loadSessionToken() {
-    if (typeof window !== "undefined" && window.localStorage) {
-      return localStorage.getItem(SESSION_TOKEN_STORAGE_KEY);
-    }
-    return null;
-  }
-  saveSessionToken(token) {
-    if (typeof window !== "undefined" && window.localStorage) {
-      try {
-        localStorage.setItem(SESSION_TOKEN_STORAGE_KEY, token);
-      } catch {
-      }
-    }
-  }
-  captureSessionToken(response) {
-    const token = response.headers.get(SESSION_TOKEN_HEADER);
-    if (token && token !== this.sessionToken) {
-      this.sessionToken = token;
-      this.saveSessionToken(token);
-    }
-  }
-  getHeaders() {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    const trimmedPublicKey = this.publicKey.trim();
-    if (trimmedPublicKey) {
-      headers["X-API-Key"] = trimmedPublicKey;
-    }
-    if (this.accessToken) {
-      headers["Authorization"] = `Bearer ${this.accessToken}`;
-    }
-    if (this.sessionToken) {
-      headers[SESSION_TOKEN_HEADER] = this.sessionToken;
-    }
-    return headers;
-  }
-  async resilientFetch(url, options) {
-    const method = options.method || "GET";
-    const path = url.replace(this.baseUrl, "").replace(this.linkApiUrl, "");
-    const startTime = Date.now();
-    let retryCount = 0;
-    const context = {
-      method,
-      path,
-      url,
-      body: options.body ? JSON.parse(options.body) : void 0,
-      startTime
-    };
-    this.hooks.onRequestStart?.(context);
-    let lastError;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        const response = await fetch(url, {
-          ...options,
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
-        this.captureSessionToken(response);
-        if (response.ok) {
-          this.hooks.onRequestSuccess?.({
-            ...context,
-            status: response.status,
-            durationMs: Date.now() - startTime
-          });
-          return response;
-        }
-        if (response.status === 429 && attempt < this.maxRetries) {
-          retryCount++;
-          const retryAfter = response.headers.get("Retry-After");
-          const delay = retryAfter ? Math.min(parseInt(retryAfter, 10) * 1e3, 3e4) || this.retryDelay * Math.pow(2, attempt) : this.retryDelay * Math.pow(2, attempt);
-          this.hooks.onRetry?.({
-            ...context,
-            attempt: retryCount,
-            delayMs: delay,
-            error: new Error(`Rate limited: ${response.status}`)
-          });
-          await sleep(delay);
-          continue;
-        }
-        if (response.status >= 400 && response.status < 500) {
-          this.hooks.onRequestError?.({
-            ...context,
-            error: new CimplifyError(
-              `HTTP_${response.status}`,
-              `Request failed with status ${response.status}`,
-              false
-            ),
-            status: response.status,
-            durationMs: Date.now() - startTime,
-            retryCount,
-            retryable: false
-          });
-          return response;
-        }
-        if (response.status >= 500 && attempt < this.maxRetries) {
-          retryCount++;
-          const delay = this.retryDelay * Math.pow(2, attempt);
-          this.hooks.onRetry?.({
-            ...context,
-            attempt: retryCount,
-            delayMs: delay,
-            error: new Error(`Server error: ${response.status}`)
-          });
-          await sleep(delay);
-          continue;
-        }
-        this.hooks.onRequestError?.({
-          ...context,
-          error: new CimplifyError(
-            "SERVER_ERROR",
-            `Server error ${response.status} after ${retryCount} retries`,
-            false
-          ),
-          status: response.status,
-          durationMs: Date.now() - startTime,
-          retryCount,
-          retryable: false
-        });
-        return response;
-      } catch (error) {
-        lastError = error;
-        const networkError = toNetworkError(error, this.isTestMode());
-        const errorRetryable = isRetryable(error);
-        if (!errorRetryable || attempt >= this.maxRetries) {
-          this.hooks.onRequestError?.({
-            ...context,
-            error: networkError,
-            durationMs: Date.now() - startTime,
-            retryCount,
-            retryable: errorRetryable
-          });
-          throw networkError;
-        }
-        retryCount++;
-        const delay = this.retryDelay * Math.pow(2, attempt);
-        this.hooks.onRetry?.({
-          ...context,
-          attempt: retryCount,
-          delayMs: delay,
-          error: networkError
-        });
-        await sleep(delay);
-      }
-    }
-    const finalError = toNetworkError(lastError, this.isTestMode());
-    this.hooks.onRequestError?.({
-      ...context,
-      error: finalError,
-      durationMs: Date.now() - startTime,
-      retryCount,
-      retryable: false
-    });
-    throw finalError;
-  }
-  getDedupeKey(type, payload) {
-    return `${type}:${JSON.stringify(payload)}`;
-  }
-  async deduplicatedRequest(key, requestFn) {
-    const existing = this.inflightRequests.get(key);
-    if (existing) {
-      return existing;
-    }
-    const request = requestFn().finally(() => {
-      this.inflightRequests.delete(key);
-    });
-    this.inflightRequests.set(key, request);
-    return request;
-  }
-  async get(path) {
-    const key = this.getDedupeKey("get", path);
-    return this.deduplicatedRequest(key, async () => {
-      const response = await this.resilientFetch(this.buildUrl(this.baseUrl, path), {
-        method: "GET",
-        credentials: this.credentials,
-        headers: this.getHeaders()
-      });
-      return this.handleRestResponse(response);
-    });
-  }
-  async post(path, body) {
-    const response = await this.resilientFetch(this.buildUrl(this.baseUrl, path), {
-      method: "POST",
-      credentials: this.credentials,
-      headers: this.getHeaders(),
-      body: body ? JSON.stringify(body) : void 0
-    });
-    return this.handleRestResponse(response);
-  }
-  async patch(path, body) {
-    const response = await this.resilientFetch(this.buildUrl(this.baseUrl, path), {
-      method: "PATCH",
-      credentials: this.credentials,
-      headers: this.getHeaders(),
-      body: body ? JSON.stringify(body) : void 0
-    });
-    return this.handleRestResponse(response);
-  }
-  async delete(path) {
-    const response = await this.resilientFetch(this.buildUrl(this.baseUrl, path), {
-      method: "DELETE",
-      credentials: this.credentials,
-      headers: this.getHeaders()
-    });
-    return this.handleRestResponse(response);
-  }
-  async linkGet(path) {
-    const key = this.getDedupeKey("linkGet", path);
-    return this.deduplicatedRequest(key, async () => {
-      const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
-        method: "GET",
-        credentials: this.credentials,
-        headers: this.getHeaders()
-      });
-      return this.handleRestResponse(response);
-    });
-  }
-  async linkPost(path, body) {
-    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
-      method: "POST",
-      credentials: this.credentials,
-      headers: this.getHeaders(),
-      body: body ? JSON.stringify(body) : void 0
-    });
-    return this.handleRestResponse(response);
-  }
-  async linkDelete(path) {
-    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
-      method: "DELETE",
-      credentials: this.credentials,
-      headers: this.getHeaders()
-    });
-    return this.handleRestResponse(response);
-  }
-  async handleRestResponse(response) {
-    const json = await response.json();
-    if (!response.ok) {
-      const errorCode = typeof json.error === "object" && json.error?.error_code || typeof json.error === "object" && json.error?.code || "API_ERROR";
-      const errorMessage = typeof json.error === "object" && json.error?.error_message || typeof json.error === "object" && json.error?.message || typeof json.error === "string" && json.error || typeof json.message === "string" && json.message || "An error occurred";
-      const retryable = typeof json.error === "object" && typeof json.error?.retryable === "boolean" ? json.error.retryable : false;
-      const error = enrichError(
-        new CimplifyError(
-          errorCode,
-          errorMessage,
-          retryable
-        ),
-        { isTestMode: this.isTestMode() }
-      );
-      if (response.status === 401 || error.code === ErrorCode.UNAUTHORIZED) {
-        console.warn(
-          "[Cimplify] Received 401 Unauthorized. Access token may be missing/expired. Refresh authentication and retry the request."
-        );
-      }
-      throw error;
-    }
-    if (json?.success === false || json?.error?.code || json?.error?.message) {
-      const error = enrichError(
-        new CimplifyError(
-          json.error?.code || "API_ERROR",
-          json.error?.message || "An error occurred",
-          json.error?.retryable || false
-        ),
-        { isTestMode: this.isTestMode() }
-      );
-      throw error;
-    }
-    if (json?.data !== void 0) {
-      return json.data;
-    }
-    return json;
-  }
-  get catalogue() {
-    if (!this._catalogue) {
-      this._catalogue = new CatalogueQueries(this);
-    }
-    return this._catalogue;
-  }
-  get cart() {
-    if (!this._cart) {
-      this._cart = new CartOperations(this);
-    }
-    return this._cart;
-  }
-  get checkout() {
-    if (!this._checkout) {
-      this._checkout = new CheckoutService(this);
-    }
-    return this._checkout;
-  }
-  get orders() {
-    if (!this._orders) {
-      this._orders = new OrderQueries(this);
-    }
-    return this._orders;
-  }
-  get link() {
-    if (!this._link) {
-      this._link = new LinkService(this);
-    }
-    return this._link;
-  }
-  get auth() {
-    if (!this._auth) {
-      this._auth = new AuthService(this);
-    }
-    return this._auth;
-  }
-  get business() {
-    if (!this._business) {
-      this._business = new BusinessService(this);
-    }
-    return this._business;
-  }
-  get inventory() {
-    if (!this._inventory) {
-      this._inventory = new InventoryService(this);
-    }
-    return this._inventory;
-  }
-  get scheduling() {
-    if (!this._scheduling) {
-      this._scheduling = new SchedulingService(this);
-    }
-    return this._scheduling;
-  }
-  get lite() {
-    if (!this._lite) {
-      this._lite = new LiteService(this);
-    }
-    return this._lite;
-  }
-  get fx() {
-    if (!this._fx) {
-      this._fx = new FxService(this);
-    }
-    return this._fx;
-  }
-  get activity() {
-    if (!this._activity) {
-      this._activity = new ActivityService(this);
-    }
-    return this._activity;
-  }
-  elements(businessId, options) {
-    if (businessId) {
-      this.setBusinessId(businessId);
-    }
-    return createElements(this, businessId ?? this.businessId ?? void 0, options);
-  }
-};
-function createCimplifyClient(config = {}) {
-  return new CimplifyClient(config);
-}
-
-// src/query/builder.ts
-function escapeQueryValue(value) {
-  return value.replace(/'/g, "\\'");
-}
-var QueryBuilder = class {
-  constructor(entity) {
-    this.filters = [];
-    this.modifiers = [];
-    this.pathSegments = [];
-    this.entity = entity;
-  }
-  path(segment) {
-    this.pathSegments.push(segment);
-    return this;
-  }
-  where(field, op, value) {
-    const v = typeof value === "string" ? `'${escapeQueryValue(value)}'` : value;
-    if (op === "contains" || op === "startsWith") {
-      this.filters.push(`@.${field} ${op} ${v}`);
-    } else {
-      this.filters.push(`@.${field}${op}${v}`);
-    }
-    return this;
-  }
-  and(field, op, value) {
-    return this.where(field, op, value);
-  }
-  sort(field, order = "asc") {
-    this.modifiers.push(`sort(${field},${order})`);
-    return this;
-  }
-  limit(n) {
-    this.modifiers.push(`limit(${n})`);
-    return this;
-  }
-  offset(n) {
-    this.modifiers.push(`offset(${n})`);
-    return this;
-  }
-  count() {
-    this.modifiers.push("count");
-    return this;
-  }
-  enriched() {
-    this.modifiers.push("enriched");
-    return this;
-  }
-  build() {
-    let query2 = this.entity;
-    if (this.pathSegments.length > 0) {
-      query2 += "." + this.pathSegments.join(".");
-    }
-    if (this.filters.length > 0) {
-      query2 += `[?(${this.filters.join(" && ")})]`;
-    }
-    for (const mod of this.modifiers) {
-      query2 += `#${mod}`;
-    }
-    return query2;
-  }
-  toString() {
-    return this.build();
-  }
-};
-function query(entity) {
-  return new QueryBuilder(entity);
-}
-
-// src/utils/variant.ts
-function stripProductPrefix(variantName, productName) {
-  if (!variantName || !productName) return variantName || productName;
-  const lower = variantName.toLowerCase().trim();
-  if (lower === "default" || lower === "standard") return productName;
-  if (lower.endsWith("-default") || lower.endsWith("-standard")) return productName;
-  if (variantName.startsWith(productName)) {
-    const rest = variantName.slice(productName.length);
-    const match = rest.match(/^\s*[-–—]\s*(.*)/);
-    if (match && match[1].length > 0) return match[1];
-  }
-  const lowerProduct = productName.toLowerCase().trim();
-  if (lower.startsWith(lowerProduct)) {
-    const rest = variantName.slice(productName.length);
-    const match = rest.match(/^\s*[-–—]\s*(.*)/);
-    if (match && match[1].length > 0) return match[1];
-  }
-  const lastDash = variantName.lastIndexOf("-");
-  if (lastDash > 0 && lastDash < variantName.length - 1) {
-    const prefix = variantName.slice(0, lastDash).trim();
-    const suffix = variantName.slice(lastDash + 1).trim();
-    if (suffix.length > 0 && prefix.length > suffix.length * 2) {
-      return suffix;
-    }
-  }
-  return variantName;
-}
-function getVariantDisplayName(variant, productName) {
-  if (variant.display_attributes?.length) {
-    return variant.display_attributes.map((a) => a.value_name).join(" / ");
-  }
-  if (variant.name) {
-    return productName ? stripProductPrefix(variant.name, productName) : variant.name;
-  }
-  return productName || (variant.is_default ? "Default" : "Option");
-}
-var ISO3_TO_COUNTRY_CODE = {
-  AGO: "AO",
-  ARE: "AE",
-  AUS: "AU",
-  BDI: "BI",
-  BRA: "BR",
-  BWA: "BW",
-  CAN: "CA",
-  CHE: "CH",
-  CHN: "CN",
-  COD: "CD",
-  EGY: "EG",
-  ETH: "ET",
-  GHA: "GH",
-  GIN: "GN",
-  GMB: "GM",
-  GBR: "GB",
-  HKG: "HK",
-  IDN: "ID",
-  IND: "IN",
-  ISR: "IL",
-  JPN: "JP",
-  KEN: "KE",
-  KOR: "KR",
-  LBR: "LR",
-  MUS: "MU",
-  MEX: "MX",
-  MOZ: "MZ",
-  MWI: "MW",
-  MYS: "MY",
-  NAM: "NA",
-  NGA: "NG",
-  PHL: "PH",
-  RWA: "RW",
-  SAU: "SA",
-  SGP: "SG",
-  SLE: "SL",
-  THA: "TH",
-  TUR: "TR",
-  TWN: "TW",
-  TZA: "TZ",
-  UGA: "UG",
-  USA: "US",
-  VNM: "VN",
-  ZAF: "ZA",
-  ZMB: "ZM"
-};
-var CURRENCY_TO_COUNTRY_CODE = {
-  AED: "AE",
-  AOA: "AO",
-  AUD: "AU",
-  BIF: "BI",
-  BWP: "BW",
-  BRL: "BR",
-  CAD: "CA",
-  CDF: "CD",
-  CHF: "CH",
-  CNY: "CN",
-  EGP: "EG",
-  ETB: "ET",
-  GHS: "GH",
-  GMD: "GM",
-  GNF: "GN",
-  GBP: "GB",
-  HKD: "HK",
-  IDR: "ID",
-  ILS: "IL",
-  INR: "IN",
-  JPY: "JP",
-  KES: "KE",
-  KRW: "KR",
-  LRD: "LR",
-  MUR: "MU",
-  MWK: "MW",
-  MXN: "MX",
-  MYR: "MY",
-  MZN: "MZ",
-  NAD: "NA",
-  NGN: "NG",
-  PHP: "PH",
-  RWF: "RW",
-  SAR: "SA",
-  SGD: "SG",
-  SLL: "SL",
-  THB: "TH",
-  TRY: "TR",
-  TWD: "TW",
-  TZS: "TZ",
-  UGX: "UG",
-  USD: "US",
-  VND: "VN",
-  ZAR: "ZA",
-  ZMW: "ZM"
-};
-function normalizeCountryCode(value) {
-  const normalized = value?.trim().toUpperCase();
-  if (!normalized) {
-    return void 0;
-  }
-  if (normalized.length === 2) {
-    return normalized;
-  }
-  return ISO3_TO_COUNTRY_CODE[normalized];
-}
-function parsePhoneCandidate(value, country) {
-  try {
-    return country ? libphonenumberJs.parsePhoneNumberFromString(value, country) : libphonenumberJs.parsePhoneNumberFromString(value);
-  } catch {
-    return void 0;
-  }
-}
-function resolvePhoneCountryCode(options = {}) {
-  const explicitCountry = normalizeCountryCode(options.country);
-  if (explicitCountry) {
-    return explicitCountry;
-  }
-  const currency = options.currency?.trim().toUpperCase();
-  if (!currency) {
-    return void 0;
-  }
-  return CURRENCY_TO_COUNTRY_CODE[currency];
-}
-function normalizePhoneToE164(raw, options = {}) {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return null;
-  }
-  const country = resolvePhoneCountryCode(options);
-  const digits = trimmed.replace(/\D/g, "");
-  const internationalDigits = digits.startsWith("00") ? digits.slice(2) : digits;
-  const attempts = [];
-  const seen = /* @__PURE__ */ new Set();
-  function addAttempt(value, nextCountry) {
-    const key = `${nextCountry || ""}:${value}`;
-    if (seen.has(key)) {
-      return;
-    }
-    seen.add(key);
-    attempts.push({ value, country: nextCountry });
-  }
-  if (country) {
-    addAttempt(trimmed, country);
-  }
-  addAttempt(trimmed);
-  if (country && digits) {
-    addAttempt(digits, country);
-  }
-  if (internationalDigits) {
-    addAttempt(`+${internationalDigits}`);
-  }
-  for (const attempt of attempts) {
-    const parsed = parsePhoneCandidate(attempt.value, attempt.country);
-    if (parsed?.isValid()) {
-      return parsed.format("E.164");
-    }
-  }
-  return null;
-}
-function isValidPhoneForContext(raw, options = {}) {
-  return normalizePhoneToE164(raw, options) !== null;
-}
-
-exports.AUTHORIZATION_TYPE = AUTHORIZATION_TYPE;
-exports.AUTH_MUTATION = AUTH_MUTATION;
-exports.ActivityService = ActivityService;
-exports.AuthService = AuthService;
-exports.BusinessService = BusinessService;
-exports.CHECKOUT_MODE = CHECKOUT_MODE;
-exports.CHECKOUT_MUTATION = CHECKOUT_MUTATION;
-exports.CHECKOUT_STEP = CHECKOUT_STEP;
-exports.CONTACT_TYPE = CONTACT_TYPE;
-exports.CURRENCY_SYMBOLS = CURRENCY_SYMBOLS;
-exports.CartOperations = CartOperations;
-exports.CatalogueQueries = CatalogueQueries;
-exports.CheckoutOperations = CheckoutService;
-exports.CheckoutService = CheckoutService;
-exports.CimplifyClient = CimplifyClient;
-exports.CimplifyElement = CimplifyElement;
-exports.CimplifyElements = CimplifyElements;
-exports.CimplifyError = CimplifyError;
-exports.DEFAULT_COUNTRY = DEFAULT_COUNTRY;
-exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
-exports.DEVICE_TYPE = DEVICE_TYPE;
-exports.ELEMENT_TYPES = ELEMENT_TYPES;
-exports.ERROR_HINTS = ERROR_HINTS;
-exports.EVENT_TYPES = EVENT_TYPES;
-exports.ErrorCode = ErrorCode;
-exports.FxService = FxService;
-exports.InventoryService = InventoryService;
-exports.LINK_MUTATION = LINK_MUTATION;
-exports.LINK_QUERY = LINK_QUERY;
-exports.LinkService = LinkService;
-exports.LiteService = LiteService;
-exports.MESSAGE_TYPES = MESSAGE_TYPES;
-exports.MOBILE_MONEY_PROVIDER = MOBILE_MONEY_PROVIDER;
-exports.MOBILE_MONEY_PROVIDERS = MOBILE_MONEY_PROVIDERS;
-exports.ORDER_MUTATION = ORDER_MUTATION;
-exports.ORDER_TYPE = ORDER_TYPE;
-exports.OrderQueries = OrderQueries;
-exports.PAYMENT_METHOD = PAYMENT_METHOD;
-exports.PAYMENT_MUTATION = PAYMENT_MUTATION;
-exports.PAYMENT_STATE = PAYMENT_STATE;
-exports.PICKUP_TIME_TYPE = PICKUP_TIME_TYPE;
-exports.QueryBuilder = QueryBuilder;
-exports.SchedulingService = SchedulingService;
-exports.ZERO = ZERO;
-exports.categorizePaymentError = categorizePaymentError;
-exports.combine = combine;
-exports.combineObject = combineObject;
-exports.createCimplifyClient = createCimplifyClient;
-exports.createElements = createElements;
-exports.currencyCode = currencyCode;
-exports.detectMobileMoneyProvider = detectMobileMoneyProvider;
-exports.enrichError = enrichError;
-exports.err = err;
-exports.flatMap = flatMap;
-exports.formatMoney = formatMoney;
-exports.formatNumberCompact = formatNumberCompact;
-exports.formatPrice = formatPrice;
-exports.formatPriceAdjustment = formatPriceAdjustment;
-exports.formatPriceCompact = formatPriceCompact;
-exports.formatPriceWithTax = formatPriceWithTax;
-exports.formatProductPrice = formatProductPrice;
-exports.fromPromise = fromPromise;
-exports.generateIdempotencyKey = generateIdempotencyKey;
-exports.getBasePrice = getBasePrice;
-exports.getCurrencySymbol = getCurrencySymbol;
-exports.getDiscountPercentage = getDiscountPercentage;
-exports.getDisplayPrice = getDisplayPrice;
-exports.getErrorHint = getErrorHint;
-exports.getMarkupPercentage = getMarkupPercentage;
-exports.getOrElse = getOrElse;
-exports.getProductCurrency = getProductCurrency;
-exports.getTaxAmount = getTaxAmount;
-exports.getVariantDisplayName = getVariantDisplayName;
-exports.hasTaxInfo = hasTaxInfo;
-exports.isCimplifyError = isCimplifyError;
-exports.isErr = isErr;
-exports.isOk = isOk;
-exports.isOnSale = isOnSale;
-exports.isPaymentStatusFailure = isPaymentStatusFailure;
-exports.isPaymentStatusRequiresAction = isPaymentStatusRequiresAction;
-exports.isPaymentStatusSuccess = isPaymentStatusSuccess;
-exports.isRetryableError = isRetryableError;
-exports.isSupportedCurrency = isSupportedCurrency;
-exports.isTaxInclusive = isTaxInclusive;
-exports.isValidPhoneForContext = isValidPhoneForContext;
-exports.mapError = mapError;
-exports.mapResult = mapResult;
-exports.money = money;
-exports.moneyFromNumber = moneyFromNumber;
-exports.normalizePaymentResponse = normalizePaymentResponse;
-exports.normalizePhoneToE164 = normalizePhoneToE164;
-exports.normalizeStatusResponse = normalizeStatusResponse;
-exports.ok = ok;
-exports.parsePrice = parsePrice;
-exports.query = query;
-exports.resolvePhoneCountryCode = resolvePhoneCountryCode;
-exports.toNullable = toNullable;
-exports.tryCatch = tryCatch;
-exports.unwrap = unwrap;
+Object.defineProperty(exports, "ActivityService", {
+  enumerable: true,
+  get: function () { return chunkOITG2SEN_js.ActivityService; }
+});
+Object.defineProperty(exports, "CimplifyClient", {
+  enumerable: true,
+  get: function () { return chunkOITG2SEN_js.CimplifyClient; }
+});
+Object.defineProperty(exports, "createCimplifyClient", {
+  enumerable: true,
+  get: function () { return chunkOITG2SEN_js.createCimplifyClient; }
+});
+Object.defineProperty(exports, "getVariantDisplayName", {
+  enumerable: true,
+  get: function () { return chunkOITG2SEN_js.getVariantDisplayName; }
+});
+Object.defineProperty(exports, "isValidPhoneForContext", {
+  enumerable: true,
+  get: function () { return chunkS6TU55KP_js.isValidPhoneForContext; }
+});
+Object.defineProperty(exports, "normalizePhoneToE164", {
+  enumerable: true,
+  get: function () { return chunkS6TU55KP_js.normalizePhoneToE164; }
+});
+Object.defineProperty(exports, "resolvePhoneCountryCode", {
+  enumerable: true,
+  get: function () { return chunkS6TU55KP_js.resolvePhoneCountryCode; }
+});
+Object.defineProperty(exports, "QueryBuilder", {
+  enumerable: true,
+  get: function () { return chunkFLPI2VVJ_js.QueryBuilder; }
+});
+Object.defineProperty(exports, "query", {
+  enumerable: true,
+  get: function () { return chunkFLPI2VVJ_js.query; }
+});
+Object.defineProperty(exports, "AUTHORIZATION_TYPE", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.AUTHORIZATION_TYPE; }
+});
+Object.defineProperty(exports, "AUTH_MUTATION", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.AUTH_MUTATION; }
+});
+Object.defineProperty(exports, "AuthService", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.AuthService; }
+});
+Object.defineProperty(exports, "BusinessService", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.BusinessService; }
+});
+Object.defineProperty(exports, "CHECKOUT_MODE", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CHECKOUT_MODE; }
+});
+Object.defineProperty(exports, "CHECKOUT_MUTATION", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CHECKOUT_MUTATION; }
+});
+Object.defineProperty(exports, "CHECKOUT_STEP", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CHECKOUT_STEP; }
+});
+Object.defineProperty(exports, "CONTACT_TYPE", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CONTACT_TYPE; }
+});
+Object.defineProperty(exports, "CartOperations", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CartOperations; }
+});
+Object.defineProperty(exports, "CatalogueQueries", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CatalogueQueries; }
+});
+Object.defineProperty(exports, "CheckoutOperations", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CheckoutService; }
+});
+Object.defineProperty(exports, "CheckoutService", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CheckoutService; }
+});
+Object.defineProperty(exports, "CimplifyElement", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CimplifyElement; }
+});
+Object.defineProperty(exports, "CimplifyElements", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.CimplifyElements; }
+});
+Object.defineProperty(exports, "DEFAULT_COUNTRY", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.DEFAULT_COUNTRY; }
+});
+Object.defineProperty(exports, "DEFAULT_CURRENCY", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.DEFAULT_CURRENCY; }
+});
+Object.defineProperty(exports, "DEVICE_TYPE", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.DEVICE_TYPE; }
+});
+Object.defineProperty(exports, "ELEMENT_TYPES", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.ELEMENT_TYPES; }
+});
+Object.defineProperty(exports, "EVENT_TYPES", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.EVENT_TYPES; }
+});
+Object.defineProperty(exports, "FxService", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.FxService; }
+});
+Object.defineProperty(exports, "InventoryService", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.InventoryService; }
+});
+Object.defineProperty(exports, "LINK_MUTATION", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.LINK_MUTATION; }
+});
+Object.defineProperty(exports, "LINK_QUERY", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.LINK_QUERY; }
+});
+Object.defineProperty(exports, "LinkService", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.LinkService; }
+});
+Object.defineProperty(exports, "LiteService", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.LiteService; }
+});
+Object.defineProperty(exports, "MESSAGE_TYPES", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.MESSAGE_TYPES; }
+});
+Object.defineProperty(exports, "MOBILE_MONEY_PROVIDER", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.MOBILE_MONEY_PROVIDER; }
+});
+Object.defineProperty(exports, "ORDER_MUTATION", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.ORDER_MUTATION; }
+});
+Object.defineProperty(exports, "ORDER_TYPE", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.ORDER_TYPE; }
+});
+Object.defineProperty(exports, "OrderQueries", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.OrderQueries; }
+});
+Object.defineProperty(exports, "PAYMENT_METHOD", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.PAYMENT_METHOD; }
+});
+Object.defineProperty(exports, "PAYMENT_MUTATION", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.PAYMENT_MUTATION; }
+});
+Object.defineProperty(exports, "PAYMENT_STATE", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.PAYMENT_STATE; }
+});
+Object.defineProperty(exports, "PICKUP_TIME_TYPE", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.PICKUP_TIME_TYPE; }
+});
+Object.defineProperty(exports, "SchedulingService", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.SchedulingService; }
+});
+Object.defineProperty(exports, "combine", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.combine; }
+});
+Object.defineProperty(exports, "combineObject", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.combineObject; }
+});
+Object.defineProperty(exports, "createElements", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.createElements; }
+});
+Object.defineProperty(exports, "err", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.err; }
+});
+Object.defineProperty(exports, "flatMap", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.flatMap; }
+});
+Object.defineProperty(exports, "fromPromise", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.fromPromise; }
+});
+Object.defineProperty(exports, "generateIdempotencyKey", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.generateIdempotencyKey; }
+});
+Object.defineProperty(exports, "getOrElse", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.getOrElse; }
+});
+Object.defineProperty(exports, "isErr", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.isErr; }
+});
+Object.defineProperty(exports, "isOk", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.isOk; }
+});
+Object.defineProperty(exports, "mapError", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.mapError; }
+});
+Object.defineProperty(exports, "mapResult", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.mapResult; }
+});
+Object.defineProperty(exports, "ok", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.ok; }
+});
+Object.defineProperty(exports, "toNullable", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.toNullable; }
+});
+Object.defineProperty(exports, "tryCatch", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.tryCatch; }
+});
+Object.defineProperty(exports, "unwrap", {
+  enumerable: true,
+  get: function () { return chunkREPTMTQ4_js.unwrap; }
+});
+Object.defineProperty(exports, "CURRENCY_SYMBOLS", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.CURRENCY_SYMBOLS; }
+});
+Object.defineProperty(exports, "CimplifyError", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.CimplifyError; }
+});
+Object.defineProperty(exports, "ERROR_HINTS", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.ERROR_HINTS; }
+});
+Object.defineProperty(exports, "ErrorCode", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.ErrorCode; }
+});
+Object.defineProperty(exports, "MOBILE_MONEY_PROVIDERS", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.MOBILE_MONEY_PROVIDERS; }
+});
+Object.defineProperty(exports, "ZERO", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.ZERO; }
+});
+Object.defineProperty(exports, "categorizePaymentError", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.categorizePaymentError; }
+});
+Object.defineProperty(exports, "currencyCode", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.currencyCode; }
+});
+Object.defineProperty(exports, "detectMobileMoneyProvider", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.detectMobileMoneyProvider; }
+});
+Object.defineProperty(exports, "enrichError", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.enrichError; }
+});
+Object.defineProperty(exports, "formatMoney", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.formatMoney; }
+});
+Object.defineProperty(exports, "formatNumberCompact", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.formatNumberCompact; }
+});
+Object.defineProperty(exports, "formatPrice", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.formatPrice; }
+});
+Object.defineProperty(exports, "formatPriceAdjustment", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.formatPriceAdjustment; }
+});
+Object.defineProperty(exports, "formatPriceCompact", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.formatPriceCompact; }
+});
+Object.defineProperty(exports, "formatPriceWithTax", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.formatPriceWithTax; }
+});
+Object.defineProperty(exports, "formatProductPrice", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.formatProductPrice; }
+});
+Object.defineProperty(exports, "getBasePrice", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.getBasePrice; }
+});
+Object.defineProperty(exports, "getCurrencySymbol", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.getCurrencySymbol; }
+});
+Object.defineProperty(exports, "getDiscountPercentage", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.getDiscountPercentage; }
+});
+Object.defineProperty(exports, "getDisplayPrice", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.getDisplayPrice; }
+});
+Object.defineProperty(exports, "getErrorHint", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.getErrorHint; }
+});
+Object.defineProperty(exports, "getMarkupPercentage", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.getMarkupPercentage; }
+});
+Object.defineProperty(exports, "getProductCurrency", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.getProductCurrency; }
+});
+Object.defineProperty(exports, "getTaxAmount", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.getTaxAmount; }
+});
+Object.defineProperty(exports, "hasTaxInfo", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.hasTaxInfo; }
+});
+Object.defineProperty(exports, "isCimplifyError", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.isCimplifyError; }
+});
+Object.defineProperty(exports, "isOnSale", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.isOnSale; }
+});
+Object.defineProperty(exports, "isPaymentStatusFailure", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.isPaymentStatusFailure; }
+});
+Object.defineProperty(exports, "isPaymentStatusRequiresAction", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.isPaymentStatusRequiresAction; }
+});
+Object.defineProperty(exports, "isPaymentStatusSuccess", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.isPaymentStatusSuccess; }
+});
+Object.defineProperty(exports, "isRetryableError", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.isRetryableError; }
+});
+Object.defineProperty(exports, "isSupportedCurrency", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.isSupportedCurrency; }
+});
+Object.defineProperty(exports, "isTaxInclusive", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.isTaxInclusive; }
+});
+Object.defineProperty(exports, "money", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.money; }
+});
+Object.defineProperty(exports, "moneyFromNumber", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.moneyFromNumber; }
+});
+Object.defineProperty(exports, "normalizePaymentResponse", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.normalizePaymentResponse; }
+});
+Object.defineProperty(exports, "normalizeStatusResponse", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.normalizeStatusResponse; }
+});
+Object.defineProperty(exports, "parsePrice", {
+  enumerable: true,
+  get: function () { return chunkJ65U5SED_js.parsePrice; }
+});