@cimplify/sdk 0.6.2 → 0.6.3

package/dist/index.js

@@ -664,1994 +664,2837 @@ 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;
-  }
-  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));
+function getBasePrice(product) {
+  if (product.price_info) {
+    return parsePrice(product.price_info.base_price);
   }
-  async get(orderId) {
-    return safe4(this.client.query(`orders.${orderId}`));
+  if (product.base_price !== void 0 && product.base_price !== null) {
+    return parsePrice(product.base_price);
   }
-  async getRecent(limit = 5) {
-    return safe4(this.client.query(`orders#sort(created_at,desc)#limit(${limit})`));
+  if (product.default_price !== void 0 && product.default_price !== null) {
+    return parsePrice(product.default_price);
   }
-  async getByStatus(status) {
-    return safe4(this.client.query(`orders[?(@.status=='${status}')]`));
+  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);
   }
-  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 getMarkupPercentage(product) {
+  const basePrice = getBasePrice(product);
+  const finalPrice = getDisplayPrice(product);
+  if (finalPrice > basePrice && basePrice > 0) {
+    return Math.round((finalPrice - basePrice) / basePrice * 100);
   }
+  return 0;
 }
-var LinkService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async requestOtp(input) {
-    return safe5(this.client.linkPost("/v1/link/auth/request-otp", input));
-  }
-  async verifyOtp(input) {
-    const result = await safe5(
-      this.client.linkPost("/v1/link/auth/verify-otp", input)
-    );
-    if (result.ok && result.value.session_token) {
-      this.client.setSessionToken(result.value.session_token);
-    }
-    return result;
-  }
-  async logout() {
-    const result = await safe5(this.client.linkPost("/v1/link/auth/logout"));
-    if (result.ok) {
-      this.client.clearSession();
-    }
-    return result;
-  }
-  async checkStatus(contact) {
-    return safe5(
-      this.client.call(LINK_MUTATION.CHECK_STATUS, {
-        contact
-      })
-    );
-  }
-  async getLinkData() {
-    return safe5(this.client.query(LINK_QUERY.DATA));
-  }
-  async getAddresses() {
-    return safe5(this.client.query(LINK_QUERY.ADDRESSES));
-  }
-  async getMobileMoney() {
-    return safe5(this.client.query(LINK_QUERY.MOBILE_MONEY));
-  }
-  async getPreferences() {
-    return safe5(this.client.query(LINK_QUERY.PREFERENCES));
-  }
-  async enroll(data) {
-    return safe5(this.client.call(LINK_MUTATION.ENROLL, data));
-  }
-  async enrollAndLinkOrder(data) {
-    return safe5(
-      this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data)
-    );
-  }
-  async updatePreferences(preferences) {
-    return safe5(this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences));
-  }
-  async createAddress(input) {
-    return safe5(this.client.call(LINK_MUTATION.CREATE_ADDRESS, input));
-  }
-  async updateAddress(input) {
-    return safe5(this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input));
-  }
-  async deleteAddress(addressId) {
-    return safe5(this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId));
-  }
-  async setDefaultAddress(addressId) {
-    return safe5(this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId));
-  }
-  async trackAddressUsage(addressId) {
-    return safe5(
-      this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
-        address_id: addressId
-      })
-    );
-  }
-  async createMobileMoney(input) {
-    return safe5(this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input));
-  }
-  async deleteMobileMoney(mobileMoneyId) {
-    return safe5(this.client.call(LINK_MUTATION.DELETE_MOBILE_MONEY, mobileMoneyId));
-  }
-  async setDefaultMobileMoney(mobileMoneyId) {
-    return safe5(
-      this.client.call(LINK_MUTATION.SET_DEFAULT_MOBILE_MONEY, mobileMoneyId)
-    );
-  }
-  async trackMobileMoneyUsage(mobileMoneyId) {
-    return safe5(
-      this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
-        mobile_money_id: mobileMoneyId
-      })
-    );
-  }
-  async verifyMobileMoney(mobileMoneyId) {
-    return safe5(
-      this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
-    );
-  }
-  async getSessions() {
-    return safe5(this.client.linkGet("/v1/link/sessions"));
-  }
-  async revokeSession(sessionId) {
-    return safe5(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
-  }
-  async revokeAllSessions() {
-    return safe5(this.client.linkDelete("/v1/link/sessions"));
-  }
-  async getAddressesRest() {
-    return safe5(this.client.linkGet("/v1/link/addresses"));
-  }
-  async createAddressRest(input) {
-    return safe5(this.client.linkPost("/v1/link/addresses", input));
-  }
-  async deleteAddressRest(addressId) {
-    return safe5(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
-  }
-  async setDefaultAddressRest(addressId) {
-    return safe5(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
-  }
-  async getMobileMoneyRest() {
-    return safe5(this.client.linkGet("/v1/link/mobile-money"));
-  }
-  async createMobileMoneyRest(input) {
-    return safe5(this.client.linkPost("/v1/link/mobile-money", input));
-  }
-  async deleteMobileMoneyRest(mobileMoneyId) {
-    return safe5(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
+function getProductCurrency(product) {
+  if (product.price_info?.currency) {
+    return product.price_info.currency;
   }
-  async setDefaultMobileMoneyRest(mobileMoneyId) {
-    return safe5(
-      this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
-    );
+  if (product.currency) {
+    return product.currency;
   }
-};
+  return "GHS";
+}
+function formatProductPrice(product, locale = "en-US") {
+  const price = getDisplayPrice(product);
+  const currency = getProductCurrency(product);
+  return formatPrice(price, currency, locale);
+}
 
-// src/auth.ts
-function toCimplifyError6(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+// src/utils/payment.ts
+function categorizePaymentError(error, errorCode) {
+  let message = "An unexpected error occurred during payment processing. Please try again or contact support.";
+  let recoverable = true;
+  let code = errorCode || "PAYMENT_ERROR";
+  const technical = error.stack;
+  const errorMessage = error.message?.toLowerCase() || "";
+  if (errorCode === "INSUFFICIENT_FUNDS" || errorMessage.includes("insufficient") || errorMessage.includes("funds")) {
+    code = "INSUFFICIENT_FUNDS";
+    message = "Your payment method has insufficient funds. Please try another payment method.";
+  } else if (errorCode === "CARD_DECLINED" || errorMessage.includes("declined")) {
+    code = "CARD_DECLINED";
+    message = "Your card was declined. Please try another card or payment method.";
+  } else if (errorMessage.includes("cancelled") || errorMessage.includes("canceled") || errorCode === "PAYMENT_CANCELLED") {
+    code = "PAYMENT_CANCELLED";
+    message = "Payment was cancelled. You can try again when ready.";
+  } else if (errorMessage.includes("network") || errorMessage.includes("connection") || errorCode === "NETWORK_ERROR") {
+    code = "NETWORK_ERROR";
+    message = "Network connection issue. Please check your internet connection and try again.";
+  } else if (errorMessage.includes("timeout") || errorCode === "TIMEOUT") {
+    code = "TIMEOUT";
+    message = "Payment processing timed out. Please try again.";
+  } else if (errorCode === "PAYMENT_ACTION_NOT_COMPLETED") {
+    code = "PAYMENT_ACTION_NOT_COMPLETED";
+    message = "Payment action was not completed. Please try again.";
+  } else if (errorCode === "AUTHORIZATION_FAILED") {
+    code = "AUTHORIZATION_FAILED";
+    message = "Authorization failed. Please check your code and try again.";
+  } else if (errorCode === "INVALID_OTP") {
+    code = "INVALID_OTP";
+    message = "Invalid verification code. Please check and try again.";
   }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+  return { code, message, recoverable, technical };
 }
-async function safe6(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError6(error));
-  }
+function isQuickPaymentResponse(response) {
+  return response !== null && typeof response === "object" && "payment" in response && typeof response.payment === "object";
 }
-var AuthService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getStatus() {
-    return safe6(this.client.query("auth"));
-  }
-  async getCurrentUser() {
-    const result = await this.getStatus();
-    if (!result.ok) return result;
-    return ok(result.value.customer || null);
+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 isAuthenticated() {
-    const result = await this.getStatus();
-    if (!result.ok) return result;
-    return ok(result.value.is_authenticated);
+  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 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));
+  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 changePassword(input) {
-    return safe6(this.client.call("auth.change_password", input));
+  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];
   }
-  async resetPassword(email) {
-    return safe6(this.client.call("auth.reset_password", { email }));
+  return KNOWN_PAYMENT_STATUSES.has(normalized) ? normalized : "unknown";
+}
+function isPaymentStatusSuccess(status) {
+  const normalizedStatus = normalizePaymentStatusValue(status);
+  return PAYMENT_SUCCESS_STATUSES.has(normalizedStatus);
+}
+function isPaymentStatusFailure(status) {
+  const normalizedStatus = normalizePaymentStatusValue(status);
+  return PAYMENT_FAILURE_STATUSES.has(normalizedStatus);
+}
+function isPaymentStatusRequiresAction(status) {
+  const normalizedStatus = normalizePaymentStatusValue(status);
+  return PAYMENT_REQUIRES_ACTION_STATUSES.has(normalizedStatus);
+}
+function normalizeStatusResponse(response) {
+  if (!response || typeof response !== "object") {
+    return {
+      status: "pending",
+      paid: false,
+      message: "No status available"
+    };
   }
+  const res = response;
+  const normalizedStatus = normalizePaymentStatusValue(res.status ?? void 0);
+  const paidValue = res.paid === true;
+  const derivedPaid = paidValue || [
+    "success",
+    "succeeded",
+    "paid",
+    "captured",
+    "authorized",
+    "completed"
+  ].includes(normalizedStatus);
+  return {
+    status: normalizedStatus,
+    paid: derivedPaid,
+    amount: res.amount,
+    currency: res.currency,
+    reference: res.reference,
+    message: res.message || ""
+  };
+}
+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"] }
 };
-
-// src/business.ts
-function toCimplifyError7(error) {
-  if (error instanceof CimplifyError) return error;
-  if (error instanceof Error) {
-    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+function detectMobileMoneyProvider(phoneNumber) {
+  const cleaned = phoneNumber.replace(/\D/g, "");
+  const prefix = cleaned.slice(-9, -6);
+  for (const [provider, info] of Object.entries(MOBILE_MONEY_PROVIDERS)) {
+    if (info.prefix.some((p) => prefix.startsWith(p.slice(1)))) {
+      return provider;
+    }
   }
-  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+  return null;
 }
-async function safe7(promise) {
+
+// src/utils/paystack.ts
+async function openPaystackPopup(options, signal) {
+  if (typeof window === "undefined") {
+    return { success: false, error: "PAYSTACK_UNAVAILABLE" };
+  }
+  let PaystackPop;
   try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError7(error));
+    const imported = await import('@paystack/inline-js');
+    PaystackPop = imported.default;
+  } catch {
+    return { success: false, error: "PAYSTACK_UNAVAILABLE" };
   }
+  return new Promise((resolve) => {
+    let settled = false;
+    const resolveOnce = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve(result);
+    };
+    const onAbort = () => {
+      resolveOnce({ success: false, error: "CANCELLED" });
+    };
+    if (signal?.aborted) {
+      resolveOnce({ success: false, error: "CANCELLED" });
+      return;
+    }
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      const popup = new PaystackPop();
+      popup.newTransaction({
+        key: options.key,
+        email: options.email,
+        amount: options.amount,
+        currency: options.currency,
+        reference: options.reference,
+        accessCode: options.accessCode,
+        onSuccess: (transaction) => {
+          resolveOnce({
+            success: true,
+            reference: transaction.reference ?? options.reference
+          });
+        },
+        onCancel: () => {
+          resolveOnce({ success: false, error: "PAYMENT_CANCELLED" });
+        },
+        onError: (error) => {
+          resolveOnce({
+            success: false,
+            error: error?.message || "PAYMENT_FAILED"
+          });
+        }
+      });
+    } catch {
+      resolveOnce({ success: false, error: "POPUP_BLOCKED" });
+    }
+  });
 }
-var BusinessService = class {
-  constructor(client) {
-    this.client = client;
+
+// 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 getInfo() {
-    return safe7(this.client.query("business.info"));
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value;
   }
-  async getByHandle(handle) {
-    return safe7(this.client.query(`business.handle.${handle}`));
+  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 getByDomain(domain) {
-    return safe7(this.client.query("business.domain", { domain }));
+  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 getSettings() {
-    return safe7(this.client.query("business.settings"));
+  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 getTheme() {
-    return safe7(this.client.query("business.theme"));
+  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 getLocations() {
-    return safe7(this.client.query("business.locations"));
+  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 getLocation(locationId) {
-    return safe7(this.client.query(`business.locations.${locationId}`));
+  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 getHours() {
-    return safe7(this.client.query("business.hours"));
+  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 getLocationHours(locationId) {
-    return safe7(this.client.query(`business.locations.${locationId}.hours`));
+  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 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
+  getOrderCurrency(checkoutResult) {
+    if (checkoutResult.fx?.pay_currency) {
+      return checkoutResult.fx.pay_currency;
+    }
+    if (this.cartCurrency) {
+      return this.cartCurrency;
+    }
+    if (this.checkoutData.pay_currency) {
+      return this.checkoutData.pay_currency;
+    }
+    return "GHS";
+  }
+  emit(status, context = {}) {
+    if (!this.onStatusChange) {
+      return;
+    }
+    try {
+      this.onStatusChange(status, context);
+    } catch {
+    }
+  }
+  fail(code, message, recoverable) {
+    this.emit("failed", {
+      display_text: message
+    });
+    return {
+      success: false,
+      error: {
+        code,
+        message,
+        recoverable
+      }
+    };
+  }
+  isSuccessfulStatus(status) {
+    const normalized = normalizeStatusResponse({ status, paid: false });
+    return normalized.paid || isPaymentStatusSuccess(normalized.status);
+  }
+  isFailureStatus(status) {
+    const normalized = normalizeStatusResponse({ status, paid: false });
+    return isPaymentStatusFailure(normalized.status);
+  }
+  ensureNotAborted() {
+    if (this.signal?.aborted) {
+      throw createAbortError();
+    }
+  }
+  wait(ms) {
+    this.ensureNotAborted();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.signal) {
+          this.signal.removeEventListener("abort", onAbort);
+        }
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(createAbortError());
+      };
+      if (this.signal) {
+        this.signal.addEventListener("abort", onAbort, { once: true });
+      }
     });
   }
 };
 
-// src/inventory.ts
-function toCimplifyError8(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 safe8(promise) {
+async function safe3(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError8(error));
+    return err(toCimplifyError3(error));
   }
 }
-var InventoryService = 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 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 process(data) {
+    const checkoutData = {
+      ...data,
+      idempotency_key: data.idempotency_key || generateIdempotencyKey()
+    };
+    return safe3(
+      this.client.call(CHECKOUT_MUTATION.PROCESS, {
+        checkout_data: checkoutData
       })
     );
   }
-  async getVariantStock(variantId, locationId) {
-    return safe8(
-      this.client.query("inventory.variant", {
-        variant_id: variantId,
-        location_id: locationId
+  async initializePayment(orderId, method) {
+    return safe3(
+      this.client.call("order.initializePayment", {
+        order_id: orderId,
+        payment_method: method
       })
     );
   }
-  async checkProductAvailability(productId, quantity, locationId) {
-    return safe8(
-      this.client.query("inventory.check_availability", {
-        product_id: productId,
-        quantity,
-        location_id: locationId
-      })
+  async submitAuthorization(input) {
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
     );
   }
-  async checkVariantAvailability(variantId, quantity, locationId) {
-    return safe8(
-      this.client.query("inventory.check_availability", {
-        variant_id: variantId,
-        quantity,
-        location_id: locationId
-      })
+  async pollPaymentStatus(orderId) {
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
     );
   }
-  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 updateOrderCustomer(orderId, customer) {
+    return safe3(
+      this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
+        order_id: orderId,
+        ...customer
+      })
     );
-    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 verifyPayment(orderId) {
+    return safe3(
+      this.client.call("order.verifyPayment", {
+        order_id: orderId
+      })
+    );
   }
-  async getAvailableQuantity(productId, locationId) {
-    const result = await this.getProductStock(productId, locationId);
-    if (!result.ok) return result;
-    return ok(result.value.available_quantity);
+  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/scheduling.ts
-function toVariables(input) {
-  return Object.fromEntries(Object.entries(input));
-}
-function toCimplifyError9(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 safe9(promise) {
+async function safe4(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError9(error));
+    return err(toCimplifyError4(error));
   }
 }
-var SchedulingService = class {
+var OrderQueries = 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 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 getAvailableSlots(input) {
-    return safe9(
-      this.client.query("scheduling.slots", toVariables(input))
-    );
+  async get(orderId) {
+    return safe4(this.client.query(`orders.${orderId}`));
   }
-  async checkSlotAvailability(input) {
-    return safe9(
-      this.client.query(
-        "scheduling.check_availability",
-        toVariables(input)
-      )
-    );
-  }
-  async getServiceAvailability(params) {
-    return safe9(
-      this.client.query(
-        "scheduling.availability",
-        toVariables(params)
-      )
-    );
-  }
-  async getBooking(bookingId) {
-    return safe9(this.client.query(`scheduling.${bookingId}`));
-  }
-  async getCustomerBookings() {
-    return safe9(this.client.query("scheduling"));
+  async getRecent(limit = 5) {
+    return safe4(this.client.query(`orders#sort(created_at,desc)#limit(${limit})`));
   }
-  async getUpcomingBookings() {
-    return safe9(
-      this.client.query(
-        "scheduling[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
-      )
-    );
+  async getByStatus(status) {
+    return safe4(this.client.query(`orders[?(@.status=='${status}')]`));
   }
-  async getPastBookings(limit = 10) {
-    return safe9(
-      this.client.query(
-        `scheduling[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
-      )
+  async cancel(orderId, reason) {
+    return safe4(
+      this.client.call("order.cancelOrder", {
+        order_id: orderId,
+        reason
+      })
     );
   }
-  async cancelBooking(input) {
-    return safe9(this.client.call("scheduling.cancel_booking", input));
-  }
-  async rescheduleBooking(input) {
-    return safe9(this.client.call("scheduling.reschedule_booking", input));
-  }
-  async getNextAvailableSlot(serviceId, fromDate) {
-    const date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const result = await this.getAvailableSlots({
-      service_id: serviceId,
-      date
-    });
-    if (!result.ok) return result;
-    return ok(result.value.find((slot) => slot.is_available) || null);
-  }
-  async hasAvailabilityOn(serviceId, date) {
-    const result = await this.getAvailableSlots({
-      service_id: serviceId,
-      date
-    });
-    if (!result.ok) return result;
-    return ok(result.value.some((slot) => slot.is_available));
-  }
 };
 
-// src/lite.ts
-function toCimplifyError10(error) {
+// 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 safe10(promise) {
+async function safe5(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError10(error));
+    return err(toCimplifyError5(error));
   }
 }
-var LiteService = class {
+var LinkService = class {
   constructor(client) {
     this.client = client;
   }
-  async getBootstrap() {
-    return safe10(this.client.query("lite.bootstrap"));
+  async requestOtp(input) {
+    return safe5(this.client.linkPost("/v1/link/auth/request-otp", input));
   }
-  async getTable(tableId) {
-    return safe10(this.client.query(`lite.table.${tableId}`));
+  async verifyOtp(input) {
+    const result = await safe5(
+      this.client.linkPost("/v1/link/auth/verify-otp", input)
+    );
+    if (result.ok && result.value.session_token) {
+      this.client.setSessionToken(result.value.session_token);
+    }
+    return result;
   }
-  async getTableByNumber(tableNumber, locationId) {
-    return safe10(
-      this.client.query("lite.table_by_number", {
-        table_number: tableNumber,
-        location_id: locationId
+  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 sendToKitchen(tableId, items) {
-    return safe10(
-      this.client.call("lite.send_to_kitchen", {
-        table_id: tableId,
-        items
-      })
+  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 callWaiter(tableId, reason) {
-    return safe10(
-      this.client.call("lite.call_waiter", {
-        table_id: tableId,
-        reason
+  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 requestBill(tableId) {
-    return safe10(
-      this.client.call("lite.request_bill", {
-        table_id: tableId
+  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 getMenu() {
-    return safe10(this.client.query("lite.menu"));
+  async verifyMobileMoney(mobileMoneyId) {
+    return safe5(
+      this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
+    );
   }
-  async getMenuByCategory(categoryId) {
-    return safe10(this.client.query(`lite.menu.category.${categoryId}`));
+  async getSessions() {
+    return safe5(this.client.linkGet("/v1/link/sessions"));
+  }
+  async revokeSession(sessionId) {
+    return safe5(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
+  }
+  async revokeAllSessions() {
+    return safe5(this.client.linkDelete("/v1/link/sessions"));
+  }
+  async getAddressesRest() {
+    return safe5(this.client.linkGet("/v1/link/addresses"));
+  }
+  async createAddressRest(input) {
+    return safe5(this.client.linkPost("/v1/link/addresses", input));
+  }
+  async deleteAddressRest(addressId) {
+    return safe5(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
+  }
+  async setDefaultAddressRest(addressId) {
+    return safe5(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
+  }
+  async getMobileMoneyRest() {
+    return safe5(this.client.linkGet("/v1/link/mobile-money"));
+  }
+  async createMobileMoneyRest(input) {
+    return safe5(this.client.linkPost("/v1/link/mobile-money", input));
+  }
+  async deleteMobileMoneyRest(mobileMoneyId) {
+    return safe5(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
+  }
+  async setDefaultMobileMoneyRest(mobileMoneyId) {
+    return safe5(
+      this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
+    );
   }
 };
 
-// src/fx.ts
-function toCimplifyError11(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 safe11(promise) {
+async function safe6(promise) {
   try {
     return ok(await promise);
   } catch (error) {
-    return err(toCimplifyError11(error));
+    return err(toCimplifyError6(error));
   }
 }
-var FxService = class {
+var AuthService = class {
   constructor(client) {
     this.client = client;
   }
-  async getRate(from, to) {
-    return safe11(this.client.call("fx.getRate", { from, to }));
+  async getStatus() {
+    return safe6(this.client.query("auth"));
   }
-  async lockQuote(request) {
-    return safe11(this.client.call("fx.lockQuote", request));
+  async getCurrentUser() {
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.customer || null);
+  }
+  async isAuthenticated() {
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.is_authenticated);
+  }
+  async requestOtp(contact, contactType) {
+    return safe6(
+      this.client.call(AUTH_MUTATION.REQUEST_OTP, {
+        contact,
+        contact_type: contactType
+      })
+    );
+  }
+  async verifyOtp(code, contact) {
+    return safe6(
+      this.client.call(AUTH_MUTATION.VERIFY_OTP, {
+        otp_code: code,
+        contact
+      })
+    );
+  }
+  async logout() {
+    return safe6(this.client.call("auth.logout"));
+  }
+  async updateProfile(input) {
+    return safe6(this.client.call("auth.update_profile", input));
+  }
+  async changePassword(input) {
+    return safe6(this.client.call("auth.change_password", input));
+  }
+  async resetPassword(email) {
+    return safe6(this.client.call("auth.reset_password", { email }));
   }
 };
 
-// src/types/elements.ts
-var ELEMENT_TYPES = {
-  AUTH: "auth",
-  ADDRESS: "address",
-  PAYMENT: "payment"
-};
-var MESSAGE_TYPES = {
-  // Parent → Iframe
-  INIT: "init",
-  SET_TOKEN: "set_token",
-  GET_DATA: "get_data",
-  REFRESH_TOKEN: "refresh_token",
-  LOGOUT: "logout",
-  // Iframe → Parent
-  READY: "ready",
-  HEIGHT_CHANGE: "height_change",
-  AUTHENTICATED: "authenticated",
-  REQUIRES_OTP: "requires_otp",
-  ERROR: "error",
-  ADDRESS_CHANGED: "address_changed",
-  ADDRESS_SELECTED: "address_selected",
-  PAYMENT_METHOD_SELECTED: "payment_method_selected",
-  TOKEN_REFRESHED: "token_refreshed",
-  LOGOUT_COMPLETE: "logout_complete"
-};
-var EVENT_TYPES = {
-  READY: "ready",
-  AUTHENTICATED: "authenticated",
-  REQUIRES_OTP: "requires_otp",
-  ERROR: "error",
-  CHANGE: "change",
-  BLUR: "blur",
-  FOCUS: "focus"
-};
-
-// src/elements.ts
-function mapOrderType(orderType) {
-  if (orderType === "dine_in") return "dine-in";
-  return orderType ?? "delivery";
-}
-function toCheckoutFormData(data) {
-  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?.type === "card" && data.payment_method?.id ? data.payment_method.id : void 0
-  };
+// 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);
 }
-var DEFAULT_LINK_URL = "https://link.cimplify.io";
-function isAllowedOrigin(origin) {
+async function safe7(promise) {
   try {
-    const url = new URL(origin);
-    const hostname = url.hostname;
-    if (hostname === "localhost" || hostname === "127.0.0.1") {
-      return true;
-    }
-    if (url.protocol !== "https:") {
-      return false;
-    }
-    return hostname === "cimplify.io" || hostname.endsWith(".cimplify.io");
-  } catch {
-    return false;
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError7(error));
   }
 }
-var CimplifyElements = class {
-  constructor(client, businessId, options = {}) {
-    this.elements = /* @__PURE__ */ new Map();
-    this.accessToken = null;
-    this.accountId = null;
-    this.customerId = null;
-    this.addressData = null;
-    this.paymentData = null;
+var BusinessService = class {
+  constructor(client) {
     this.client = client;
-    this.businessId = businessId;
-    this.linkUrl = options.linkUrl || DEFAULT_LINK_URL;
-    this.options = options;
-    this.boundHandleMessage = this.handleMessage.bind(this);
-    if (typeof window !== "undefined") {
-      window.addEventListener("message", this.boundHandleMessage);
-    }
   }
-  create(type, options = {}) {
-    const existing = this.elements.get(type);
-    if (existing) return existing;
-    const element = new CimplifyElement(type, this.businessId, this.linkUrl, options, this);
-    this.elements.set(type, element);
-    return element;
+  async getInfo() {
+    return safe7(this.client.query("business.info"));
   }
-  getElement(type) {
-    return this.elements.get(type);
+  async getByHandle(handle) {
+    return safe7(this.client.query(`business.handle.${handle}`));
   }
-  destroy() {
-    this.elements.forEach((element) => element.destroy());
-    this.elements.clear();
-    if (typeof window !== "undefined") {
-      window.removeEventListener("message", this.boundHandleMessage);
-    }
+  async getByDomain(domain) {
+    return safe7(this.client.query("business.domain", { domain }));
   }
-  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) {
-      return {
-        success: true,
-        order: {
-          id: result.value.order_id,
-          status: result.value.payment_status,
-          total: ""
-          // Total is not returned by checkout result
-        }
-      };
-    }
-    return {
-      success: false,
-      error: {
-        code: result.error.code || "CHECKOUT_FAILED",
-        message: result.error.message || "Checkout failed"
-      }
-    };
+  async getSettings() {
+    return safe7(this.client.query("business.settings"));
   }
-  isAuthenticated() {
-    return this.accessToken !== null;
+  async getTheme() {
+    return safe7(this.client.query("business.theme"));
   }
-  getAccessToken() {
-    return this.accessToken;
+  async getLocations() {
+    return safe7(this.client.query("business.locations"));
   }
-  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;
-        this.elements.forEach((element, type) => {
-          if (type !== ELEMENT_TYPES.AUTH) {
-            element.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token: message.token });
-          }
-        });
-        break;
-      case MESSAGE_TYPES.TOKEN_REFRESHED:
-        this.accessToken = message.token;
-        break;
-      case MESSAGE_TYPES.ADDRESS_CHANGED:
-      case MESSAGE_TYPES.ADDRESS_SELECTED:
-        this.addressData = message.address;
-        break;
-      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
-        this.paymentData = message.method;
-        break;
-      case MESSAGE_TYPES.LOGOUT_COMPLETE:
-        this.accessToken = null;
-        this.accountId = null;
-        this.customerId = null;
-        this.addressData = null;
-        this.paymentData = null;
-        break;
-    }
+  async getLocation(locationId) {
+    return safe7(this.client.query(`business.locations.${locationId}`));
   }
-  _setAddressData(data) {
-    this.addressData = data;
+  async getHours() {
+    return safe7(this.client.query("business.hours"));
   }
-  _setPaymentData(data) {
-    this.paymentData = data;
+  async getLocationHours(locationId) {
+    return safe7(this.client.query(`business.locations.${locationId}.hours`));
   }
-};
-var CimplifyElement = class {
-  constructor(type, businessId, linkUrl, options, parent) {
-    this.iframe = null;
-    this.container = null;
-    this.mounted = false;
-    this.eventHandlers = /* @__PURE__ */ new Map();
-    this.resolvers = /* @__PURE__ */ new Map();
-    this.type = type;
-    this.businessId = businessId;
-    this.linkUrl = linkUrl;
-    this.options = options;
-    this.parent = parent;
-    this.boundHandleMessage = this.handleMessage.bind(this);
-    if (typeof window !== "undefined") {
-      window.addEventListener("message", this.boundHandleMessage);
-    }
+  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
+    });
   }
-  mount(container) {
-    if (this.mounted) {
-      console.warn(`Element ${this.type} is already mounted`);
-      return;
-    }
-    const target = typeof container === "string" ? document.querySelector(container) : container;
-    if (!target) {
-      console.error(`Container not found: ${container}`);
-      return;
-    }
-    this.container = target;
-    this.createIframe();
-    this.mounted = true;
+};
+
+// src/inventory.ts
+function toCimplifyError8(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
   }
-  destroy() {
-    if (this.iframe) {
-      this.iframe.remove();
-      this.iframe = null;
-    }
-    this.container = null;
-    this.mounted = false;
-    this.eventHandlers.clear();
-    if (typeof window !== "undefined") {
-      window.removeEventListener("message", this.boundHandleMessage);
-    }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe8(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError8(error));
   }
-  on(event, handler) {
-    if (!this.eventHandlers.has(event)) {
-      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.eventHandlers.get(event).add(handler);
-  }
-  off(event, handler) {
-    this.eventHandlers.get(event)?.delete(handler);
+}
+var InventoryService = class {
+  constructor(client) {
+    this.client = client;
   }
-  async getData() {
-    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);
-        }
-      }, 5e3);
-    });
+  async getStockLevels() {
+    return safe8(this.client.query("inventory.stock_levels"));
   }
-  sendMessage(message) {
-    if (this.iframe?.contentWindow) {
-      this.iframe.contentWindow.postMessage(message, this.linkUrl);
+  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
+      })
+    );
   }
-  createIframe() {
-    if (!this.container) return;
-    const iframe = document.createElement("iframe");
-    const url = new URL(`${this.linkUrl}/elements/${this.type}`);
-    url.searchParams.set("businessId", this.businessId);
-    if (this.options.prefillEmail) url.searchParams.set("email", this.options.prefillEmail);
-    if (this.options.mode) url.searchParams.set("mode", this.options.mode);
-    iframe.src = url.toString();
-    iframe.style.border = "none";
-    iframe.style.width = "100%";
-    iframe.style.display = "block";
-    iframe.style.overflow = "hidden";
-    iframe.setAttribute("allowtransparency", "true");
-    iframe.setAttribute("frameborder", "0");
-    iframe.setAttribute("sandbox", "allow-scripts allow-same-origin allow-forms allow-popups");
-    this.iframe = iframe;
-    this.container.appendChild(iframe);
-    iframe.onload = () => {
-      this.sendMessage({
-        type: MESSAGE_TYPES.INIT,
-        businessId: this.businessId,
-        prefillEmail: this.options.prefillEmail
-      });
-      const token = this.parent.getAccessToken();
-      if (token && this.type !== ELEMENT_TYPES.AUTH) {
-        this.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token });
-      }
-    };
+  async getVariantStock(variantId, locationId) {
+    return safe8(
+      this.client.query("inventory.variant", {
+        variant_id: variantId,
+        location_id: locationId
+      })
+    );
   }
-  handleMessage(event) {
-    if (!isAllowedOrigin(event.origin)) {
-      return;
-    }
-    const message = event.data;
-    if (!message?.type) return;
-    switch (message.type) {
-      case MESSAGE_TYPES.READY:
-        this.emit(EVENT_TYPES.READY, { height: message.height });
-        break;
-      case MESSAGE_TYPES.HEIGHT_CHANGE:
-        if (this.iframe) this.iframe.style.height = `${message.height}px`;
-        break;
-      case MESSAGE_TYPES.AUTHENTICATED:
-        this.emit(EVENT_TYPES.AUTHENTICATED, {
-          accountId: message.accountId,
-          customerId: message.customerId,
-          token: message.token
-        });
-        break;
-      case MESSAGE_TYPES.REQUIRES_OTP:
-        this.emit(EVENT_TYPES.REQUIRES_OTP, { contactMasked: message.contactMasked });
-        break;
-      case MESSAGE_TYPES.ERROR:
-        this.emit(EVENT_TYPES.ERROR, { code: message.code, message: message.message });
-        break;
-      case MESSAGE_TYPES.ADDRESS_CHANGED:
-      case MESSAGE_TYPES.ADDRESS_SELECTED:
-        this.parent._setAddressData(message.address);
-        this.emit(EVENT_TYPES.CHANGE, { address: message.address });
-        this.resolveData(message.address);
-        break;
-      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
-        this.parent._setPaymentData(message.method);
-        this.emit(EVENT_TYPES.CHANGE, { paymentMethod: message.method });
-        this.resolveData(message.method);
-        break;
+  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));
   }
-  emit(event, data) {
-    this.eventHandlers.get(event)?.forEach((handler) => handler(data));
+  async getSummary() {
+    return safe8(this.client.query("inventory.summary"));
   }
-  resolveData(data) {
-    this.resolvers.forEach((resolve) => resolve(data));
-    this.resolvers.clear();
+  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);
   }
 };
-function createElements(client, businessId, options) {
-  return new CimplifyElements(client, businessId, options);
-}
 
-// src/client.ts
-var ACCESS_TOKEN_STORAGE_KEY = "cimplify_access_token";
-var DEFAULT_TIMEOUT_MS = 3e4;
-var DEFAULT_MAX_RETRIES = 3;
-var DEFAULT_RETRY_DELAY_MS = 1e3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+// src/scheduling.ts
+function toVariables(input) {
+  return Object.fromEntries(Object.entries(input));
 }
-function isRetryable(error) {
-  if (error instanceof TypeError && error.message.includes("fetch")) {
-    return true;
+function toCimplifyError9(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
   }
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return true;
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe9(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError9(error));
   }
-  if (error instanceof CimplifyError) {
-    return error.retryable;
+}
+var SchedulingService = class {
+  constructor(client) {
+    this.client = client;
   }
-  if (error instanceof CimplifyError && error.code === "SERVER_ERROR") {
-    return true;
+  async getServices() {
+    return safe9(this.client.query("scheduling.services"));
   }
-  return false;
-}
-function toNetworkError(error) {
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return new CimplifyError(
-      ErrorCode.TIMEOUT,
-      "Request timed out. Please check your connection and try again.",
-      true
+  /**
+   * 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))
     );
   }
-  if (error instanceof TypeError && error.message.includes("fetch")) {
-    return new CimplifyError(
-      ErrorCode.NETWORK_ERROR,
-      "Network error. Please check your internet connection.",
-      true
+  async checkSlotAvailability(input) {
+    return safe9(
+      this.client.query(
+        "scheduling.check_availability",
+        toVariables(input)
+      )
     );
   }
-  if (error instanceof CimplifyError) {
-    return error;
+  async getServiceAvailability(params) {
+    return safe9(
+      this.client.query(
+        "scheduling.availability",
+        toVariables(params)
+      )
+    );
   }
-  return new CimplifyError(
-    ErrorCode.UNKNOWN_ERROR,
-    error instanceof Error ? error.message : "An unknown error occurred",
-    false
-  );
-}
-function deriveUrls() {
-  const hostname = typeof window !== "undefined" ? window.location.hostname : "";
-  if (hostname === "localhost" || hostname === "127.0.0.1") {
-    const protocol = window.location.protocol;
-    return {
-      baseUrl: `${protocol}//${hostname}:8082`,
-      linkApiUrl: `${protocol}//${hostname}:8080`
-    };
+  async getBooking(bookingId) {
+    return safe9(this.client.query(`scheduling.${bookingId}`));
   }
-  return {
-    baseUrl: "https://storefronts.cimplify.io",
-    linkApiUrl: "https://api.cimplify.io"
-  };
-}
-function getEnvPublicKey() {
-  try {
-    const env = globalThis.process;
-    return env?.env.NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY || void 0;
-  } catch {
-    return void 0;
+  async getCustomerBookings() {
+    return safe9(this.client.query("scheduling"));
   }
-}
-var CimplifyClient = class {
-  constructor(config = {}) {
-    this.accessToken = null;
-    this.context = {};
-    this.inflightRequests = /* @__PURE__ */ new Map();
-    this.publicKey = config.publicKey || getEnvPublicKey() || "";
-    const urls = deriveUrls();
-    this.baseUrl = urls.baseUrl;
-    this.linkApiUrl = urls.linkApiUrl;
-    this.credentials = config.credentials || "include";
-    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
-    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
-    this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
-    this.hooks = config.hooks ?? {};
-    this.accessToken = this.loadAccessToken();
-    if (!this.publicKey) {
-      console.warn(
-        '[Cimplify] No public key found. Set NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY in your environment, or pass { publicKey: "pk_..." } to createCimplifyClient().'
-      );
-    }
+  async getUpcomingBookings() {
+    return safe9(
+      this.client.query(
+        "scheduling[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
+      )
+    );
   }
-  /** @deprecated Use getAccessToken() instead */
-  getSessionToken() {
-    return this.accessToken;
+  async getPastBookings(limit = 10) {
+    return safe9(
+      this.client.query(
+        `scheduling[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
+      )
+    );
   }
-  /** @deprecated Use setAccessToken() instead */
-  setSessionToken(token) {
-    this.setAccessToken(token);
+  async cancelBooking(input) {
+    return safe9(this.client.call("scheduling.cancel_booking", input));
   }
-  getAccessToken() {
-    return this.accessToken;
+  async rescheduleBooking(input) {
+    return safe9(this.client.call("scheduling.reschedule_booking", input));
   }
-  setAccessToken(token) {
-    const previous = this.accessToken;
-    this.accessToken = token;
-    this.saveAccessToken(token);
-    this.hooks.onSessionChange?.({
-      previousToken: previous,
-      newToken: token,
-      source: "manual"
+  async getNextAvailableSlot(serviceId, fromDate) {
+    const date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const result = await this.getAvailableSlots({
+      service_id: serviceId,
+      date
     });
+    if (!result.ok) return result;
+    return ok(result.value.find((slot) => slot.is_available) || null);
   }
-  clearSession() {
-    const previous = this.accessToken;
-    this.accessToken = null;
-    this.saveAccessToken(null);
-    this.hooks.onSessionChange?.({
-      previousToken: previous,
-      newToken: null,
-      source: "clear"
+  async hasAvailabilityOn(serviceId, date) {
+    const result = await this.getAvailableSlots({
+      service_id: serviceId,
+      date
     });
+    if (!result.ok) return result;
+    return ok(result.value.some((slot) => slot.is_available));
   }
-  /** Set the active location/branch for all subsequent requests */
-  setLocationId(locationId) {
-    if (locationId) {
-      this.context.location_id = locationId;
-    } else {
-      delete this.context.location_id;
-    }
+};
+
+// src/lite.ts
+function toCimplifyError10(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
   }
-  /** Get the currently active location ID */
-  getLocationId() {
-    return this.context.location_id ?? null;
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe10(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError10(error));
   }
-  loadAccessToken() {
-    if (typeof window !== "undefined" && window.localStorage) {
-      return localStorage.getItem(ACCESS_TOKEN_STORAGE_KEY);
-    }
-    return null;
+}
+var LiteService = class {
+  constructor(client) {
+    this.client = client;
   }
-  saveAccessToken(token) {
-    if (typeof window !== "undefined" && window.localStorage) {
-      if (token) {
-        localStorage.setItem(ACCESS_TOKEN_STORAGE_KEY, token);
-      } else {
-        localStorage.removeItem(ACCESS_TOKEN_STORAGE_KEY);
-      }
-    }
+  async getBootstrap() {
+    return safe10(this.client.query("lite.bootstrap"));
   }
-  getHeaders() {
-    const headers = {
-      "Content-Type": "application/json",
-      "X-API-Key": this.publicKey
-    };
-    if (this.accessToken) {
-      headers["Authorization"] = `Bearer ${this.accessToken}`;
-    }
-    return headers;
+  async getTable(tableId) {
+    return safe10(this.client.query(`lite.table.${tableId}`));
   }
-  async resilientFetch(url, options) {
-    const method = options.method || "GET";
-    const path = url.replace(this.baseUrl, "").replace(this.linkApiUrl, "");
-    const startTime = Date.now();
-    let retryCount = 0;
-    const context = {
-      method,
-      path,
-      url,
-      body: options.body ? JSON.parse(options.body) : void 0,
-      startTime
-    };
-    this.hooks.onRequestStart?.(context);
-    let lastError;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        const response = await fetch(url, {
-          ...options,
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
-        if (response.ok || response.status >= 400 && response.status < 500) {
-          this.hooks.onRequestSuccess?.({
-            ...context,
-            status: response.status,
-            durationMs: Date.now() - startTime
-          });
-          return response;
-        }
-        if (response.status >= 500 && attempt < this.maxRetries) {
-          retryCount++;
-          const delay = this.retryDelay * Math.pow(2, attempt);
-          this.hooks.onRetry?.({
-            ...context,
-            attempt: retryCount,
-            delayMs: delay,
-            error: new Error(`Server error: ${response.status}`)
-          });
-          await sleep(delay);
-          continue;
-        }
-        this.hooks.onRequestSuccess?.({
-          ...context,
-          status: response.status,
-          durationMs: Date.now() - startTime
-        });
-        return response;
-      } catch (error) {
-        lastError = error;
-        const networkError = toNetworkError(error);
-        const errorRetryable = isRetryable(error);
-        if (!errorRetryable || attempt >= this.maxRetries) {
-          this.hooks.onRequestError?.({
-            ...context,
-            error: networkError,
-            durationMs: Date.now() - startTime,
-            retryCount,
-            retryable: errorRetryable
-          });
-          throw networkError;
-        }
-        retryCount++;
-        const delay = this.retryDelay * Math.pow(2, attempt);
-        this.hooks.onRetry?.({
-          ...context,
-          attempt: retryCount,
-          delayMs: delay,
-          error: networkError
-        });
-        await sleep(delay);
-      }
-    }
-    const finalError = toNetworkError(lastError);
-    this.hooks.onRequestError?.({
-      ...context,
-      error: finalError,
-      durationMs: Date.now() - startTime,
-      retryCount,
-      retryable: false
-    });
-    throw finalError;
+  async getTableByNumber(tableNumber, locationId) {
+    return safe10(
+      this.client.query("lite.table_by_number", {
+        table_number: tableNumber,
+        location_id: locationId
+      })
+    );
   }
-  getDedupeKey(type, payload) {
-    return `${type}:${JSON.stringify(payload)}`;
+  async sendToKitchen(tableId, items) {
+    return safe10(
+      this.client.call("lite.send_to_kitchen", {
+        table_id: tableId,
+        items
+      })
+    );
   }
-  async deduplicatedRequest(key, requestFn) {
-    const existing = this.inflightRequests.get(key);
-    if (existing) {
-      return existing;
-    }
-    const request = requestFn().finally(() => {
-      this.inflightRequests.delete(key);
-    });
-    this.inflightRequests.set(key, request);
-    return request;
+  async callWaiter(tableId, reason) {
+    return safe10(
+      this.client.call("lite.call_waiter", {
+        table_id: tableId,
+        reason
+      })
+    );
   }
-  async query(query2, variables) {
-    const body = { query: query2 };
-    if (variables) {
-      body.variables = variables;
-    }
-    if (Object.keys(this.context).length > 0) {
-      body.context = this.context;
-    }
-    const key = this.getDedupeKey("query", body);
-    return this.deduplicatedRequest(key, async () => {
-      const response = await this.resilientFetch(`${this.baseUrl}/api/q`, {
-        method: "POST",
-        credentials: this.credentials,
-        headers: this.getHeaders(),
-        body: JSON.stringify(body)
-      });
-      return this.handleResponse(response);
-    });
+  async requestBill(tableId) {
+    return safe10(
+      this.client.call("lite.request_bill", {
+        table_id: tableId
+      })
+    );
   }
-  async call(method, args) {
-    const body = {
-      method,
-      args: args !== void 0 ? [args] : []
-    };
-    if (Object.keys(this.context).length > 0) {
-      body.context = this.context;
-    }
-    const response = await this.resilientFetch(`${this.baseUrl}/api/m`, {
-      method: "POST",
-      credentials: this.credentials,
-      headers: this.getHeaders(),
-      body: JSON.stringify(body)
-    });
-    return this.handleResponse(response);
+  async getMenu() {
+    return safe10(this.client.query("lite.menu"));
   }
-  async get(path) {
-    const key = this.getDedupeKey("get", path);
-    return this.deduplicatedRequest(key, async () => {
-      const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
-        method: "GET",
-        credentials: this.credentials,
-        headers: this.getHeaders()
-      });
-      return this.handleRestResponse(response);
-    });
+  async getMenuByCategory(categoryId) {
+    return safe10(this.client.query(`lite.menu.category.${categoryId}`));
   }
-  async post(path, body) {
-    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
-      method: "POST",
-      credentials: this.credentials,
-      headers: this.getHeaders(),
-      body: body ? JSON.stringify(body) : void 0
-    });
-    return this.handleRestResponse(response);
+};
+
+// src/fx.ts
+function toCimplifyError11(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
   }
-  async delete(path) {
-    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
-      method: "DELETE",
-      credentials: this.credentials,
-      headers: this.getHeaders()
-    });
-    return this.handleRestResponse(response);
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe11(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError11(error));
   }
-  async linkGet(path) {
-    const key = this.getDedupeKey("linkGet", path);
-    return this.deduplicatedRequest(key, async () => {
-      const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
-        method: "GET",
-        credentials: this.credentials,
-        headers: this.getHeaders()
-      });
-      return this.handleRestResponse(response);
-    });
+}
+var FxService = class {
+  constructor(client) {
+    this.client = client;
   }
-  async linkPost(path, body) {
-    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
-      method: "POST",
-      credentials: this.credentials,
-      headers: this.getHeaders(),
-      body: body ? JSON.stringify(body) : void 0
-    });
-    return this.handleRestResponse(response);
+  async getRate(from, to) {
+    return safe11(this.client.call("fx.getRate", { from, to }));
   }
-  async linkDelete(path) {
-    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
-      method: "DELETE",
-      credentials: this.credentials,
-      headers: this.getHeaders()
-    });
-    return this.handleRestResponse(response);
+  async lockQuote(request) {
+    return safe11(this.client.call("fx.lockQuote", request));
   }
-  async handleRestResponse(response) {
-    const json = await response.json();
-    if (!response.ok) {
-      throw new CimplifyError(
-        json.error?.error_code || "API_ERROR",
-        json.error?.error_message || "An error occurred",
-        false
-      );
+};
+
+// src/types/elements.ts
+var ELEMENT_TYPES = {
+  AUTH: "auth",
+  ADDRESS: "address",
+  PAYMENT: "payment"
+};
+var MESSAGE_TYPES = {
+  // Parent → Iframe
+  INIT: "init",
+  SET_TOKEN: "set_token",
+  GET_DATA: "get_data",
+  REFRESH_TOKEN: "refresh_token",
+  LOGOUT: "logout",
+  PROCESS_CHECKOUT: "process_checkout",
+  ABORT_CHECKOUT: "abort_checkout",
+  // Iframe → Parent
+  READY: "ready",
+  HEIGHT_CHANGE: "height_change",
+  AUTHENTICATED: "authenticated",
+  REQUIRES_OTP: "requires_otp",
+  ERROR: "error",
+  ADDRESS_CHANGED: "address_changed",
+  ADDRESS_SELECTED: "address_selected",
+  PAYMENT_METHOD_SELECTED: "payment_method_selected",
+  TOKEN_REFRESHED: "token_refreshed",
+  LOGOUT_COMPLETE: "logout_complete",
+  CHECKOUT_STATUS: "checkout_status",
+  CHECKOUT_COMPLETE: "checkout_complete"
+};
+var EVENT_TYPES = {
+  READY: "ready",
+  AUTHENTICATED: "authenticated",
+  REQUIRES_OTP: "requires_otp",
+  ERROR: "error",
+  CHANGE: "change",
+  BLUR: "blur",
+  FOCUS: "focus"
+};
+
+// src/elements.ts
+function toCheckoutError(code, message, recoverable) {
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      recoverable
     }
-    return json.data;
-  }
-  async handleResponse(response) {
-    const json = await response.json();
-    if (!json.success || json.error) {
-      throw new CimplifyError(
-        json.error?.code || "UNKNOWN_ERROR",
-        json.error?.message || "An unknown error occurred",
-        json.error?.retryable || false
-      );
+  };
+}
+var DEFAULT_LINK_URL = "https://link.cimplify.io";
+function isAllowedOrigin(origin) {
+  try {
+    const url = new URL(origin);
+    const hostname = url.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return true;
     }
-    return json.data;
-  }
-  get catalogue() {
-    if (!this._catalogue) {
-      this._catalogue = new CatalogueQueries(this);
+    if (url.protocol !== "https:") {
+      return false;
     }
-    return this._catalogue;
+    return hostname === "cimplify.io" || hostname.endsWith(".cimplify.io");
+  } catch {
+    return false;
   }
-  get cart() {
-    if (!this._cart) {
-      this._cart = new CartOperations(this);
-    }
-    return this._cart;
+}
+function parseIframeMessage(data) {
+  if (!data || typeof data !== "object") {
+    return null;
   }
-  get checkout() {
-    if (!this._checkout) {
-      this._checkout = new CheckoutService(this);
-    }
-    return this._checkout;
+  const maybeType = data.type;
+  if (typeof maybeType !== "string") {
+    return null;
   }
-  get orders() {
-    if (!this._orders) {
-      this._orders = new OrderQueries(this);
+  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;
+    this.options = options;
+    this.boundHandleMessage = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.boundHandleMessage);
     }
-    return this._orders;
   }
-  get link() {
-    if (!this._link) {
-      this._link = new LinkService(this);
-    }
-    return this._link;
+  create(type, options = {}) {
+    const existing = this.elements.get(type);
+    if (existing) return existing;
+    const element = new CimplifyElement(type, this.businessId, this.linkUrl, options, this);
+    this.elements.set(type, element);
+    return element;
   }
-  get auth() {
-    if (!this._auth) {
-      this._auth = new AuthService(this);
-    }
-    return this._auth;
+  getElement(type) {
+    return this.elements.get(type);
   }
-  get business() {
-    if (!this._business) {
-      this._business = new BusinessService(this);
+  destroy() {
+    this.elements.forEach((element) => element.destroy());
+    this.elements.clear();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this.boundHandleMessage);
     }
-    return this._business;
   }
-  get inventory() {
-    if (!this._inventory) {
-      this._inventory = new InventoryService(this);
+  async submitCheckout(data) {
+    const result = await this.processCheckout({
+      cart_id: data.cart_id,
+      order_type: data.order_type ?? "delivery",
+      location_id: data.location_id,
+      notes: data.notes,
+      scheduled_time: data.scheduled_time,
+      tip_amount: data.tip_amount,
+      enroll_in_link: true
+    });
+    if (result.success) {
+      return {
+        success: true,
+        order: {
+          id: result.order?.id || "",
+          status: result.order?.status || "unknown",
+          total: result.order?.total || ""
+        }
+      };
     }
-    return this._inventory;
+    return {
+      success: false,
+      error: {
+        code: result.error?.code || "CHECKOUT_FAILED",
+        message: result.error?.message || "Checkout failed"
+      }
+    };
   }
-  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;
+  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;
   }
-  get fx() {
-    if (!this._fx) {
-      this._fx = new FxService(this);
-    }
-    return this._fx;
+  isAuthenticated() {
+    return this.accessToken !== null;
   }
-  /**
-   * 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);
+  getAccessToken() {
+    return this.accessToken;
   }
-};
-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;
+  getPublicKey() {
+    return this.client.getPublicKey();
   }
-  path(segment) {
-    this.pathSegments.push(segment);
-    return this;
+  getAppearance() {
+    return this.options.appearance;
   }
-  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}`);
+  async hydrateCustomerData() {
+    if (!this.accessToken || this.customerData) {
+      return;
     }
-    return this;
+    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
+    };
   }
-  and(field, op, value) {
-    return this.where(field, op, value);
+  handleMessage(event) {
+    if (!isAllowedOrigin(event.origin)) {
+      return;
+    }
+    const message = parseIframeMessage(event.data);
+    if (!message) return;
+    switch (message.type) {
+      case MESSAGE_TYPES.AUTHENTICATED:
+        const customer = message.customer ?? {
+          name: "",
+          email: null,
+          phone: null
+        };
+        this.accessToken = message.token;
+        this.accountId = message.accountId;
+        this.customerId = message.customerId;
+        this.customerData = customer;
+        this.client.setAccessToken(message.token);
+        this.elements.forEach((element, type) => {
+          if (type !== ELEMENT_TYPES.AUTH) {
+            element.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token: message.token });
+          }
+        });
+        break;
+      case MESSAGE_TYPES.TOKEN_REFRESHED:
+        this.accessToken = message.token;
+        break;
+      case MESSAGE_TYPES.ADDRESS_CHANGED:
+      case MESSAGE_TYPES.ADDRESS_SELECTED:
+        this.addressData = message.address;
+        break;
+      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
+        this.paymentData = message.method;
+        break;
+      case MESSAGE_TYPES.LOGOUT_COMPLETE:
+        if (this.checkoutInProgress && this.activeCheckoutAbort) {
+          this.activeCheckoutAbort();
+        }
+        this.accessToken = null;
+        this.accountId = null;
+        this.customerId = null;
+        this.customerData = null;
+        this.addressData = null;
+        this.paymentData = null;
+        this.client.clearSession();
+        break;
+    }
   }
-  sort(field, order = "asc") {
-    this.modifiers.push(`sort(${field},${order})`);
-    return this;
+  _setAddressData(data) {
+    this.addressData = data;
   }
-  limit(n) {
-    this.modifiers.push(`limit(${n})`);
-    return this;
+  _setPaymentData(data) {
+    this.paymentData = data;
   }
-  offset(n) {
-    this.modifiers.push(`offset(${n})`);
-    return this;
+};
+var CimplifyElement = class {
+  constructor(type, businessId, linkUrl, options, parent) {
+    this.iframe = null;
+    this.container = null;
+    this.mounted = false;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+    this.type = type;
+    this.businessId = businessId;
+    this.linkUrl = linkUrl;
+    this.options = options;
+    this.parent = parent;
+    this.boundHandleMessage = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.boundHandleMessage);
+    }
   }
-  count() {
-    this.modifiers.push("count");
-    return this;
+  mount(container) {
+    if (this.mounted) {
+      console.warn(`Element ${this.type} is already mounted`);
+      return;
+    }
+    const target = typeof container === "string" ? document.querySelector(container) : container;
+    if (!target) {
+      console.error(`Container not found: ${container}`);
+      return;
+    }
+    this.container = target;
+    this.createIframe();
+    this.mounted = true;
   }
-  enriched() {
-    this.modifiers.push("enriched");
-    return this;
+  destroy() {
+    if (this.iframe) {
+      this.iframe.remove();
+      this.iframe = null;
+    }
+    this.container = null;
+    this.mounted = false;
+    this.eventHandlers.clear();
+    this.resolvers.forEach((entry) => clearTimeout(entry.timeoutId));
+    this.resolvers.clear();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this.boundHandleMessage);
+    }
   }
-  build() {
-    let query2 = this.entity;
-    if (this.pathSegments.length > 0) {
-      query2 += "." + this.pathSegments.join(".");
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
     }
-    if (this.filters.length > 0) {
-      query2 += `[?(${this.filters.join(" && ")})]`;
+    this.eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  async getData() {
+    if (!this.isMounted()) {
+      return null;
     }
-    for (const mod of this.modifiers) {
-      query2 += `#${mod}`;
+    return new Promise((resolve) => {
+      const id = Math.random().toString(36).slice(2);
+      const timeoutId = setTimeout(() => {
+        const entry = this.resolvers.get(id);
+        if (!entry) {
+          return;
+        }
+        this.resolvers.delete(id);
+        entry.resolve(null);
+      }, 5e3);
+      this.resolvers.set(id, { resolve, timeoutId });
+      this.sendMessage({ type: MESSAGE_TYPES.GET_DATA });
+    });
+  }
+  sendMessage(message) {
+    if (this.iframe?.contentWindow) {
+      this.iframe.contentWindow.postMessage(message, this.linkUrl);
     }
-    return query2;
   }
-  toString() {
-    return this.build();
+  getContentWindow() {
+    return this.iframe?.contentWindow ?? null;
   }
-};
-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`;
+  isMounted() {
+    return this.mounted && Boolean(this.iframe) && this.iframe?.isConnected === true;
   }
-  try {
-    return new Intl.NumberFormat(locale, {
-      style: "currency",
-      currency: currency.toUpperCase(),
-      minimumFractionDigits: 2,
-      maximumFractionDigits: 2
-    }).format(numAmount);
-  } catch {
-    return `${getCurrencySymbol(currency)}${numAmount.toFixed(2)}`;
+  createIframe() {
+    if (!this.container) return;
+    const iframe = document.createElement("iframe");
+    const url = new URL(`${this.linkUrl}/elements/${this.type}`);
+    url.searchParams.set("businessId", this.businessId);
+    if (this.options.prefillEmail) url.searchParams.set("email", this.options.prefillEmail);
+    if (this.options.mode) url.searchParams.set("mode", this.options.mode);
+    iframe.src = url.toString();
+    iframe.style.border = "none";
+    iframe.style.width = "100%";
+    iframe.style.display = "block";
+    iframe.style.overflow = "hidden";
+    iframe.setAttribute("allowtransparency", "true");
+    iframe.setAttribute("frameborder", "0");
+    iframe.setAttribute(
+      "sandbox",
+      "allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox"
+    );
+    this.iframe = iframe;
+    this.container.appendChild(iframe);
+    iframe.onload = () => {
+      const publicKey = this.parent.getPublicKey();
+      this.sendMessage({
+        type: MESSAGE_TYPES.INIT,
+        businessId: this.businessId,
+        publicKey,
+        demoMode: publicKey.length === 0,
+        prefillEmail: this.options.prefillEmail,
+        appearance: this.parent.getAppearance()
+      });
+      const token = this.parent.getAccessToken();
+      if (token && this.type !== ELEMENT_TYPES.AUTH) {
+        this.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token });
+      }
+    };
   }
-}
-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}`;
+  handleMessage(event) {
+    if (!isAllowedOrigin(event.origin)) {
+      return;
+    }
+    const message = parseIframeMessage(event.data);
+    if (!message) return;
+    switch (message.type) {
+      case MESSAGE_TYPES.READY:
+        this.emit(EVENT_TYPES.READY, { height: message.height });
+        break;
+      case MESSAGE_TYPES.HEIGHT_CHANGE:
+        if (this.iframe) this.iframe.style.height = `${message.height}px`;
+        break;
+      case MESSAGE_TYPES.AUTHENTICATED:
+        const customer = message.customer ?? {
+          name: "",
+          email: null,
+          phone: null
+        };
+        this.emit(EVENT_TYPES.AUTHENTICATED, {
+          accountId: message.accountId,
+          customerId: message.customerId,
+          token: message.token,
+          customer
+        });
+        break;
+      case MESSAGE_TYPES.REQUIRES_OTP:
+        this.emit(EVENT_TYPES.REQUIRES_OTP, { contactMasked: message.contactMasked });
+        break;
+      case MESSAGE_TYPES.ERROR:
+        this.emit(EVENT_TYPES.ERROR, { code: message.code, message: message.message });
+        break;
+      case MESSAGE_TYPES.ADDRESS_CHANGED:
+      case MESSAGE_TYPES.ADDRESS_SELECTED:
+        this.parent._setAddressData(message.address);
+        this.emit(EVENT_TYPES.CHANGE, { address: message.address });
+        this.resolveData(message.address);
+        break;
+      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
+        this.parent._setPaymentData(message.method);
+        this.emit(EVENT_TYPES.CHANGE, { paymentMethod: message.method });
+        this.resolveData(message.method);
+        break;
+    }
   }
-  return formatted;
-}
-function formatPriceCompact(amount, currency = "GHS", decimals = 1) {
-  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
-  if (isNaN(numAmount)) {
-    return `${getCurrencySymbol(currency)}0`;
+  emit(event, data) {
+    this.eventHandlers.get(event)?.forEach((handler) => handler(data));
   }
-  const symbol = getCurrencySymbol(currency);
-  if (Math.abs(numAmount) < 1e3) {
-    return `${symbol}${numAmount.toFixed(2)}`;
+  resolveData(data) {
+    this.resolvers.forEach((entry) => {
+      clearTimeout(entry.timeoutId);
+      entry.resolve(data);
+    });
+    this.resolvers.clear();
   }
-  return `${symbol}${formatNumberCompact(numAmount, decimals)}`;
+};
+function createElements(client, businessId, options) {
+  return new CimplifyElements(client, businessId, options);
 }
-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)}`;
+
+// src/client.ts
+var ACCESS_TOKEN_STORAGE_KEY = "cimplify_access_token";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY_MS = 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function parsePrice(value) {
-  if (value === void 0 || value === null) {
-    return 0;
-  }
-  if (typeof value === "number") {
-    return isNaN(value) ? 0 : value;
+function isRetryable(error) {
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return true;
   }
-  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 (error instanceof DOMException && error.name === "AbortError") {
+    return true;
   }
-  if (product.final_price !== void 0 && product.final_price !== null) {
-    return parsePrice(product.final_price);
+  if (error instanceof CimplifyError) {
+    return error.retryable;
   }
-  if (product.default_price !== void 0 && product.default_price !== null) {
-    return parsePrice(product.default_price);
+  if (error instanceof CimplifyError && error.code === "SERVER_ERROR") {
+    return true;
   }
-  return 0;
+  return false;
 }
-function getBasePrice(product) {
-  if (product.price_info) {
-    return parsePrice(product.price_info.base_price);
+function toNetworkError(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return new CimplifyError(
+      ErrorCode.TIMEOUT,
+      "Request timed out. Please check your connection and try again.",
+      true
+    );
   }
-  if (product.base_price !== void 0 && product.base_price !== null) {
-    return parsePrice(product.base_price);
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return new CimplifyError(
+      ErrorCode.NETWORK_ERROR,
+      "Network error. Please check your internet connection.",
+      true
+    );
   }
-  if (product.default_price !== void 0 && product.default_price !== null) {
-    return parsePrice(product.default_price);
+  if (error instanceof CimplifyError) {
+    return error;
   }
-  return 0;
-}
-function isOnSale(product) {
-  const basePrice = getBasePrice(product);
-  const finalPrice = getDisplayPrice(product);
-  return basePrice > finalPrice && basePrice > 0;
+  return new CimplifyError(
+    ErrorCode.UNKNOWN_ERROR,
+    error instanceof Error ? error.message : "An unknown error occurred",
+    false
+  );
 }
-function getDiscountPercentage(product) {
-  const basePrice = getBasePrice(product);
-  const finalPrice = getDisplayPrice(product);
-  if (basePrice > finalPrice && basePrice > 0) {
-    return Math.round((basePrice - finalPrice) / basePrice * 100);
+function deriveUrls() {
+  const hostname = typeof window !== "undefined" ? window.location.hostname : "";
+  if (hostname === "localhost" || hostname === "127.0.0.1") {
+    const protocol = window.location.protocol;
+    return {
+      baseUrl: `${protocol}//${hostname}:8082`,
+      linkApiUrl: `${protocol}//${hostname}:8080`
+    };
   }
-  return 0;
+  return {
+    baseUrl: "https://storefronts.cimplify.io",
+    linkApiUrl: "https://api.cimplify.io"
+  };
 }
-function getMarkupPercentage(product) {
-  const basePrice = getBasePrice(product);
-  const finalPrice = getDisplayPrice(product);
-  if (finalPrice > basePrice && basePrice > 0) {
-    return Math.round((finalPrice - basePrice) / basePrice * 100);
+function getEnvPublicKey() {
+  try {
+    const env = globalThis.process;
+    return env?.env.NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY || void 0;
+  } catch {
+    return void 0;
   }
-  return 0;
 }
-function getProductCurrency(product) {
-  if (product.price_info?.currency) {
-    return product.price_info.currency;
-  }
-  if (product.currency) {
-    return product.currency;
+var CimplifyClient = class {
+  constructor(config = {}) {
+    this.accessToken = null;
+    this.context = {};
+    this.inflightRequests = /* @__PURE__ */ new Map();
+    this.publicKey = config.publicKey || getEnvPublicKey() || "";
+    const urls = deriveUrls();
+    this.baseUrl = urls.baseUrl;
+    this.linkApiUrl = urls.linkApiUrl;
+    this.credentials = config.credentials || "include";
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
+    this.hooks = config.hooks ?? {};
+    this.accessToken = this.loadAccessToken();
+    if (!this.publicKey) {
+      console.warn(
+        '[Cimplify] No public key found. Set NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY in your environment, or pass { publicKey: "pk_..." } to createCimplifyClient().'
+      );
+    }
   }
-  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.";
+  /** @deprecated Use getAccessToken() instead */
+  getSessionToken() {
+    return this.accessToken;
   }
-  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: {}
+  /** @deprecated Use setAccessToken() instead */
+  setSessionToken(token) {
+    this.setAccessToken(token);
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  getPublicKey() {
+    return this.publicKey;
+  }
+  setAccessToken(token) {
+    const previous = this.accessToken;
+    this.accessToken = token;
+    this.saveAccessToken(token);
+    this.hooks.onSessionChange?.({
+      previousToken: previous,
+      newToken: token,
+      source: "manual"
+    });
+  }
+  clearSession() {
+    const previous = this.accessToken;
+    this.accessToken = null;
+    this.saveAccessToken(null);
+    this.hooks.onSessionChange?.({
+      previousToken: previous,
+      newToken: null,
+      source: "clear"
+    });
+  }
+  /** Set the active location/branch for all subsequent requests */
+  setLocationId(locationId) {
+    if (locationId) {
+      this.context.location_id = locationId;
+    } else {
+      delete this.context.location_id;
+    }
+  }
+  /** Get the currently active location ID */
+  getLocationId() {
+    return this.context.location_id ?? null;
+  }
+  loadAccessToken() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return localStorage.getItem(ACCESS_TOKEN_STORAGE_KEY);
+    }
+    return null;
+  }
+  saveAccessToken(token) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      if (token) {
+        localStorage.setItem(ACCESS_TOKEN_STORAGE_KEY, token);
+      } else {
+        localStorage.removeItem(ACCESS_TOKEN_STORAGE_KEY);
+      }
+    }
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.publicKey
+    };
+    if (this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    return headers;
+  }
+  async resilientFetch(url, options) {
+    const method = options.method || "GET";
+    const path = url.replace(this.baseUrl, "").replace(this.linkApiUrl, "");
+    const startTime = Date.now();
+    let retryCount = 0;
+    const context = {
+      method,
+      path,
+      url,
+      body: options.body ? JSON.parse(options.body) : void 0,
+      startTime
     };
+    this.hooks.onRequestStart?.(context);
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          ...options,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok || response.status >= 400 && response.status < 500) {
+          this.hooks.onRequestSuccess?.({
+            ...context,
+            status: response.status,
+            durationMs: Date.now() - startTime
+          });
+          return response;
+        }
+        if (response.status >= 500 && attempt < this.maxRetries) {
+          retryCount++;
+          const delay = this.retryDelay * Math.pow(2, attempt);
+          this.hooks.onRetry?.({
+            ...context,
+            attempt: retryCount,
+            delayMs: delay,
+            error: new Error(`Server error: ${response.status}`)
+          });
+          await sleep(delay);
+          continue;
+        }
+        this.hooks.onRequestSuccess?.({
+          ...context,
+          status: response.status,
+          durationMs: Date.now() - startTime
+        });
+        return response;
+      } catch (error) {
+        lastError = error;
+        const networkError = toNetworkError(error);
+        const errorRetryable = isRetryable(error);
+        if (!errorRetryable || attempt >= this.maxRetries) {
+          this.hooks.onRequestError?.({
+            ...context,
+            error: networkError,
+            durationMs: Date.now() - startTime,
+            retryCount,
+            retryable: errorRetryable
+          });
+          throw networkError;
+        }
+        retryCount++;
+        const delay = this.retryDelay * Math.pow(2, attempt);
+        this.hooks.onRetry?.({
+          ...context,
+          attempt: retryCount,
+          delayMs: delay,
+          error: networkError
+        });
+        await sleep(delay);
+      }
+    }
+    const finalError = toNetworkError(lastError);
+    this.hooks.onRequestError?.({
+      ...context,
+      error: finalError,
+      durationMs: Date.now() - startTime,
+      retryCount,
+      retryable: false
+    });
+    throw finalError;
+  }
+  getDedupeKey(type, payload) {
+    return `${type}:${JSON.stringify(payload)}`;
+  }
+  async deduplicatedRequest(key, requestFn) {
+    const existing = this.inflightRequests.get(key);
+    if (existing) {
+      return existing;
+    }
+    const request = requestFn().finally(() => {
+      this.inflightRequests.delete(key);
+    });
+    this.inflightRequests.set(key, request);
+    return request;
+  }
+  async query(query2, variables) {
+    const body = { query: query2 };
+    if (variables) {
+      body.variables = variables;
+    }
+    if (Object.keys(this.context).length > 0) {
+      body.context = this.context;
+    }
+    const key = this.getDedupeKey("query", body);
+    return this.deduplicatedRequest(key, async () => {
+      const response = await this.resilientFetch(`${this.baseUrl}/api/q`, {
+        method: "POST",
+        credentials: this.credentials,
+        headers: this.getHeaders(),
+        body: JSON.stringify(body)
+      });
+      return this.handleResponse(response);
+    });
+  }
+  async call(method, args) {
+    const body = {
+      method,
+      args: args !== void 0 ? [args] : []
+    };
+    if (Object.keys(this.context).length > 0) {
+      body.context = this.context;
+    }
+    const response = await this.resilientFetch(`${this.baseUrl}/api/m`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: JSON.stringify(body)
+    });
+    return this.handleResponse(response);
+  }
+  async get(path) {
+    const key = this.getDedupeKey("get", path);
+    return this.deduplicatedRequest(key, async () => {
+      const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
+        method: "GET",
+        credentials: this.credentials,
+        headers: this.getHeaders()
+      });
+      return this.handleRestResponse(response);
+    });
+  }
+  async post(path, body) {
+    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRestResponse(response);
+  }
+  async delete(path) {
+    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
+      method: "DELETE",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    return this.handleRestResponse(response);
+  }
+  async linkGet(path) {
+    const key = this.getDedupeKey("linkGet", path);
+    return this.deduplicatedRequest(key, async () => {
+      const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
+        method: "GET",
+        credentials: this.credentials,
+        headers: this.getHeaders()
+      });
+      return this.handleRestResponse(response);
+    });
+  }
+  async linkPost(path, body) {
+    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRestResponse(response);
+  }
+  async linkDelete(path) {
+    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
+      method: "DELETE",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    return this.handleRestResponse(response);
+  }
+  async handleRestResponse(response) {
+    const json = await response.json();
+    if (!response.ok) {
+      throw new CimplifyError(
+        json.error?.error_code || "API_ERROR",
+        json.error?.error_message || "An error occurred",
+        false
+      );
+    }
+    return json.data;
+  }
+  async handleResponse(response) {
+    const json = await response.json();
+    if (!json.success || json.error) {
+      throw new CimplifyError(
+        json.error?.code || "UNKNOWN_ERROR",
+        json.error?.message || "An unknown error occurred",
+        json.error?.retryable || false
+      );
+    }
+    return json.data;
+  }
+  get catalogue() {
+    if (!this._catalogue) {
+      this._catalogue = new CatalogueQueries(this);
+    }
+    return this._catalogue;
+  }
+  get cart() {
+    if (!this._cart) {
+      this._cart = new CartOperations(this);
+    }
+    return this._cart;
+  }
+  get checkout() {
+    if (!this._checkout) {
+      this._checkout = new CheckoutService(this);
+    }
+    return this._checkout;
+  }
+  get orders() {
+    if (!this._orders) {
+      this._orders = new OrderQueries(this);
+    }
+    return this._orders;
+  }
+  get link() {
+    if (!this._link) {
+      this._link = new LinkService(this);
+    }
+    return this._link;
+  }
+  get auth() {
+    if (!this._auth) {
+      this._auth = new AuthService(this);
+    }
+    return this._auth;
+  }
+  get business() {
+    if (!this._business) {
+      this._business = new BusinessService(this);
+    }
+    return this._business;
+  }
+  get inventory() {
+    if (!this._inventory) {
+      this._inventory = new InventoryService(this);
+    }
+    return this._inventory;
+  }
+  get scheduling() {
+    if (!this._scheduling) {
+      this._scheduling = new SchedulingService(this);
+    }
+    return this._scheduling;
+  }
+  get lite() {
+    if (!this._lite) {
+      this._lite = new LiteService(this);
+    }
+    return this._lite;
   }
-  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
-    };
+  get fx() {
+    if (!this._fx) {
+      this._fx = new FxService(this);
+    }
+    return this._fx;
   }
-  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
-    };
+  /**
+   * 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 {
-    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 createCimplifyClient(config = {}) {
+  return new CimplifyClient(config);
 }
-function normalizePaymentStatusValue(status) {
-  const normalized = normalizeStatusToken(status);
-  if (Object.prototype.hasOwnProperty.call(PAYMENT_STATUS_ALIAS_MAP, normalized)) {
-    return PAYMENT_STATUS_ALIAS_MAP[normalized];
+
+// src/query/builder.ts
+var QueryBuilder = class {
+  constructor(entity) {
+    this.filters = [];
+    this.modifiers = [];
+    this.pathSegments = [];
+    this.entity = entity;
   }
-  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"
-    };
+  path(segment) {
+    this.pathSegments.push(segment);
+    return this;
   }
-  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;
+  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 null;
+  and(field, op, value) {
+    return this.where(field, op, value);
+  }
+  sort(field, order = "asc") {
+    this.modifiers.push(`sort(${field},${order})`);
+    return this;
+  }
+  limit(n) {
+    this.modifiers.push(`limit(${n})`);
+    return this;
+  }
+  offset(n) {
+    this.modifiers.push(`offset(${n})`);
+    return this;
+  }
+  count() {
+    this.modifiers.push("count");
+    return this;
+  }
+  enriched() {
+    this.modifiers.push("enriched");
+    return this;
+  }
+  build() {
+    let query2 = this.entity;
+    if (this.pathSegments.length > 0) {
+      query2 += "." + this.pathSegments.join(".");
+    }
+    if (this.filters.length > 0) {
+      query2 += `[?(${this.filters.join(" && ")})]`;
+    }
+    for (const mod of this.modifiers) {
+      query2 += `#${mod}`;
+    }
+    return query2;
+  }
+  toString() {
+    return this.build();
+  }
+};
+function query(entity) {
+  return new QueryBuilder(entity);
 }
 
 exports.AUTHORIZATION_TYPE = AUTHORIZATION_TYPE;