@cimplify/sdk 0.16.3 → 0.17.0

package/dist/advanced.mjs

@@ -1,2893 +1,3 @@
-// src/types/result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-
-// src/types/common.ts
-function money(value) {
-  return typeof value === "string" ? parseFloat(value) || 0 : value;
-}
-function moneyFromNumber(value) {
-  return value;
-}
-function currencyCode(value) {
-  return value;
-}
-var ErrorCode = {
-  UNKNOWN_ERROR: "UNKNOWN_ERROR",
-  NOT_FOUND: "NOT_FOUND"};
-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 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;
-}
-
-// 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 MOBILE_MONEY_PROVIDER = {
-  MTN: "mtn",
-  VODAFONE: "vodafone",
-  AIRTEL: "airtel"
-};
-
-// src/utils/payment.ts
-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 || ""
-  };
-}
-
-// 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/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/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);
-}
-
-export { AuthService, BusinessService, CartOperations, CatalogueQueries, CheckoutService as CheckoutOperations, CheckoutService, CimplifyElement, CimplifyElements, ELEMENT_TYPES, EVENT_TYPES, FxService, InventoryService, LinkService, LiteService, MESSAGE_TYPES, OrderQueries, QueryBuilder, SchedulingService, createElements, generateIdempotencyKey, query };
+export { QueryBuilder, query } from './chunk-LM3CJ4L7.mjs';
+export { AuthService, BusinessService, CartOperations, CatalogueQueries, CheckoutService as CheckoutOperations, CheckoutService, CimplifyElement, CimplifyElements, ELEMENT_TYPES, EVENT_TYPES, FxService, InventoryService, LinkService, LiteService, MESSAGE_TYPES, OrderQueries, SchedulingService, createElements, generateIdempotencyKey } from './chunk-GFKBH7R2.mjs';
+import './chunk-OVM5YWM5.mjs';