@cimplify/sdk 0.6.4 → 0.6.6

package/dist/advanced.js

@@ -0,0 +1,2639 @@
+'use strict';
+
+// src/types/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// src/types/common.ts
+var CimplifyError = class extends Error {
+  constructor(code, message, retryable = false) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "CimplifyError";
+  }
+  /** User-friendly message safe to display */
+  get userMessage() {
+    return this.message;
+  }
+};
+
+// src/catalogue.ts
+function toCimplifyError(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError(error));
+  }
+}
+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 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 variants = normalized["variants"];
+  if (Array.isArray(variants)) {
+    normalized["variants"] = variants.map((variant) => {
+      if (!isRecord(variant)) return variant;
+      const normalizedVariant = { ...variant };
+      const variantAdjustment = normalizedVariant["price_adjustment"];
+      if (variantAdjustment === void 0 || variantAdjustment === null || variantAdjustment === "") {
+        normalizedVariant["price_adjustment"] = readFinalPrice(normalizedVariant["price_info"]) ?? "0";
+      }
+      return normalizedVariant;
+    });
+  }
+  const addOns = normalized["add_ons"];
+  if (Array.isArray(addOns)) {
+    normalized["add_ons"] = addOns.map((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;
+    });
+  }
+  return normalized;
+}
+function findProductBySlug(products, slug) {
+  return products.find((product) => {
+    const value = product["slug"];
+    return typeof value === "string" && value === slug;
+  });
+}
+var CatalogueQueries = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getProducts(options) {
+    let query2 = "products";
+    const filters = [];
+    if (options?.category) {
+      filters.push(`@.category_id=='${options.category}'`);
+    }
+    if (options?.featured !== void 0) {
+      filters.push(`@.featured==${options.featured}`);
+    }
+    if (options?.in_stock !== void 0) {
+      filters.push(`@.in_stock==${options.in_stock}`);
+    }
+    if (options?.search) {
+      filters.push(`@.name contains '${options.search}'`);
+    }
+    if (options?.min_price !== void 0) {
+      filters.push(`@.price>=${options.min_price}`);
+    }
+    if (options?.max_price !== void 0) {
+      filters.push(`@.price<=${options.max_price}`);
+    }
+    if (filters.length > 0) {
+      query2 += `[?(${filters.join(" && ")})]`;
+    }
+    if (options?.sort_by) {
+      query2 += `#sort(${options.sort_by},${options.sort_order || "asc"})`;
+    }
+    if (options?.limit) {
+      query2 += `#limit(${options.limit})`;
+    }
+    if (options?.offset) {
+      query2 += `#offset(${options.offset})`;
+    }
+    const result = await safe(this.client.query(query2));
+    if (!result.ok) return result;
+    return ok(result.value.map((product) => normalizeCatalogueProductPayload(product)));
+  }
+  async getProduct(id) {
+    const result = await safe(this.client.query(`products.${id}`));
+    if (!result.ok) return result;
+    return ok(normalizeCatalogueProductPayload(result.value));
+  }
+  async getProductBySlug(slug) {
+    const filteredResult = await safe(
+      this.client.query(`products[?(@.slug=='${slug}')]`)
+    );
+    if (!filteredResult.ok) return filteredResult;
+    const exactMatch = findProductBySlug(filteredResult.value, slug);
+    if (exactMatch) {
+      return ok(normalizeCatalogueProductPayload(exactMatch));
+    }
+    if (filteredResult.value.length === 1) {
+      return ok(normalizeCatalogueProductPayload(filteredResult.value[0]));
+    }
+    const unfilteredResult = await safe(this.client.query("products"));
+    if (!unfilteredResult.ok) return unfilteredResult;
+    const fallbackMatch = findProductBySlug(unfilteredResult.value, slug);
+    if (!fallbackMatch) {
+      return err(new CimplifyError("NOT_FOUND", `Product not found: ${slug}`, false));
+    }
+    return ok(normalizeCatalogueProductPayload(fallbackMatch));
+  }
+  async getVariants(productId) {
+    return safe(this.client.query(`products.${productId}.variants`));
+  }
+  async getVariantAxes(productId) {
+    return safe(this.client.query(`products.${productId}.variant_axes`));
+  }
+  /**
+   * Find a variant by axis selections (e.g., { "Size": "Large", "Color": "Red" })
+   * Returns the matching variant or null if no match found.
+   */
+  async getVariantByAxisSelections(productId, selections) {
+    return safe(
+      this.client.query(`products.${productId}.variant`, {
+        axis_selections: selections
+      })
+    );
+  }
+  /**
+   * Get a specific variant by its ID
+   */
+  async getVariantById(productId, variantId) {
+    return safe(this.client.query(`products.${productId}.variant.${variantId}`));
+  }
+  async getAddOns(productId) {
+    return safe(this.client.query(`products.${productId}.add_ons`));
+  }
+  async getCategories() {
+    return safe(this.client.query("categories"));
+  }
+  async getCategory(id) {
+    return safe(this.client.query(`categories.${id}`));
+  }
+  async getCategoryBySlug(slug) {
+    const result = await safe(
+      this.client.query(`categories[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Category not found: ${slug}`, false));
+    }
+    return ok(result.value[0]);
+  }
+  async getCategoryProducts(categoryId) {
+    return safe(this.client.query(`products[?(@.category_id=='${categoryId}')]`));
+  }
+  async getCollections() {
+    return safe(this.client.query("collections"));
+  }
+  async getCollection(id) {
+    return safe(this.client.query(`collections.${id}`));
+  }
+  async getCollectionBySlug(slug) {
+    const result = await safe(
+      this.client.query(`collections[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Collection not found: ${slug}`, false));
+    }
+    return ok(result.value[0]);
+  }
+  async getCollectionProducts(collectionId) {
+    return safe(this.client.query(`collections.${collectionId}.products`));
+  }
+  async searchCollections(query2, limit = 20) {
+    return safe(
+      this.client.query(`collections[?(@.name contains '${query2}')]#limit(${limit})`)
+    );
+  }
+  async getBundles() {
+    return safe(this.client.query("bundles"));
+  }
+  async getBundle(id) {
+    return safe(this.client.query(`bundles.${id}`));
+  }
+  async getBundleBySlug(slug) {
+    const result = await safe(
+      this.client.query(`bundles[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Bundle not found: ${slug}`, false));
+    }
+    return ok(result.value[0]);
+  }
+  async searchBundles(query2, limit = 20) {
+    return safe(
+      this.client.query(`bundles[?(@.name contains '${query2}')]#limit(${limit})`)
+    );
+  }
+  async getComposites(options) {
+    let query2 = "composites";
+    if (options?.limit) {
+      query2 += `#limit(${options.limit})`;
+    }
+    return safe(this.client.query(query2));
+  }
+  async getComposite(id) {
+    return safe(this.client.query(`composites.${id}`));
+  }
+  async getCompositeByProductId(productId) {
+    return safe(this.client.query(`composites.by_product.${productId}`));
+  }
+  async calculateCompositePrice(compositeId, selections, locationId) {
+    return safe(
+      this.client.call("composite.calculatePrice", {
+        composite_id: compositeId,
+        selections,
+        location_id: locationId
+      })
+    );
+  }
+  async fetchQuote(input) {
+    return safe(this.client.call("catalogue.createQuote", input));
+  }
+  async getQuote(quoteId) {
+    return safe(
+      this.client.call("catalogue.getQuote", {
+        quote_id: quoteId
+      })
+    );
+  }
+  async refreshQuote(input) {
+    return safe(this.client.call("catalogue.refreshQuote", input));
+  }
+  async search(query2, options) {
+    const limit = options?.limit ?? 20;
+    let searchQuery = `products[?(@.name contains '${query2}')]`;
+    if (options?.category) {
+      searchQuery = `products[?(@.name contains '${query2}' && @.category_id=='${options.category}')]`;
+    }
+    searchQuery += `#limit(${limit})`;
+    return safe(this.client.query(searchQuery));
+  }
+  async searchProducts(query2, options) {
+    return safe(
+      this.client.call("catalogue.search", {
+        query: query2,
+        limit: options?.limit ?? 20,
+        category: options?.category
+      })
+    );
+  }
+  async getMenu(options) {
+    let query2 = "menu";
+    if (options?.category) {
+      query2 = `menu[?(@.category=='${options.category}')]`;
+    }
+    if (options?.limit) {
+      query2 += `#limit(${options.limit})`;
+    }
+    return safe(this.client.query(query2));
+  }
+  async getMenuCategory(categoryId) {
+    return safe(this.client.query(`menu.category.${categoryId}`));
+  }
+  async getMenuItem(itemId) {
+    return safe(this.client.query(`menu.${itemId}`));
+  }
+};
+
+// src/cart.ts
+function toCimplifyError2(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe2(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError2(error));
+  }
+}
+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 safe2(this.client.query("cart#enriched"));
+    if (!result.ok) return result;
+    return ok(unwrapEnrichedCart(result.value));
+  }
+  async getRaw() {
+    return safe2(this.client.query("cart"));
+  }
+  async getItems() {
+    return safe2(this.client.query("cart_items"));
+  }
+  async getCount() {
+    return safe2(this.client.query("cart#count"));
+  }
+  async getTotal() {
+    return safe2(this.client.query("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 safe2(this.client.call("cart.addItem", input));
+  }
+  async updateItem(cartItemId, updates) {
+    return safe2(
+      this.client.call("cart.updateItem", {
+        cart_item_id: cartItemId,
+        ...updates
+      })
+    );
+  }
+  async updateQuantity(cartItemId, quantity) {
+    return safe2(
+      this.client.call("cart.updateItemQuantity", {
+        cart_item_id: cartItemId,
+        quantity
+      })
+    );
+  }
+  async removeItem(cartItemId) {
+    return safe2(
+      this.client.call("cart.removeItem", {
+        cart_item_id: cartItemId
+      })
+    );
+  }
+  async clear() {
+    return safe2(this.client.call("cart.clearCart"));
+  }
+  async applyCoupon(code) {
+    return safe2(
+      this.client.call("cart.applyCoupon", {
+        coupon_code: code
+      })
+    );
+  }
+  async removeCoupon() {
+    return safe2(this.client.call("cart.removeCoupon"));
+  }
+  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 LINK_QUERY = {
+  DATA: "link.data",
+  ADDRESSES: "link.addresses",
+  MOBILE_MONEY: "link.mobile_money",
+  PREFERENCES: "link.preferences"};
+var LINK_MUTATION = {
+  CHECK_STATUS: "link.check_status",
+  ENROLL: "link.enroll",
+  ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order",
+  UPDATE_PREFERENCES: "link.update_preferences",
+  CREATE_ADDRESS: "link.create_address",
+  UPDATE_ADDRESS: "link.update_address",
+  DELETE_ADDRESS: "link.delete_address",
+  SET_DEFAULT_ADDRESS: "link.set_default_address",
+  TRACK_ADDRESS_USAGE: "link.track_address_usage",
+  CREATE_MOBILE_MONEY: "link.create_mobile_money",
+  DELETE_MOBILE_MONEY: "link.delete_mobile_money",
+  SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money",
+  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
+  VERIFY_MOBILE_MONEY: "link.verify_mobile_money"};
+var AUTH_MUTATION = {
+  REQUEST_OTP: "auth.request_otp",
+  VERIFY_OTP: "auth.verify_otp"
+};
+var CHECKOUT_MUTATION = {
+  PROCESS: "checkout.process"
+};
+var PAYMENT_MUTATION = {
+  SUBMIT_AUTHORIZATION: "payment.submit_authorization",
+  CHECK_STATUS: "order.poll_payment_status"
+};
+var ORDER_MUTATION = {
+  UPDATE_CUSTOMER: "order.update_order_customer"
+};
+
+// 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"
+]);
+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([
+  "pending",
+  "processing",
+  "created",
+  "pending_confirmation",
+  "success",
+  "succeeded",
+  "failed",
+  "declined",
+  "authorized",
+  "refunded",
+  "partially_refunded",
+  "partially_paid",
+  "paid",
+  "unpaid",
+  "requires_action",
+  "requires_payment_method",
+  "requires_capture",
+  "captured",
+  "cancelled",
+  "completed",
+  "voided",
+  "error",
+  "unknown"
+]);
+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,
+      message: "No status available"
+    };
+  }
+  const res = response;
+  const normalizedStatus = normalizePaymentStatusValue(res.status ?? void 0);
+  const paidValue = res.paid === true;
+  const derivedPaid = paidValue || [
+    "success",
+    "succeeded",
+    "paid",
+    "captured",
+    "authorized",
+    "completed"
+  ].includes(normalizedStatus);
+  return {
+    status: normalizedStatus,
+    paid: derivedPaid,
+    amount: res.amount,
+    currency: res.currency,
+    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";
+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" };
+}
+function normalizeAuthorizationType(value) {
+  return value === "otp" || value === "pin" ? value : 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);
+      }
+      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 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);
+    }
+    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) {
+      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 toCimplifyError3(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe3(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError3(error));
+  }
+}
+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;
+  }
+  async process(data) {
+    const checkoutData = {
+      ...data,
+      idempotency_key: data.idempotency_key || generateIdempotencyKey()
+    };
+    return safe3(
+      this.client.call(CHECKOUT_MUTATION.PROCESS, {
+        checkout_data: checkoutData
+      })
+    );
+  }
+  async initializePayment(orderId, method) {
+    return safe3(
+      this.client.call("order.initializePayment", {
+        order_id: orderId,
+        payment_method: method
+      })
+    );
+  }
+  async submitAuthorization(input) {
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
+    );
+  }
+  async pollPaymentStatus(orderId) {
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
+    );
+  }
+  async updateOrderCustomer(orderId, customer) {
+    return safe3(
+      this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
+        order_id: orderId,
+        ...customer
+      })
+    );
+  }
+  async verifyPayment(orderId) {
+    return safe3(
+      this.client.call("order.verifyPayment", {
+        order_id: orderId
+      })
+    );
+  }
+  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 = (cart.pricing.currency || checkoutData.pay_currency || "GHS").toUpperCase();
+    const payCurrency = data.pay_currency?.trim().toUpperCase();
+    const cartTotalAmount = Number.parseFloat(cart.pricing.total_price || "0");
+    if (payCurrency && payCurrency !== baseCurrency && !checkoutData.fx_quote_id && Number.isFinite(cartTotalAmount) && cartTotalAmount > 0) {
+      const fxQuoteResult = await this.client.fx.lockQuote({
+        from: baseCurrency,
+        to: payCurrency,
+        amount: cartTotalAmount
+      });
+      if (!fxQuoteResult.ok) {
+        return ok(
+          toTerminalFailure(
+            "FX_QUOTE_FAILED",
+            fxQuoteResult.error.message || "Unable to lock FX quote for checkout.",
+            true
+          )
+        );
+      }
+      checkoutData.pay_currency = payCurrency;
+      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
+function toCimplifyError4(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe4(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError4(error));
+  }
+}
+var OrderQueries = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options) {
+    let query2 = "orders";
+    if (options?.status) {
+      query2 += `[?(@.status=='${options.status}')]`;
+    }
+    query2 += "#sort(created_at,desc)";
+    if (options?.limit) {
+      query2 += `#limit(${options.limit})`;
+    }
+    if (options?.offset) {
+      query2 += `#offset(${options.offset})`;
+    }
+    return safe4(this.client.query(query2));
+  }
+  async get(orderId) {
+    return safe4(this.client.query(`orders.${orderId}`));
+  }
+  async getRecent(limit = 5) {
+    return safe4(this.client.query(`orders#sort(created_at,desc)#limit(${limit})`));
+  }
+  async getByStatus(status) {
+    return safe4(this.client.query(`orders[?(@.status=='${status}')]`));
+  }
+  async cancel(orderId, reason) {
+    return safe4(
+      this.client.call("order.cancelOrder", {
+        order_id: orderId,
+        reason
+      })
+    );
+  }
+};
+
+// src/link.ts
+function toCimplifyError5(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe5(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError5(error));
+  }
+}
+var LinkService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async requestOtp(input) {
+    return safe5(this.client.linkPost("/v1/link/auth/request-otp", input));
+  }
+  async verifyOtp(input) {
+    const result = await safe5(
+      this.client.linkPost("/v1/link/auth/verify-otp", input)
+    );
+    if (result.ok && result.value.session_token) {
+      this.client.setSessionToken(result.value.session_token);
+    }
+    return result;
+  }
+  async logout() {
+    const result = await safe5(this.client.linkPost("/v1/link/auth/logout"));
+    if (result.ok) {
+      this.client.clearSession();
+    }
+    return result;
+  }
+  async checkStatus(contact) {
+    return safe5(
+      this.client.call(LINK_MUTATION.CHECK_STATUS, {
+        contact
+      })
+    );
+  }
+  async getLinkData() {
+    return safe5(this.client.query(LINK_QUERY.DATA));
+  }
+  async getAddresses() {
+    return safe5(this.client.query(LINK_QUERY.ADDRESSES));
+  }
+  async getMobileMoney() {
+    return safe5(this.client.query(LINK_QUERY.MOBILE_MONEY));
+  }
+  async getPreferences() {
+    return safe5(this.client.query(LINK_QUERY.PREFERENCES));
+  }
+  async enroll(data) {
+    return safe5(this.client.call(LINK_MUTATION.ENROLL, data));
+  }
+  async enrollAndLinkOrder(data) {
+    return safe5(
+      this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data)
+    );
+  }
+  async updatePreferences(preferences) {
+    return safe5(this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences));
+  }
+  async createAddress(input) {
+    return safe5(this.client.call(LINK_MUTATION.CREATE_ADDRESS, input));
+  }
+  async updateAddress(input) {
+    return safe5(this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input));
+  }
+  async deleteAddress(addressId) {
+    return safe5(this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId));
+  }
+  async setDefaultAddress(addressId) {
+    return safe5(this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId));
+  }
+  async trackAddressUsage(addressId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
+        address_id: addressId
+      })
+    );
+  }
+  async createMobileMoney(input) {
+    return safe5(this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input));
+  }
+  async deleteMobileMoney(mobileMoneyId) {
+    return safe5(this.client.call(LINK_MUTATION.DELETE_MOBILE_MONEY, mobileMoneyId));
+  }
+  async setDefaultMobileMoney(mobileMoneyId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.SET_DEFAULT_MOBILE_MONEY, mobileMoneyId)
+    );
+  }
+  async trackMobileMoneyUsage(mobileMoneyId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
+        mobile_money_id: mobileMoneyId
+      })
+    );
+  }
+  async verifyMobileMoney(mobileMoneyId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
+    );
+  }
+  async getSessions() {
+    return safe5(this.client.linkGet("/v1/link/sessions"));
+  }
+  async revokeSession(sessionId) {
+    return safe5(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
+  }
+  async revokeAllSessions() {
+    return safe5(this.client.linkDelete("/v1/link/sessions"));
+  }
+  async getAddressesRest() {
+    return safe5(this.client.linkGet("/v1/link/addresses"));
+  }
+  async createAddressRest(input) {
+    return safe5(this.client.linkPost("/v1/link/addresses", input));
+  }
+  async deleteAddressRest(addressId) {
+    return safe5(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
+  }
+  async setDefaultAddressRest(addressId) {
+    return safe5(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
+  }
+  async getMobileMoneyRest() {
+    return safe5(this.client.linkGet("/v1/link/mobile-money"));
+  }
+  async createMobileMoneyRest(input) {
+    return safe5(this.client.linkPost("/v1/link/mobile-money", input));
+  }
+  async deleteMobileMoneyRest(mobileMoneyId) {
+    return safe5(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
+  }
+  async setDefaultMobileMoneyRest(mobileMoneyId) {
+    return safe5(
+      this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
+    );
+  }
+};
+
+// src/auth.ts
+function toCimplifyError6(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe6(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError6(error));
+  }
+}
+var AuthService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getStatus() {
+    return safe6(this.client.query("auth"));
+  }
+  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 safe6(
+      this.client.call(AUTH_MUTATION.REQUEST_OTP, {
+        contact,
+        contact_type: contactType
+      })
+    );
+  }
+  async verifyOtp(code, contact) {
+    return safe6(
+      this.client.call(AUTH_MUTATION.VERIFY_OTP, {
+        otp_code: code,
+        contact
+      })
+    );
+  }
+  async logout() {
+    return safe6(this.client.call("auth.logout"));
+  }
+  async updateProfile(input) {
+    return safe6(this.client.call("auth.update_profile", input));
+  }
+  async changePassword(input) {
+    return safe6(this.client.call("auth.change_password", input));
+  }
+  async resetPassword(email) {
+    return safe6(this.client.call("auth.reset_password", { email }));
+  }
+};
+
+// src/business.ts
+function toCimplifyError7(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe7(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError7(error));
+  }
+}
+var BusinessService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getInfo() {
+    return safe7(this.client.query("business.info"));
+  }
+  async getByHandle(handle) {
+    return safe7(this.client.query(`business.handle.${handle}`));
+  }
+  async getByDomain(domain) {
+    return safe7(this.client.query("business.domain", { domain }));
+  }
+  async getSettings() {
+    return safe7(this.client.query("business.settings"));
+  }
+  async getTheme() {
+    return safe7(this.client.query("business.theme"));
+  }
+  async getLocations() {
+    return safe7(this.client.query("business.locations"));
+  }
+  async getLocation(locationId) {
+    return safe7(this.client.query(`business.locations.${locationId}`));
+  }
+  async getHours() {
+    return safe7(this.client.query("business.hours"));
+  }
+  async getLocationHours(locationId) {
+    return safe7(this.client.query(`business.locations.${locationId}.hours`));
+  }
+  async getBootstrap() {
+    const [businessResult, locationsResult, categoriesResult] = await Promise.all([
+      this.getInfo(),
+      this.getLocations(),
+      safe7(this.client.query("categories#select(id,name,slug)"))
+    ]);
+    if (!businessResult.ok) return businessResult;
+    if (!locationsResult.ok) return locationsResult;
+    if (!categoriesResult.ok) return categoriesResult;
+    const business = businessResult.value;
+    const locations = locationsResult.value;
+    const categories = categoriesResult.value;
+    const defaultLocation = locations[0];
+    return ok({
+      business,
+      location: defaultLocation,
+      locations,
+      categories,
+      currency: business.default_currency,
+      is_open: defaultLocation?.accepts_online_orders ?? false,
+      accepts_orders: defaultLocation?.accepts_online_orders ?? false
+    });
+  }
+};
+
+// src/inventory.ts
+function toCimplifyError8(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe8(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError8(error));
+  }
+}
+var InventoryService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getStockLevels() {
+    return safe8(this.client.query("inventory.stock_levels"));
+  }
+  async getProductStock(productId, locationId) {
+    if (locationId) {
+      return safe8(
+        this.client.query("inventory.product", {
+          product_id: productId,
+          location_id: locationId
+        })
+      );
+    }
+    return safe8(
+      this.client.query("inventory.product", {
+        product_id: productId
+      })
+    );
+  }
+  async getVariantStock(variantId, locationId) {
+    return safe8(
+      this.client.query("inventory.variant", {
+        variant_id: variantId,
+        location_id: locationId
+      })
+    );
+  }
+  async checkProductAvailability(productId, quantity, locationId) {
+    return safe8(
+      this.client.query("inventory.check_availability", {
+        product_id: productId,
+        quantity,
+        location_id: locationId
+      })
+    );
+  }
+  async checkVariantAvailability(variantId, quantity, locationId) {
+    return safe8(
+      this.client.query("inventory.check_availability", {
+        variant_id: variantId,
+        quantity,
+        location_id: locationId
+      })
+    );
+  }
+  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 getSummary() {
+    return safe8(this.client.query("inventory.summary"));
+  }
+  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 toVariables(input) {
+  return Object.fromEntries(Object.entries(input));
+}
+function toCimplifyError9(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe9(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError9(error));
+  }
+}
+var SchedulingService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getServices() {
+    return safe9(this.client.query("scheduling.services"));
+  }
+  /**
+   * Get a specific service by ID
+   * Note: Filters from all services client-side (no single-service endpoint)
+   */
+  async getService(serviceId) {
+    const result = await this.getServices();
+    if (!result.ok) return result;
+    return ok(result.value.find((s) => s.id === serviceId) || null);
+  }
+  async getAvailableSlots(input) {
+    return safe9(
+      this.client.query("scheduling.slots", toVariables(input))
+    );
+  }
+  async checkSlotAvailability(input) {
+    return safe9(
+      this.client.query(
+        "scheduling.check_availability",
+        toVariables(input)
+      )
+    );
+  }
+  async getServiceAvailability(params) {
+    return safe9(
+      this.client.query(
+        "scheduling.availability",
+        toVariables(params)
+      )
+    );
+  }
+  async getBooking(bookingId) {
+    return safe9(this.client.query(`scheduling.${bookingId}`));
+  }
+  async getCustomerBookings() {
+    return safe9(this.client.query("scheduling"));
+  }
+  async getUpcomingBookings() {
+    return safe9(
+      this.client.query(
+        "scheduling[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
+      )
+    );
+  }
+  async getPastBookings(limit = 10) {
+    return safe9(
+      this.client.query(
+        `scheduling[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
+      )
+    );
+  }
+  async cancelBooking(input) {
+    return safe9(this.client.call("scheduling.cancel_booking", input));
+  }
+  async rescheduleBooking(input) {
+    return safe9(this.client.call("scheduling.reschedule_booking", 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
+function toCimplifyError10(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe10(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError10(error));
+  }
+}
+var LiteService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getBootstrap() {
+    return safe10(this.client.query("lite.bootstrap"));
+  }
+  async getTable(tableId) {
+    return safe10(this.client.query(`lite.table.${tableId}`));
+  }
+  async getTableByNumber(tableNumber, locationId) {
+    return safe10(
+      this.client.query("lite.table_by_number", {
+        table_number: tableNumber,
+        location_id: locationId
+      })
+    );
+  }
+  async sendToKitchen(tableId, items) {
+    return safe10(
+      this.client.call("lite.send_to_kitchen", {
+        table_id: tableId,
+        items
+      })
+    );
+  }
+  async callWaiter(tableId, reason) {
+    return safe10(
+      this.client.call("lite.call_waiter", {
+        table_id: tableId,
+        reason
+      })
+    );
+  }
+  async requestBill(tableId) {
+    return safe10(
+      this.client.call("lite.request_bill", {
+        table_id: tableId
+      })
+    );
+  }
+  async getMenu() {
+    return safe10(this.client.query("lite.menu"));
+  }
+  async getMenuByCategory(categoryId) {
+    return safe10(this.client.query(`lite.menu.category.${categoryId}`));
+  }
+};
+
+// src/fx.ts
+function toCimplifyError11(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe11(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError11(error));
+  }
+}
+var FxService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getRate(from, to) {
+    return safe11(this.client.call("fx.getRate", { from, to }));
+  }
+  async lockQuote(request) {
+    return safe11(this.client.call("fx.lockQuote", request));
+  }
+};
+
+// src/types/elements.ts
+var ELEMENT_TYPES = {
+  AUTH: "auth",
+  ADDRESS: "address",
+  PAYMENT: "payment"
+};
+var MESSAGE_TYPES = {
+  // Parent → Iframe
+  INIT: "init",
+  SET_TOKEN: "set_token",
+  GET_DATA: "get_data",
+  REFRESH_TOKEN: "refresh_token",
+  LOGOUT: "logout",
+  PROCESS_CHECKOUT: "process_checkout",
+  ABORT_CHECKOUT: "abort_checkout",
+  // Iframe → Parent
+  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",
+  CHECKOUT_STATUS: "checkout_status",
+  CHECKOUT_COMPLETE: "checkout_complete"
+};
+var EVENT_TYPES = {
+  READY: "ready",
+  AUTHENTICATED: "authenticated",
+  REQUIRES_OTP: "requires_otp",
+  ERROR: "error",
+  CHANGE: "change",
+  BLUR: "blur",
+  FOCUS: "focus"
+};
+
+// src/elements.ts
+function toCheckoutError(code, message, recoverable) {
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      recoverable
+    }
+  };
+}
+var DEFAULT_LINK_URL = "https://link.cimplify.io";
+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);
+    }
+  }
+  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);
+  }
+  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 () => {
+      if (this.checkoutInProgress) {
+        return toCheckoutError(
+          "ALREADY_PROCESSING",
+          "Checkout is already in progress.",
+          false
+        );
+      }
+      if (!options.cart_id) {
+        return toCheckoutError(
+          "INVALID_CART",
+          "A valid cart is required before checkout can start.",
+          false
+        );
+      }
+      if (!options.order_type) {
+        return toCheckoutError(
+          "ORDER_TYPE_REQUIRED",
+          "Order type is required before checkout can start.",
+          false
+        );
+      }
+      const paymentElement = this.elements.get(ELEMENT_TYPES.PAYMENT);
+      if (!paymentElement) {
+        return toCheckoutError(
+          "NO_PAYMENT_ELEMENT",
+          "Payment element must be mounted before checkout.",
+          false
+        );
+      }
+      if (!paymentElement.isMounted()) {
+        return toCheckoutError(
+          "PAYMENT_NOT_MOUNTED",
+          "Payment element must be mounted before checkout.",
+          false
+        );
+      }
+      const authElement = this.elements.get(ELEMENT_TYPES.AUTH);
+      if (authElement && !this.accessToken) {
+        return toCheckoutError(
+          "AUTH_INCOMPLETE",
+          "Authentication must complete before checkout can start.",
+          true
+        );
+      }
+      const addressElement = this.elements.get(ELEMENT_TYPES.ADDRESS);
+      if (addressElement) {
+        await addressElement.getData();
+      }
+      await this.hydrateCustomerData();
+      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: this.addressData ?? void 0,
+        customer: 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 = paymentElement.getContentWindow();
+      this.checkoutInProgress = true;
+      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) {
+            paymentElement.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) {
+            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 = () => {
+          paymentElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
+          settle(
+            toCheckoutError(
+              "CANCELLED",
+              "Checkout was cancelled.",
+              true
+            )
+          );
+        };
+        this.activeCheckoutAbort = abortFn;
+        paymentElement.sendMessage(processMessage);
+      });
+    })();
+    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) {
+            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.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;
+  }
+};
+var CimplifyElement = class {
+  constructor(type, businessId, linkUrl, options, parent) {
+    this.iframe = null;
+    this.container = null;
+    this.mounted = false;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+    this.type = type;
+    this.businessId = businessId;
+    this.linkUrl = linkUrl;
+    this.options = options;
+    this.parent = parent;
+    this.boundHandleMessage = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.boundHandleMessage);
+    }
+  }
+  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;
+    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 (typeof window !== "undefined") {
+      window.removeEventListener("message", this.boundHandleMessage);
+    }
+  }
+  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 });
+    });
+  }
+  sendMessage(message) {
+    if (this.iframe?.contentWindow) {
+      this.iframe.contentWindow.postMessage(message, this.linkUrl);
+    }
+  }
+  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);
+    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.display = "block";
+    iframe.style.overflow = "hidden";
+    iframe.setAttribute("allowtransparency", "true");
+    iframe.setAttribute("frameborder", "0");
+    iframe.setAttribute(
+      "sandbox",
+      "allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox"
+    );
+    this.iframe = iframe;
+    this.container.appendChild(iframe);
+    iframe.onload = () => {
+      const publicKey = this.parent.getPublicKey();
+      this.sendMessage({
+        type: MESSAGE_TYPES.INIT,
+        businessId: resolvedBusinessId,
+        publicKey,
+        demoMode: publicKey.length === 0,
+        prefillEmail: this.options.prefillEmail,
+        appearance: this.parent.getAppearance()
+      });
+      const token = this.parent.getAccessToken();
+      if (token && this.type !== ELEMENT_TYPES.AUTH) {
+        this.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token });
+      }
+    };
+  }
+  handleMessage(event) {
+    if (!isAllowedOrigin(event.origin)) {
+      return;
+    }
+    const message = parseIframeMessage(event.data);
+    if (!message) return;
+    switch (message.type) {
+      case MESSAGE_TYPES.READY:
+        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;
+    }
+  }
+  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
+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" ? `'${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);
+}
+
+exports.AuthService = AuthService;
+exports.BusinessService = BusinessService;
+exports.CartOperations = CartOperations;
+exports.CatalogueQueries = CatalogueQueries;
+exports.CheckoutOperations = CheckoutService;
+exports.CheckoutService = CheckoutService;
+exports.CimplifyElement = CimplifyElement;
+exports.CimplifyElements = CimplifyElements;
+exports.ELEMENT_TYPES = ELEMENT_TYPES;
+exports.EVENT_TYPES = EVENT_TYPES;
+exports.FxService = FxService;
+exports.InventoryService = InventoryService;
+exports.LinkService = LinkService;
+exports.LiteService = LiteService;
+exports.MESSAGE_TYPES = MESSAGE_TYPES;
+exports.OrderQueries = OrderQueries;
+exports.QueryBuilder = QueryBuilder;
+exports.SchedulingService = SchedulingService;
+exports.createElements = createElements;
+exports.generateIdempotencyKey = generateIdempotencyKey;
+exports.query = query;