@cimplify/sdk 0.6.1 → 0.6.3

package/dist/index.js

@@ -151,6 +151,63 @@ async function safe(promise) {
     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;
@@ -188,20 +245,34 @@ var CatalogueQueries = class {
     if (options?.offset) {
       query2 += `#offset(${options.offset})`;
     }
-    return safe(this.client.query(query2));
+    const result = await safe(this.client.query(query2));
+    if (!result.ok) return result;
+    return ok(result.value.map((product) => normalizeCatalogueProductPayload(product)));
   }
   async getProduct(id) {
-    return safe(this.client.query(`products.${id}`));
+    const result = await safe(this.client.query(`products.${id}`));
+    if (!result.ok) return result;
+    return ok(normalizeCatalogueProductPayload(result.value));
   }
   async getProductBySlug(slug) {
-    const result = await safe(
+    const filteredResult = await safe(
       this.client.query(`products[?(@.slug=='${slug}')]`)
     );
-    if (!result.ok) return result;
-    if (!result.value.length) {
+    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(result.value[0]);
+    return ok(normalizeCatalogueProductPayload(fallbackMatch));
   }
   async getVariants(productId) {
     return safe(this.client.query(`products.${productId}.variants`));
@@ -593,535 +664,1592 @@ var ORDER_MUTATION = {
 var DEFAULT_CURRENCY = "GHS";
 var DEFAULT_COUNTRY = "GHA";
 
-// src/checkout.ts
-function toCimplifyError3(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+// src/utils/price.ts
+var CURRENCY_SYMBOLS = {
+  // Major world currencies
+  USD: "$",
+  EUR: "\u20AC",
+  GBP: "\xA3",
+  JPY: "\xA5",
+  CNY: "\xA5",
+  CHF: "CHF",
+  CAD: "C$",
+  AUD: "A$",
+  NZD: "NZ$",
+  HKD: "HK$",
+  SGD: "S$",
+  INR: "\u20B9",
+  BRL: "R$",
+  MXN: "MX$",
+  KRW: "\u20A9",
+  RUB: "\u20BD",
+  TRY: "\u20BA",
+  THB: "\u0E3F",
+  PLN: "z\u0142",
+  SEK: "kr",
+  NOK: "kr",
+  DKK: "kr",
+  CZK: "K\u010D",
+  HUF: "Ft",
+  ILS: "\u20AA",
+  AED: "\u062F.\u0625",
+  SAR: "\uFDFC",
+  MYR: "RM",
+  PHP: "\u20B1",
+  IDR: "Rp",
+  VND: "\u20AB",
+  TWD: "NT$",
+  // African currencies
+  GHS: "GH\u20B5",
+  NGN: "\u20A6",
+  KES: "KSh",
+  ZAR: "R",
+  XOF: "CFA",
+  XAF: "FCFA",
+  EGP: "E\xA3",
+  MAD: "MAD",
+  TZS: "TSh",
+  UGX: "USh",
+  RWF: "FRw",
+  ETB: "Br",
+  ZMW: "ZK",
+  BWP: "P",
+  MUR: "\u20A8",
+  SCR: "\u20A8",
+  NAD: "N$",
+  SZL: "E",
+  LSL: "L",
+  MWK: "MK",
+  AOA: "Kz",
+  CDF: "FC",
+  GMD: "D",
+  GNF: "FG",
+  LRD: "L$",
+  SLL: "Le",
+  MZN: "MT",
+  SDG: "SDG",
+  SSP: "SSP",
+  SOS: "Sh.So.",
+  DJF: "Fdj",
+  ERN: "Nfk",
+  CVE: "$",
+  STN: "Db",
+  KMF: "CF",
+  BIF: "FBu"
+};
+function getCurrencySymbol(currencyCode) {
+  return CURRENCY_SYMBOLS[currencyCode.toUpperCase()] || currencyCode;
+}
+function formatNumberCompact(value, decimals = 1) {
+  const absValue = Math.abs(value);
+  const sign = value < 0 ? "-" : "";
+  if (absValue >= 1e9) {
+    return `${sign}${(absValue / 1e9).toFixed(decimals)}B`;
   }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+  if (absValue >= 1e6) {
+    return `${sign}${(absValue / 1e6).toFixed(decimals)}M`;
+  }
+  if (absValue >= 1e3) {
+    return `${sign}${(absValue / 1e3).toFixed(decimals)}K`;
+  }
+  return `${sign}${absValue.toFixed(decimals)}`;
 }
-async function safe3(promise) {
+function formatPrice(amount, currency = "GHS", locale = "en-US") {
+  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (isNaN(numAmount)) {
+    return `${getCurrencySymbol(currency)}0.00`;
+  }
   try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError3(error));
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currency.toUpperCase(),
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2
+    }).format(numAmount);
+  } catch {
+    return `${getCurrencySymbol(currency)}${numAmount.toFixed(2)}`;
   }
 }
-function generateIdempotencyKey() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return `idem_${crypto.randomUUID()}`;
+function formatPriceAdjustment(amount, currency = "GHS", locale = "en-US") {
+  const formatted = formatPrice(Math.abs(amount), currency, locale);
+  if (amount > 0) {
+    return `+${formatted}`;
+  } else if (amount < 0) {
+    return `-${formatted}`;
   }
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 15);
-  return `idem_${timestamp}_${random}`;
+  return formatted;
 }
-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
-      })
-    );
+function formatPriceCompact(amount, currency = "GHS", decimals = 1) {
+  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (isNaN(numAmount)) {
+    return `${getCurrencySymbol(currency)}0`;
   }
-  async initializePayment(orderId, method) {
-    return safe3(
-      this.client.call("order.initializePayment", {
-        order_id: orderId,
-        payment_method: method
-      })
-    );
+  const symbol = getCurrencySymbol(currency);
+  if (Math.abs(numAmount) < 1e3) {
+    return `${symbol}${numAmount.toFixed(2)}`;
   }
-  async submitAuthorization(input) {
-    return safe3(
-      this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
-    );
+  return `${symbol}${formatNumberCompact(numAmount, decimals)}`;
+}
+function formatMoney(amount, currency = "GHS") {
+  const symbol = getCurrencySymbol(currency);
+  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (isNaN(numAmount)) {
+    return `${symbol}0.00`;
   }
-  async pollPaymentStatus(orderId) {
-    return safe3(
-      this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
-    );
+  return `${symbol}${numAmount.toFixed(2)}`;
+}
+function parsePrice(value) {
+  if (value === void 0 || value === null) {
+    return 0;
   }
-  async updateOrderCustomer(orderId, customer) {
-    return safe3(
-      this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
-        order_id: orderId,
-        ...customer
-      })
-    );
+  if (typeof value === "number") {
+    return isNaN(value) ? 0 : value;
   }
-  async verifyPayment(orderId) {
-    return safe3(
-      this.client.call("order.verifyPayment", {
-        order_id: orderId
-      })
-    );
+  const cleaned = value.replace(/[^\d.-]/g, "");
+  const parsed = parseFloat(cleaned);
+  return isNaN(parsed) ? 0 : parsed;
+}
+function getDisplayPrice(product) {
+  if (product.price_info) {
+    return parsePrice(product.price_info.final_price);
   }
-};
-
-// src/orders.ts
-function toCimplifyError4(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  if (product.final_price !== void 0 && product.final_price !== null) {
+    return parsePrice(product.final_price);
   }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
-}
-async function safe4(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError4(error));
+  if (product.default_price !== void 0 && product.default_price !== null) {
+    return parsePrice(product.default_price);
   }
+  return 0;
 }
-var OrderQueries = class {
-  constructor(client) {
-    this.client = client;
+function getBasePrice(product) {
+  if (product.price_info) {
+    return parsePrice(product.price_info.base_price);
   }
-  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));
+  if (product.base_price !== void 0 && product.base_price !== null) {
+    return parsePrice(product.base_price);
   }
-  async get(orderId) {
-    return safe4(this.client.query(`orders.${orderId}`));
+  if (product.default_price !== void 0 && product.default_price !== null) {
+    return parsePrice(product.default_price);
   }
-  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);
+  return 0;
 }
-async function safe5(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError5(error));
-  }
+function isOnSale(product) {
+  const basePrice = getBasePrice(product);
+  const finalPrice = getDisplayPrice(product);
+  return basePrice > finalPrice && basePrice > 0;
 }
-var LinkService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async requestOtp(input) {
-    return safe5(this.client.linkPost("/v1/link/auth/request-otp", input));
+function getDiscountPercentage(product) {
+  const basePrice = getBasePrice(product);
+  const finalPrice = getDisplayPrice(product);
+  if (basePrice > finalPrice && basePrice > 0) {
+    return Math.round((basePrice - finalPrice) / basePrice * 100);
   }
-  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;
+  return 0;
+}
+function getMarkupPercentage(product) {
+  const basePrice = getBasePrice(product);
+  const finalPrice = getDisplayPrice(product);
+  if (finalPrice > basePrice && basePrice > 0) {
+    return Math.round((finalPrice - basePrice) / basePrice * 100);
   }
-  async logout() {
-    const result = await safe5(this.client.linkPost("/v1/link/auth/logout"));
-    if (result.ok) {
-      this.client.clearSession();
-    }
-    return result;
+  return 0;
+}
+function getProductCurrency(product) {
+  if (product.price_info?.currency) {
+    return product.price_info.currency;
   }
-  async checkStatus(contact) {
-    return safe5(
-      this.client.call(LINK_MUTATION.CHECK_STATUS, {
-        contact
-      })
-    );
+  if (product.currency) {
+    return product.currency;
   }
-  async getLinkData() {
-    return safe5(this.client.query(LINK_QUERY.DATA));
+  return "GHS";
+}
+function formatProductPrice(product, locale = "en-US") {
+  const price = getDisplayPrice(product);
+  const currency = getProductCurrency(product);
+  return formatPrice(price, currency, locale);
+}
+
+// src/utils/payment.ts
+function categorizePaymentError(error, errorCode) {
+  let message = "An unexpected error occurred during payment processing. Please try again or contact support.";
+  let recoverable = true;
+  let code = errorCode || "PAYMENT_ERROR";
+  const technical = error.stack;
+  const errorMessage = error.message?.toLowerCase() || "";
+  if (errorCode === "INSUFFICIENT_FUNDS" || errorMessage.includes("insufficient") || errorMessage.includes("funds")) {
+    code = "INSUFFICIENT_FUNDS";
+    message = "Your payment method has insufficient funds. Please try another payment method.";
+  } else if (errorCode === "CARD_DECLINED" || errorMessage.includes("declined")) {
+    code = "CARD_DECLINED";
+    message = "Your card was declined. Please try another card or payment method.";
+  } else if (errorMessage.includes("cancelled") || errorMessage.includes("canceled") || errorCode === "PAYMENT_CANCELLED") {
+    code = "PAYMENT_CANCELLED";
+    message = "Payment was cancelled. You can try again when ready.";
+  } else if (errorMessage.includes("network") || errorMessage.includes("connection") || errorCode === "NETWORK_ERROR") {
+    code = "NETWORK_ERROR";
+    message = "Network connection issue. Please check your internet connection and try again.";
+  } else if (errorMessage.includes("timeout") || errorCode === "TIMEOUT") {
+    code = "TIMEOUT";
+    message = "Payment processing timed out. Please try again.";
+  } else if (errorCode === "PAYMENT_ACTION_NOT_COMPLETED") {
+    code = "PAYMENT_ACTION_NOT_COMPLETED";
+    message = "Payment action was not completed. Please try again.";
+  } else if (errorCode === "AUTHORIZATION_FAILED") {
+    code = "AUTHORIZATION_FAILED";
+    message = "Authorization failed. Please check your code and try again.";
+  } else if (errorCode === "INVALID_OTP") {
+    code = "INVALID_OTP";
+    message = "Invalid verification code. Please check and try again.";
   }
-  async getAddresses() {
-    return safe5(this.client.query(LINK_QUERY.ADDRESSES));
+  return { code, message, recoverable, technical };
+}
+function isQuickPaymentResponse(response) {
+  return response !== null && typeof response === "object" && "payment" in response && typeof response.payment === "object";
+}
+function isWebPaymentResponse(response) {
+  return response !== null && typeof response === "object" && "transaction" in response && typeof response.transaction === "object";
+}
+function normalizePaymentResponse(response) {
+  if (!response) {
+    return {
+      method: "unknown",
+      provider: "unknown",
+      requires_action: false,
+      metadata: {}
+    };
   }
-  async getMobileMoney() {
-    return safe5(this.client.query(LINK_QUERY.MOBILE_MONEY));
+  if (isQuickPaymentResponse(response)) {
+    return {
+      method: response.payment.type?.toLowerCase() || "unknown",
+      provider: response.payment.provider?.toLowerCase() || "unknown",
+      requires_action: !!response.payment.redirect_url || !!response.payment.access_code,
+      public_key: response.payment.public_key,
+      client_secret: response.payment.access_code,
+      access_code: response.payment.access_code,
+      redirect_url: response.payment.redirect_url,
+      transaction_id: response.payment.reference,
+      order_id: response.order_id,
+      reference: response.payment.reference,
+      instructions: response.payment.instructions,
+      metadata: response.payment.metadata
+    };
   }
-  async getPreferences() {
-    return safe5(this.client.query(LINK_QUERY.PREFERENCES));
+  if (isWebPaymentResponse(response)) {
+    const authType = response.authorization_type?.toLowerCase();
+    const validAuthTypes = ["otp", "pin", "phone", "birthday", "address"];
+    const safeAuthType = authType && validAuthTypes.includes(authType) ? authType : void 0;
+    return {
+      provider: response.transaction.provider_type?.toLowerCase() || "unknown",
+      requires_action: response.requires_action || false,
+      public_key: response.public_key,
+      client_secret: response.client_secret,
+      redirect_url: response.authorization_url,
+      transaction_id: response.transaction.id,
+      order_id: response.transaction.order_id,
+      reference: response.transaction.provider_reference,
+      metadata: response.transaction.metadata,
+      method: response.transaction.payment_method?.toLowerCase() || "unknown",
+      instructions: response.display_text,
+      display_text: response.display_text,
+      requires_authorization: response.requires_authorization,
+      authorization_type: safeAuthType,
+      provider_payment_id: response.provider_payment_id || response.transaction.provider_reference
+    };
   }
-  async enroll(data) {
-    return safe5(this.client.call(LINK_MUTATION.ENROLL, data));
+  return {
+    method: "unknown",
+    provider: "unknown",
+    requires_action: false,
+    metadata: {}
+  };
+}
+var PAYMENT_SUCCESS_STATUSES = /* @__PURE__ */ new Set([
+  "success",
+  "succeeded",
+  "paid",
+  "captured",
+  "completed",
+  "authorized"
+]);
+var PAYMENT_FAILURE_STATUSES = /* @__PURE__ */ new Set([
+  "failed",
+  "declined",
+  "cancelled",
+  "voided",
+  "error"
+]);
+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"
+    };
   }
-  async enrollAndLinkOrder(data) {
-    return safe5(
-      this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data)
-    );
+  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 || ""
+  };
+}
+var MOBILE_MONEY_PROVIDERS = {
+  mtn: { name: "MTN Mobile Money", prefix: ["024", "054", "055", "059"] },
+  vodafone: { name: "Vodafone Cash", prefix: ["020", "050"] },
+  airtel: { name: "AirtelTigo Money", prefix: ["027", "057", "026", "056"] }
+};
+function detectMobileMoneyProvider(phoneNumber) {
+  const cleaned = phoneNumber.replace(/\D/g, "");
+  const prefix = cleaned.slice(-9, -6);
+  for (const [provider, info] of Object.entries(MOBILE_MONEY_PROVIDERS)) {
+    if (info.prefix.some((p) => prefix.startsWith(p.slice(1)))) {
+      return provider;
+    }
   }
-  async updatePreferences(preferences) {
-    return safe5(this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences));
+  return null;
+}
+
+// src/utils/paystack.ts
+async function openPaystackPopup(options, signal) {
+  if (typeof window === "undefined") {
+    return { success: false, error: "PAYSTACK_UNAVAILABLE" };
   }
-  async createAddress(input) {
-    return safe5(this.client.call(LINK_MUTATION.CREATE_ADDRESS, input));
+  let PaystackPop;
+  try {
+    const imported = await import('@paystack/inline-js');
+    PaystackPop = imported.default;
+  } catch {
+    return { success: false, error: "PAYSTACK_UNAVAILABLE" };
   }
-  async updateAddress(input) {
-    return safe5(this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input));
+  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;
+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);
   }
-  async deleteAddress(addressId) {
-    return safe5(this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId));
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value;
   }
-  async setDefaultAddress(addressId) {
-    return safe5(this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId));
+  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;
   }
-  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)
+  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.allowCardPopup = options.allowCardPopup ?? false;
+  }
+  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) {
+        if (!this.allowCardPopup) {
+          return this.fail(
+            "PAYSTACK_HANDOFF_REQUIRED",
+            "Card authorization requires Elements. Use elements.processCheckout() for card flows.",
+            true
+          );
+        }
+        this.emit("awaiting_authorization", {
+          authorization_type: authorizationType,
+          display_text: "Complete payment in the card authorization popup.",
+          order_id: checkoutResult.order_id,
+          order_number: checkoutResult.order_number,
+          provider: checkoutResult.provider ?? "paystack"
+        });
+        const popupResult = await openPaystackPopup(
+          {
+            key: checkoutResult.public_key,
+            email: this.checkoutData.customer.email || "customer@cimplify.io",
+            accessCode: checkoutResult.client_secret,
+            reference: paymentReference || checkoutResult.client_secret,
+            currency: this.getOrderCurrency(checkoutResult)
+          },
+          this.signal
+        );
+        if (!popupResult.success) {
+          if (popupResult.error === "POPUP_BLOCKED" || popupResult.error === "PAYSTACK_UNAVAILABLE") {
+            return this.fail(
+              "POPUP_BLOCKED",
+              "Unable to open card payment popup. Please allow popups and try again.",
+              true
+            );
+          }
+          return this.fail(
+            popupResult.error || "PAYMENT_CANCELLED",
+            "Card payment was cancelled before completion.",
+            true
+          );
+        }
+      }
+      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 trackMobileMoneyUsage(mobileMoneyId) {
-    return safe5(
-      this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
-        mobile_money_id: mobileMoneyId
-      })
-    );
+  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 verifyMobileMoney(mobileMoneyId) {
-    return safe5(
-      this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
-    );
+  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 getSessions() {
-    return safe5(this.client.linkGet("/v1/link/sessions"));
+  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;
+    }
   }
-  async revokeSession(sessionId) {
-    return safe5(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
+  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
+    };
   }
-  async revokeAllSessions() {
-    return safe5(this.client.linkDelete("/v1/link/sessions"));
+  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;
   }
-  async getAddressesRest() {
-    return safe5(this.client.linkGet("/v1/link/addresses"));
+  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";
   }
-  async createAddressRest(input) {
-    return safe5(this.client.linkPost("/v1/link/addresses", input));
+  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";
   }
-  async deleteAddressRest(addressId) {
-    return safe5(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
+  emit(status, context = {}) {
+    if (!this.onStatusChange) {
+      return;
+    }
+    try {
+      this.onStatusChange(status, context);
+    } catch {
+    }
   }
-  async setDefaultAddressRest(addressId) {
-    return safe5(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
+  fail(code, message, recoverable) {
+    this.emit("failed", {
+      display_text: message
+    });
+    return {
+      success: false,
+      error: {
+        code,
+        message,
+        recoverable
+      }
+    };
   }
-  async getMobileMoneyRest() {
-    return safe5(this.client.linkGet("/v1/link/mobile-money"));
+  isSuccessfulStatus(status) {
+    const normalized = normalizeStatusResponse({ status, paid: false });
+    return normalized.paid || isPaymentStatusSuccess(normalized.status);
   }
-  async createMobileMoneyRest(input) {
-    return safe5(this.client.linkPost("/v1/link/mobile-money", input));
+  isFailureStatus(status) {
+    const normalized = normalizeStatusResponse({ status, paid: false });
+    return isPaymentStatusFailure(normalized.status);
   }
-  async deleteMobileMoneyRest(mobileMoneyId) {
-    return safe5(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
+  ensureNotAborted() {
+    if (this.signal?.aborted) {
+      throw createAbortError();
+    }
   }
-  async setDefaultMobileMoneyRest(mobileMoneyId) {
-    return safe5(
-      this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
-    );
+  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/auth.ts
-function toCimplifyError6(error) {
+// 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 safe6(promise) {
+async function safe3(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError6(error));
+    return err(toCimplifyError3(error));
   }
 }
-var AuthService = class {
+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 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 process(data) {
+    const checkoutData = {
+      ...data,
+      idempotency_key: data.idempotency_key || generateIdempotencyKey()
+    };
+    return safe3(
+      this.client.call(CHECKOUT_MUTATION.PROCESS, {
+        checkout_data: checkoutData
       })
     );
   }
-  async verifyOtp(code, contact) {
-    return safe6(
-      this.client.call(AUTH_MUTATION.VERIFY_OTP, {
-        otp_code: code,
-        contact
+  async initializePayment(orderId, method) {
+    return safe3(
+      this.client.call("order.initializePayment", {
+        order_id: orderId,
+        payment_method: method
       })
     );
   }
-  async logout() {
-    return safe6(this.client.call("auth.logout"));
+  async submitAuthorization(input) {
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
+    );
   }
-  async updateProfile(input) {
-    return safe6(this.client.call("auth.update_profile", input));
+  async pollPaymentStatus(orderId) {
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
+    );
   }
-  async changePassword(input) {
-    return safe6(this.client.call("auth.change_password", input));
+  async updateOrderCustomer(orderId, customer) {
+    return safe3(
+      this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
+        order_id: orderId,
+        ...customer
+      })
+    );
   }
-  async resetPassword(email) {
-    return safe6(this.client.call("auth.reset_password", { email }));
+  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,
+      allowCardPopup: false
+    });
+    const resolved = await resolver.resolve(processResult.value);
+    return ok(resolved);
   }
 };
 
-// src/business.ts
-function toCimplifyError7(error) {
+// 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 safe7(promise) {
+async function safe4(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError7(error));
+    return err(toCimplifyError4(error));
   }
 }
-var BusinessService = class {
+var OrderQueries = 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 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 getLocation(locationId) {
-    return safe7(this.client.query(`business.locations.${locationId}`));
+  async get(orderId) {
+    return safe4(this.client.query(`orders.${orderId}`));
   }
-  async getHours() {
-    return safe7(this.client.query("business.hours"));
+  async getRecent(limit = 5) {
+    return safe4(this.client.query(`orders#sort(created_at,desc)#limit(${limit})`));
   }
-  async getLocationHours(locationId) {
-    return safe7(this.client.query(`business.locations.${locationId}.hours`));
+  async getByStatus(status) {
+    return safe4(this.client.query(`orders[?(@.status=='${status}')]`));
   }
-  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
-    });
+  async cancel(orderId, reason) {
+    return safe4(
+      this.client.call("order.cancelOrder", {
+        order_id: orderId,
+        reason
+      })
+    );
   }
 };
 
-// src/inventory.ts
-function toCimplifyError8(error) {
+// 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 safe8(promise) {
+async function safe5(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError8(error));
+    return err(toCimplifyError5(error));
   }
 }
-var InventoryService = class {
+var LinkService = class {
   constructor(client) {
     this.client = client;
   }
-  async getStockLevels() {
-    return safe8(this.client.query("inventory.stock_levels"));
+  async requestOtp(input) {
+    return safe5(this.client.linkPost("/v1/link/auth/request-otp", input));
   }
-  async getProductStock(productId, locationId) {
-    if (locationId) {
-      return safe8(
-        this.client.query("inventory.product", {
-          product_id: productId,
-          location_id: locationId
-        })
-      );
+  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 safe8(
-      this.client.query("inventory.product", {
-        product_id: productId
+    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 getVariantStock(variantId, locationId) {
-    return safe8(
-      this.client.query("inventory.variant", {
-        variant_id: variantId,
-        location_id: locationId
-      })
+  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 checkProductAvailability(productId, quantity, locationId) {
-    return safe8(
-      this.client.query("inventory.check_availability", {
-        product_id: productId,
-        quantity,
-        location_id: locationId
+  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 checkVariantAvailability(variantId, quantity, locationId) {
-    return safe8(
-      this.client.query("inventory.check_availability", {
-        variant_id: variantId,
-        quantity,
-        location_id: locationId
+  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 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)
-      )
+  async verifyMobileMoney(mobileMoneyId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
     );
-    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 getSessions() {
+    return safe5(this.client.linkGet("/v1/link/sessions"));
   }
-  async isInStock(productId, locationId) {
-    const result = await this.checkProductAvailability(productId, 1, locationId);
-    if (!result.ok) return result;
-    return ok(result.value.is_available);
+  async revokeSession(sessionId) {
+    return safe5(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
   }
-  async getAvailableQuantity(productId, locationId) {
-    const result = await this.getProductStock(productId, locationId);
-    if (!result.ok) return result;
-    return ok(result.value.available_quantity);
+  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/scheduling.ts
-function toVariables(input) {
-  return Object.fromEntries(Object.entries(input));
-}
-function toCimplifyError9(error) {
+// 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 safe9(promise) {
+async function safe6(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError9(error));
+    return err(toCimplifyError6(error));
   }
 }
-var SchedulingService = class {
+var AuthService = class {
   constructor(client) {
     this.client = client;
   }
-  async getServices() {
-    return safe9(this.client.query("scheduling.services"));
+  async getStatus() {
+    return safe6(this.client.query("auth"));
   }
-  /**
-   * 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();
+  async getCurrentUser() {
+    const result = await this.getStatus();
     if (!result.ok) return result;
-    return ok(result.value.find((s) => s.id === serviceId) || null);
+    return ok(result.value.customer || null);
   }
-  async getAvailableSlots(input) {
+  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))
     );
@@ -1291,6 +2419,8 @@ var MESSAGE_TYPES = {
   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",
@@ -1301,7 +2431,9 @@ var MESSAGE_TYPES = {
   ADDRESS_SELECTED: "address_selected",
   PAYMENT_METHOD_SELECTED: "payment_method_selected",
   TOKEN_REFRESHED: "token_refreshed",
-  LOGOUT_COMPLETE: "logout_complete"
+  LOGOUT_COMPLETE: "logout_complete",
+  CHECKOUT_STATUS: "checkout_status",
+  CHECKOUT_COMPLETE: "checkout_complete"
 };
 var EVENT_TYPES = {
   READY: "ready",
@@ -1314,38 +2446,14 @@ var EVENT_TYPES = {
 };
 
 // src/elements.ts
-function mapOrderType(orderType) {
-  if (orderType === "dine_in") return "dine-in";
-  return orderType ?? "delivery";
-}
-function toCheckoutFormData(data) {
+function toCheckoutError(code, message, recoverable) {
   return {
-    cart_id: data.cart_id,
-    customer: {
-      name: "",
-      email: "",
-      phone: "",
-      save_details: false
-    },
-    order_type: mapOrderType(data.order_type),
-    address_info: data.address ? {
-      street_address: data.address.street_address,
-      apartment: data.address.apartment,
-      city: data.address.city,
-      region: data.address.region,
-      postal_code: data.address.postal_code,
-      country: data.address.country,
-      delivery_instructions: data.address.delivery_instructions,
-      phone_for_delivery: data.address.phone_for_delivery
-    } : {},
-    payment_method: data.payment_method?.type ?? "mobile_money",
-    mobile_money_details: data.payment_method?.type === "mobile_money" && data.payment_method.phone_number ? {
-      phone_number: data.payment_method.phone_number,
-      provider: data.payment_method.provider ?? "mtn"
-    } : void 0,
-    special_instructions: data.notes,
-    link_address_id: data.address?.id,
-    link_payment_method_id: data.payment_method?.id
+    success: false,
+    error: {
+      code,
+      message,
+      recoverable
+    }
   };
 }
 var DEFAULT_LINK_URL = "https://link.cimplify.io";
@@ -1364,14 +2472,27 @@ function isAllowedOrigin(origin) {
     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.client = client;
     this.businessId = businessId;
     this.linkUrl = options.linkUrl || DEFAULT_LINK_URL;
@@ -1399,54 +2520,242 @@ var CimplifyElements = class {
     }
   }
   async submitCheckout(data) {
-    const addressElement = this.elements.get(ELEMENT_TYPES.ADDRESS);
-    if (addressElement) await addressElement.getData();
-    const paymentElement = this.elements.get(ELEMENT_TYPES.PAYMENT);
-    if (paymentElement) await paymentElement.getData();
-    const internalData = {
-      ...data,
-      customer: this.accountId ? { account_id: this.accountId, customer_id: this.customerId } : void 0,
-      address: this.addressData,
-      payment_method: this.paymentData
-    };
-    const checkoutFormData = toCheckoutFormData(internalData);
-    const result = await this.client.checkout.process(checkoutFormData);
-    if (result.ok) {
+    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.value.order_id,
-          status: result.value.payment_status,
-          total: ""
-          // Total is not returned by checkout result
+          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"
+        code: result.error?.code || "CHECKOUT_FAILED",
+        message: result.error?.message || "Checkout failed"
       }
     };
   }
-  isAuthenticated() {
-    return this.accessToken !== null;
-  }
-  getAccessToken() {
-    return this.accessToken;
-  }
-  handleMessage(event) {
-    if (!isAllowedOrigin(event.origin)) {
-      return;
-    }
-    const message = event.data;
-    if (!message?.type) return;
-    switch (message.type) {
-      case MESSAGE_TYPES.AUTHENTICATED:
-        this.accessToken = message.token;
-        this.accountId = message.accountId;
-        this.customerId = message.customerId;
+  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();
+  }
+  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 });
@@ -1464,11 +2773,16 @@ var CimplifyElements = class {
         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;
     }
   }
@@ -1518,6 +2832,8 @@ var CimplifyElement = class {
     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);
     }
@@ -1532,16 +2848,21 @@ var CimplifyElement = class {
     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);
-      this.resolvers.set(id, resolve);
-      this.sendMessage({ type: MESSAGE_TYPES.GET_DATA });
-      setTimeout(() => {
-        if (this.resolvers.has(id)) {
-          this.resolvers.delete(id);
-          resolve(null);
+      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) {
@@ -1549,6 +2870,12 @@ var CimplifyElement = class {
       this.iframe.contentWindow.postMessage(message, this.linkUrl);
     }
   }
+  getContentWindow() {
+    return this.iframe?.contentWindow ?? null;
+  }
+  isMounted() {
+    return this.mounted && Boolean(this.iframe) && this.iframe?.isConnected === true;
+  }
   createIframe() {
     if (!this.container) return;
     const iframe = document.createElement("iframe");
@@ -1563,14 +2890,21 @@ var CimplifyElement = class {
     iframe.style.overflow = "hidden";
     iframe.setAttribute("allowtransparency", "true");
     iframe.setAttribute("frameborder", "0");
-    iframe.setAttribute("sandbox", "allow-scripts allow-same-origin allow-forms allow-popups");
+    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: this.businessId,
-        prefillEmail: this.options.prefillEmail
+        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) {
@@ -1582,8 +2916,8 @@ var CimplifyElement = class {
     if (!isAllowedOrigin(event.origin)) {
       return;
     }
-    const message = event.data;
-    if (!message?.type) return;
+    const message = parseIframeMessage(event.data);
+    if (!message) return;
     switch (message.type) {
       case MESSAGE_TYPES.READY:
         this.emit(EVENT_TYPES.READY, { height: message.height });
@@ -1592,10 +2926,16 @@ var CimplifyElement = class {
         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
+          token: message.token,
+          customer
         });
         break;
       case MESSAGE_TYPES.REQUIRES_OTP:
@@ -1621,7 +2961,10 @@ var CimplifyElement = class {
     this.eventHandlers.get(event)?.forEach((handler) => handler(data));
   }
   resolveData(data) {
-    this.resolvers.forEach((resolve) => resolve(data));
+    this.resolvers.forEach((entry) => {
+      clearTimeout(entry.timeoutId);
+      entry.resolve(data);
+    });
     this.resolvers.clear();
   }
 };
@@ -1730,6 +3073,9 @@ var CimplifyClient = class {
   getAccessToken() {
     return this.accessToken;
   }
+  getPublicKey() {
+    return this.publicKey;
+  }
   setAccessToken(token) {
     const previous = this.accessToken;
     this.accessToken = token;
@@ -2036,463 +3382,119 @@ var CimplifyClient = class {
   }
   get business() {
     if (!this._business) {
-      this._business = new BusinessService(this);
-    }
-    return this._business;
-  }
-  get inventory() {
-    if (!this._inventory) {
-      this._inventory = new InventoryService(this);
-    }
-    return this._inventory;
-  }
-  get scheduling() {
-    if (!this._scheduling) {
-      this._scheduling = new SchedulingService(this);
-    }
-    return this._scheduling;
-  }
-  get lite() {
-    if (!this._lite) {
-      this._lite = new LiteService(this);
-    }
-    return this._lite;
-  }
-  get fx() {
-    if (!this._fx) {
-      this._fx = new FxService(this);
-    }
-    return this._fx;
-  }
-  /**
-   * Create a CimplifyElements instance for embedding checkout components.
-   * Like Stripe's stripe.elements().
-   *
-   * @param businessId - The business ID for checkout context
-   * @param options - Optional configuration for elements
-   *
-   * @example
-   * ```ts
-   * const elements = client.elements('bus_xxx');
-   * const authElement = elements.create('auth');
-   * authElement.mount('#auth-container');
-   * ```
-   */
-  elements(businessId, options) {
-    return createElements(this, businessId, options);
-  }
-};
-function createCimplifyClient(config = {}) {
-  return new CimplifyClient(config);
-}
-
-// 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);
-}
-
-// src/utils/price.ts
-var CURRENCY_SYMBOLS = {
-  // Major world currencies
-  USD: "$",
-  EUR: "\u20AC",
-  GBP: "\xA3",
-  JPY: "\xA5",
-  CNY: "\xA5",
-  CHF: "CHF",
-  CAD: "C$",
-  AUD: "A$",
-  NZD: "NZ$",
-  HKD: "HK$",
-  SGD: "S$",
-  INR: "\u20B9",
-  BRL: "R$",
-  MXN: "MX$",
-  KRW: "\u20A9",
-  RUB: "\u20BD",
-  TRY: "\u20BA",
-  THB: "\u0E3F",
-  PLN: "z\u0142",
-  SEK: "kr",
-  NOK: "kr",
-  DKK: "kr",
-  CZK: "K\u010D",
-  HUF: "Ft",
-  ILS: "\u20AA",
-  AED: "\u062F.\u0625",
-  SAR: "\uFDFC",
-  MYR: "RM",
-  PHP: "\u20B1",
-  IDR: "Rp",
-  VND: "\u20AB",
-  TWD: "NT$",
-  // African currencies
-  GHS: "GH\u20B5",
-  NGN: "\u20A6",
-  KES: "KSh",
-  ZAR: "R",
-  XOF: "CFA",
-  XAF: "FCFA",
-  EGP: "E\xA3",
-  MAD: "MAD",
-  TZS: "TSh",
-  UGX: "USh",
-  RWF: "FRw",
-  ETB: "Br",
-  ZMW: "ZK",
-  BWP: "P",
-  MUR: "\u20A8",
-  SCR: "\u20A8",
-  NAD: "N$",
-  SZL: "E",
-  LSL: "L",
-  MWK: "MK",
-  AOA: "Kz",
-  CDF: "FC",
-  GMD: "D",
-  GNF: "FG",
-  LRD: "L$",
-  SLL: "Le",
-  MZN: "MT",
-  SDG: "SDG",
-  SSP: "SSP",
-  SOS: "Sh.So.",
-  DJF: "Fdj",
-  ERN: "Nfk",
-  CVE: "$",
-  STN: "Db",
-  KMF: "CF",
-  BIF: "FBu"
-};
-function getCurrencySymbol(currencyCode) {
-  return CURRENCY_SYMBOLS[currencyCode.toUpperCase()] || currencyCode;
-}
-function formatNumberCompact(value, decimals = 1) {
-  const absValue = Math.abs(value);
-  const sign = value < 0 ? "-" : "";
-  if (absValue >= 1e9) {
-    return `${sign}${(absValue / 1e9).toFixed(decimals)}B`;
-  }
-  if (absValue >= 1e6) {
-    return `${sign}${(absValue / 1e6).toFixed(decimals)}M`;
-  }
-  if (absValue >= 1e3) {
-    return `${sign}${(absValue / 1e3).toFixed(decimals)}K`;
-  }
-  return `${sign}${absValue.toFixed(decimals)}`;
-}
-function formatPrice(amount, currency = "GHS", locale = "en-US") {
-  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
-  if (isNaN(numAmount)) {
-    return `${getCurrencySymbol(currency)}0.00`;
-  }
-  try {
-    return new Intl.NumberFormat(locale, {
-      style: "currency",
-      currency: currency.toUpperCase(),
-      minimumFractionDigits: 2,
-      maximumFractionDigits: 2
-    }).format(numAmount);
-  } catch {
-    return `${getCurrencySymbol(currency)}${numAmount.toFixed(2)}`;
-  }
-}
-function formatPriceAdjustment(amount, currency = "GHS", locale = "en-US") {
-  const formatted = formatPrice(Math.abs(amount), currency, locale);
-  if (amount > 0) {
-    return `+${formatted}`;
-  } else if (amount < 0) {
-    return `-${formatted}`;
-  }
-  return formatted;
-}
-function formatPriceCompact(amount, currency = "GHS", decimals = 1) {
-  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
-  if (isNaN(numAmount)) {
-    return `${getCurrencySymbol(currency)}0`;
-  }
-  const symbol = getCurrencySymbol(currency);
-  if (Math.abs(numAmount) < 1e3) {
-    return `${symbol}${numAmount.toFixed(2)}`;
-  }
-  return `${symbol}${formatNumberCompact(numAmount, decimals)}`;
-}
-function formatMoney(amount, currency = "GHS") {
-  const symbol = getCurrencySymbol(currency);
-  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
-  if (isNaN(numAmount)) {
-    return `${symbol}0.00`;
-  }
-  return `${symbol}${numAmount.toFixed(2)}`;
-}
-function parsePrice(value) {
-  if (value === void 0 || value === null) {
-    return 0;
-  }
-  if (typeof value === "number") {
-    return isNaN(value) ? 0 : value;
-  }
-  const cleaned = value.replace(/[^\d.-]/g, "");
-  const parsed = parseFloat(cleaned);
-  return isNaN(parsed) ? 0 : parsed;
-}
-function getDisplayPrice(product) {
-  if (product.price_info) {
-    return parsePrice(product.price_info.final_price);
-  }
-  if (product.final_price !== void 0 && product.final_price !== null) {
-    return parsePrice(product.final_price);
+      this._business = new BusinessService(this);
+    }
+    return this._business;
   }
-  if (product.default_price !== void 0 && product.default_price !== null) {
-    return parsePrice(product.default_price);
+  get inventory() {
+    if (!this._inventory) {
+      this._inventory = new InventoryService(this);
+    }
+    return this._inventory;
   }
-  return 0;
-}
-function getBasePrice(product) {
-  if (product.price_info) {
-    return parsePrice(product.price_info.base_price);
+  get scheduling() {
+    if (!this._scheduling) {
+      this._scheduling = new SchedulingService(this);
+    }
+    return this._scheduling;
   }
-  if (product.base_price !== void 0 && product.base_price !== null) {
-    return parsePrice(product.base_price);
+  get lite() {
+    if (!this._lite) {
+      this._lite = new LiteService(this);
+    }
+    return this._lite;
   }
-  if (product.default_price !== void 0 && product.default_price !== null) {
-    return parsePrice(product.default_price);
+  get fx() {
+    if (!this._fx) {
+      this._fx = new FxService(this);
+    }
+    return this._fx;
   }
-  return 0;
-}
-function isOnSale(product) {
-  const basePrice = getBasePrice(product);
-  const finalPrice = getDisplayPrice(product);
-  return basePrice > finalPrice && basePrice > 0;
-}
-function getDiscountPercentage(product) {
-  const basePrice = getBasePrice(product);
-  const finalPrice = getDisplayPrice(product);
-  if (basePrice > finalPrice && basePrice > 0) {
-    return Math.round((basePrice - finalPrice) / basePrice * 100);
+  /**
+   * Create a CimplifyElements instance for embedding checkout components.
+   * Like Stripe's stripe.elements().
+   *
+   * @param businessId - The business ID for checkout context
+   * @param options - Optional configuration for elements
+   *
+   * @example
+   * ```ts
+   * const elements = client.elements('bus_xxx');
+   * const authElement = elements.create('auth');
+   * authElement.mount('#auth-container');
+   * ```
+   */
+  elements(businessId, options) {
+    return createElements(this, businessId, options);
   }
-  return 0;
+};
+function createCimplifyClient(config = {}) {
+  return new CimplifyClient(config);
 }
-function getMarkupPercentage(product) {
-  const basePrice = getBasePrice(product);
-  const finalPrice = getDisplayPrice(product);
-  if (finalPrice > basePrice && basePrice > 0) {
-    return Math.round((finalPrice - basePrice) / basePrice * 100);
+
+// src/query/builder.ts
+var QueryBuilder = class {
+  constructor(entity) {
+    this.filters = [];
+    this.modifiers = [];
+    this.pathSegments = [];
+    this.entity = entity;
   }
-  return 0;
-}
-function getProductCurrency(product) {
-  if (product.price_info?.currency) {
-    return product.price_info.currency;
+  path(segment) {
+    this.pathSegments.push(segment);
+    return this;
   }
-  if (product.currency) {
-    return product.currency;
+  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;
   }
-  return "GHS";
-}
-function formatProductPrice(product, locale = "en-US") {
-  const price = getDisplayPrice(product);
-  const currency = getProductCurrency(product);
-  return formatPrice(price, currency, locale);
-}
-
-// src/utils/payment.ts
-function categorizePaymentError(error, errorCode) {
-  let message = "An unexpected error occurred during payment processing. Please try again or contact support.";
-  let recoverable = true;
-  let code = errorCode || "PAYMENT_ERROR";
-  const technical = error.stack;
-  const errorMessage = error.message?.toLowerCase() || "";
-  if (errorCode === "INSUFFICIENT_FUNDS" || errorMessage.includes("insufficient") || errorMessage.includes("funds")) {
-    code = "INSUFFICIENT_FUNDS";
-    message = "Your payment method has insufficient funds. Please try another payment method.";
-  } else if (errorCode === "CARD_DECLINED" || errorMessage.includes("declined")) {
-    code = "CARD_DECLINED";
-    message = "Your card was declined. Please try another card or payment method.";
-  } else if (errorMessage.includes("cancelled") || errorMessage.includes("canceled") || errorCode === "PAYMENT_CANCELLED") {
-    code = "PAYMENT_CANCELLED";
-    message = "Payment was cancelled. You can try again when ready.";
-  } else if (errorMessage.includes("network") || errorMessage.includes("connection") || errorCode === "NETWORK_ERROR") {
-    code = "NETWORK_ERROR";
-    message = "Network connection issue. Please check your internet connection and try again.";
-  } else if (errorMessage.includes("timeout") || errorCode === "TIMEOUT") {
-    code = "TIMEOUT";
-    message = "Payment processing timed out. Please try again.";
-  } else if (errorCode === "PAYMENT_ACTION_NOT_COMPLETED") {
-    code = "PAYMENT_ACTION_NOT_COMPLETED";
-    message = "Payment action was not completed. Please try again.";
-  } else if (errorCode === "AUTHORIZATION_FAILED") {
-    code = "AUTHORIZATION_FAILED";
-    message = "Authorization failed. Please check your code and try again.";
-  } else if (errorCode === "INVALID_OTP") {
-    code = "INVALID_OTP";
-    message = "Invalid verification code. Please check and try again.";
+  and(field, op, value) {
+    return this.where(field, op, value);
   }
-  return { code, message, recoverable, technical };
-}
-function isQuickPaymentResponse(response) {
-  return response !== null && typeof response === "object" && "payment" in response && typeof response.payment === "object";
-}
-function isWebPaymentResponse(response) {
-  return response !== null && typeof response === "object" && "transaction" in response && typeof response.transaction === "object";
-}
-function normalizePaymentResponse(response) {
-  if (!response) {
-    return {
-      method: "unknown",
-      provider: "unknown",
-      requires_action: false,
-      metadata: {}
-    };
+  sort(field, order = "asc") {
+    this.modifiers.push(`sort(${field},${order})`);
+    return this;
   }
-  if (isQuickPaymentResponse(response)) {
-    return {
-      method: response.payment.type?.toLowerCase() || "unknown",
-      provider: response.payment.provider?.toLowerCase() || "unknown",
-      requires_action: !!response.payment.redirect_url || !!response.payment.access_code,
-      public_key: response.payment.public_key,
-      client_secret: response.payment.access_code,
-      access_code: response.payment.access_code,
-      redirect_url: response.payment.redirect_url,
-      transaction_id: response.payment.reference,
-      order_id: response.order_id,
-      reference: response.payment.reference,
-      instructions: response.payment.instructions,
-      metadata: response.payment.metadata
-    };
+  limit(n) {
+    this.modifiers.push(`limit(${n})`);
+    return this;
   }
-  if (isWebPaymentResponse(response)) {
-    const authType = response.authorization_type?.toLowerCase();
-    const validAuthTypes = ["otp", "pin", "phone", "birthday", "address"];
-    const safeAuthType = authType && validAuthTypes.includes(authType) ? authType : void 0;
-    return {
-      provider: response.transaction.provider_type?.toLowerCase() || "unknown",
-      requires_action: response.requires_action || false,
-      public_key: response.public_key,
-      client_secret: response.client_secret,
-      redirect_url: response.authorization_url,
-      transaction_id: response.transaction.id,
-      order_id: response.transaction.order_id,
-      reference: response.transaction.provider_reference,
-      metadata: response.transaction.metadata,
-      method: response.transaction.payment_method?.toLowerCase() || "unknown",
-      instructions: response.display_text,
-      display_text: response.display_text,
-      requires_authorization: response.requires_authorization,
-      authorization_type: safeAuthType,
-      provider_payment_id: response.provider_payment_id || response.transaction.provider_reference
-    };
+  offset(n) {
+    this.modifiers.push(`offset(${n})`);
+    return this;
   }
-  return {
-    method: "unknown",
-    provider: "unknown",
-    requires_action: false,
-    metadata: {}
-  };
-}
-function normalizeStatusResponse(response) {
-  if (!response || typeof response !== "object") {
-    return {
-      status: "pending",
-      paid: false,
-      message: "No status available"
-    };
+  count() {
+    this.modifiers.push("count");
+    return this;
   }
-  const res = response;
-  const status = res.status?.toLowerCase() || "";
-  let standardStatus;
-  if (status === "success" || status === "completed" || res.paid === true) {
-    standardStatus = "success";
-  } else if (status === "failed" || status === "declined" || status === "cancelled") {
-    standardStatus = "failed";
-  } else if (status === "processing" || status === "pending_confirmation") {
-    standardStatus = "processing";
-  } else {
-    standardStatus = "pending";
+  enriched() {
+    this.modifiers.push("enriched");
+    return this;
   }
-  return {
-    status: standardStatus,
-    paid: res.paid || standardStatus === "success",
-    amount: res.amount,
-    currency: res.currency,
-    reference: res.reference,
-    message: res.message || ""
-  };
-}
-var MOBILE_MONEY_PROVIDERS = {
-  mtn: { name: "MTN Mobile Money", prefix: ["024", "054", "055", "059"] },
-  vodafone: { name: "Vodafone Cash", prefix: ["020", "050"] },
-  airtel: { name: "AirtelTigo Money", prefix: ["027", "057", "026", "056"] }
-};
-function detectMobileMoneyProvider(phoneNumber) {
-  const cleaned = phoneNumber.replace(/\D/g, "");
-  const prefix = cleaned.slice(-9, -6);
-  for (const [provider, info] of Object.entries(MOBILE_MONEY_PROVIDERS)) {
-    if (info.prefix.some((p) => prefix.startsWith(p.slice(1)))) {
-      return provider;
+  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;
   }
-  return null;
+  toString() {
+    return this.build();
+  }
+};
+function query(entity) {
+  return new QueryBuilder(entity);
 }
 
 exports.AUTHORIZATION_TYPE = AUTHORIZATION_TYPE;
@@ -2563,6 +3565,9 @@ exports.isCimplifyError = isCimplifyError;
 exports.isErr = isErr;
 exports.isOk = isOk;
 exports.isOnSale = isOnSale;
+exports.isPaymentStatusFailure = isPaymentStatusFailure;
+exports.isPaymentStatusRequiresAction = isPaymentStatusRequiresAction;
+exports.isPaymentStatusSuccess = isPaymentStatusSuccess;
 exports.isRetryableError = isRetryableError;
 exports.mapError = mapError;
 exports.mapResult = mapResult;